iOS LLVM 中的宏定义

在阅读 Objc 库源码时常常会遇到很多宏定义，比如宏 SUPPORT_INDEXED_ISA、SUPPORT_PACKED_ISA，代码如下所示:

// Define SUPPORT_INDEXED_ISA=1 on platforms that store the class in the isa 

// field as an index into a class table.

// Note, keep this in sync with any .s files which also define it.

// Be sure to edit objc-abi.h as well.

#if __ARM_ARCH_7K__ >= 2  ||  (__arm64__ && !__LP64__)

#   define SUPPORT_INDEXED_ISA 1

#else

#   define SUPPORT_INDEXED_ISA 0

#endif


// Define SUPPORT_PACKED_ISA=1 on platforms that store the class in the isa 

// field as a maskable pointer with other data around it.

#if (!__LP64__  ||  TARGET_OS_WIN32  ||  \

     (TARGET_OS_SIMULATOR && !TARGET_OS_MACCATALYST && !__arm64__))

#   define SUPPORT_PACKED_ISA 0

#else

#   define SUPPORT_PACKED_ISA 1

#endif

在上面的宏定义中，__ARM_ARCH_7K__、__arm64__、__LP64__ 这些宏在 Objc 库中找不到定义的源码。如果不清楚这些宏的意义，对阅读源码会带来一定的障碍。实际上，这些宏都定义在 LLVM 源码中(基本上找不到定义的宏，都可以在 LLVM 源码中找到)。

__ARM_ARCH_7K__

在 LLVM 源码 ARM.cpp 中，可以看到对 __ARM_ARCH_7K__ 的定义，源码如下:

// file: ARM.cpp

// Unfortunately, __ARM_ARCH_7K__ is now more of an ABI descriptor. The CPU
  // happens to be Cortex-A7 though, so it should still get __ARM_ARCH_7A__.
  if (getTriple().isWatchABI()) // 判断是否是 Watch 的ABI
    Builder.defineMacro("__ARM_ARCH_7K__", "2");

从源码看到，这个宏是在 Apple Watch 下生效，在 iPhone 设备上该宏不会生效。

__arm64__

在 LLVM 源码 AArch64.cpp 中，可以看到对 __arm64__ 的定义，源码如下:

void DarwinAArch64TargetInfo::getOSDefines(const LangOptions &Opts,
                                           const llvm::Triple &Triple,
                                           MacroBuilder &Builder) const {
  Builder.defineMacro("__AARCH64_SIMD__");
  if (Triple.isArch32Bit())
    Builder.defineMacro("__ARM64_ARCH_8_32__");
  else
    Builder.defineMacro("__ARM64_ARCH_8__");
  Builder.defineMacro("__ARM_NEON__");
  Builder.defineMacro("__LITTLE_ENDIAN__");
  Builder.defineMacro("__REGISTER_PREFIX__", "");
  Builder.defineMacro("__arm64", "1");
  Builder.defineMacro("__arm64__", "1"); // __arm64__ 定义

  if (Triple.isArm64e())
    Builder.defineMacro("__arm64e__", "1");

  getDarwinDefines(Builder, Opts, Triple, PlatformName, PlatformMinVersion);
}

从源码上可以看到，只要 ARM CPU 是 64bit，就会定义 __arm64__ 宏，虽然可能这个 CPU 使用的是 ILP32(见下文)。

__LP64__

在 LLVM 源码 InitPreprocessor.cpp 中，可以看到对 __LP64__ 的定义，源码如下:

// file: InitPreprocessor.cpp

static void InitializePredefinedMacros(const TargetInfo &TI,
const LangOptions &LangOpts,
const FrontendOptions &FEOpts,
const PreprocessorOptions &PPOpts,
MacroBuilder &Builder) {
...

if (TI.getPointerWidth(0) == 64 && TI.getLongWidth() == 64
&& TI.getIntWidth() == 32) {
Builder.defineMacro("_LP64");
Builder.defineMacro("__LP64__"); // 定义 __LP64__
}

if (TI.getPointerWidth(0) == 32 && TI.getLongWidth() == 32
&& TI.getIntWidth() == 32) {
Builder.defineMacro("_ILP32");
Builder.defineMacro("__ILP32__"); // 定义 __ILP32__
}

...

// Get other target #defines.
TI.getTargetDefines(LangOpts, Builder); // 该方法会重新定义 __LP64__
}

从上面源码可以看到，如果指针 pointer 的长度是 64bit，long 类型的长度是 64bit，int 类型的长度是 32bit，那么就定义宏 __LP64__。

如果指针 pointer 的长度是 32bit，long 类型的长度是 32bit，int 类型的长度是 32bit，那么就定义宏 __ILP32__。

源码最后一行 TI.getTargetDefines(LangOpts, Builder) 在 ARM 架构下重新定义 __LP64__，相关源码位于 AArch64.cpp:

// file: AArch64.cpp

void AArch64TargetInfo::getTargetDefines(const LangOptions &Opts,
                                         MacroBuilder &Builder) const {
  // Target identification.
  Builder.defineMacro("__aarch64__");
  // For bare-metal.
  if (getTriple().getOS() == llvm::Triple::UnknownOS &&
      getTriple().isOSBinFormatELF())
    Builder.defineMacro("__ELF__");

  // Target properties.
  if (!getTriple().isOSWindows() && getTriple().isArch64Bit()) { // 在非 Windows 下，并且真正支持 64bit 指针的 CPU 架构下才定义 __LP64__
    Builder.defineMacro("_LP64");
    Builder.defineMacro("__LP64__");
  }

  ...

}

从上面的源码可以看到，非 Windows 系统 & 真正支持 64bit 指针的 CPU 架构才会定义 __LP64__。那么哪些类型的 CPU 支持 64bit 的指针呢? 通过查看 Triple::isArch64Bit 方法可以得到答案:

// file: Triple.cpp

bool Triple::isArch64Bit() const {
  return getArchPointerBitWidth(getArch()) == 64;
}

static unsigned getArchPointerBitWidth(llvm::Triple::ArchType Arch) {

  switch (Arch) {

  case llvm::Triple::UnknownArch:

    return 0;

 

  case llvm::Triple::avr:

  case llvm::Triple::msp430:

    return 16;

 

  case llvm::Triple::aarch64_32:

  case llvm::Triple::amdil:

  case llvm::Triple::arc:

  case llvm::Triple::arm:

  case llvm::Triple::armeb:

  case llvm::Triple::csky:

  case llvm::Triple::dxil:

  case llvm::Triple::hexagon:

  case llvm::Triple::hsail:

  case llvm::Triple::kalimba:

  case llvm::Triple::lanai:

  case llvm::Triple::le32:

  case llvm::Triple::loongarch32:

  case llvm::Triple::m68k:

  case llvm::Triple::mips:

  case llvm::Triple::mipsel:

  case llvm::Triple::nvptx:

  case llvm::Triple::ppc:

  case llvm::Triple::ppcle:

  case llvm::Triple::r600:

  case llvm::Triple::renderscript32:

  case llvm::Triple::riscv32:

  case llvm::Triple::shave:

  case llvm::Triple::sparc:

  case llvm::Triple::sparcel:

  case llvm::Triple::spir:

  case llvm::Triple::spirv32:

  case llvm::Triple::tce:

  case llvm::Triple::tcele:

  case llvm::Triple::thumb:

  case llvm::Triple::thumbeb:

  case llvm::Triple::wasm32:

  case llvm::Triple::x86:

  case llvm::Triple::xcore:

    return 32;

 

  case llvm::Triple::aarch64:

  case llvm::Triple::aarch64_be:

  case llvm::Triple::amdgcn:

  case llvm::Triple::amdil64:

  case llvm::Triple::bpfeb:

  case llvm::Triple::bpfel:

  case llvm::Triple::hsail64:

  case llvm::Triple::le64:

  case llvm::Triple::loongarch64:

  case llvm::Triple::mips64:

  case llvm::Triple::mips64el:

  case llvm::Triple::nvptx64:

  case llvm::Triple::ppc64:

  case llvm::Triple::ppc64le:

  case llvm::Triple::renderscript64:

  case llvm::Triple::riscv64:

  case llvm::Triple::sparcv9:

  case llvm::Triple::spir64:

  case llvm::Triple::spirv64:

  case llvm::Triple::systemz:

  case llvm::Triple::ve:

  case llvm::Triple::wasm64:

  case llvm::Triple::x86_64:

    return 64;

  }

  llvm_unreachable("Invalid architecture value");

}

上面源码需要注意的一个 CPU 架构是 aarch64_32，这种 ARM 架构的 CPU 虽然是 64bit 的，但是 int、long、pointer 都使用 32bit 表示(即 ILP32)。这种 CPU 通常用在嵌入式里面，Apple Watch Series 4/5 就是使用的这种 CPU:

由于 Apple 从 iPhone 5S 就开始支持 64bit 的 CPU，因此在 >= iPhone 5S 的设备上，SUPPORT_INDEXED_ISA 定义为0，SUPPORT_PACKED_ISA 定义为1。

__OBJC__

___OBJC__ 宏定义在 LLVM 源码的 InitPreprocessor.cpp 文件，源码如下:

// file: InitPreprocessor.cpp

static void InitializeStandardPredefinedMacros(const TargetInfo &TI,
                                               const LangOptions &LangOpts,
                                               const FrontendOptions &FEOpts,
                                               MacroBuilder &Builder) {
  ...

  if (LangOpts.ObjC)
    Builder.defineMacro("__OBJC__"); // 定义 __OBJC__ 宏

  ...
}

从源码可以看到，如果编译的语言是Objective-C，那么这个宏就会被定义。

__OBJC2__

__OBJC2__ 宏定义在 LLVM 源码的 InitPreprocessor.cpp 文件，源码如下:

// file: InitPreprocessor.cpp

static void InitializePredefinedMacros(const TargetInfo &TI,
                                       const LangOptions &LangOpts,
                                       const FrontendOptions &FEOpts,
                                       const PreprocessorOptions &PPOpts,
                                       MacroBuilder &Builder) {
  ...

  if (LangOpts.ObjC) {
    if (LangOpts.ObjCRuntime.isNonFragile()) {
      Builder.defineMacro("__OBJC2__"); // 如果是 Objective-C 语言，并且满足 non fragile，就定义 __OBJC2__


  ...
}

对于 __OBJC2__ 宏的定义中，除了判断是 Objectvie-C 语言，还需要判断 non-fragile 条件。该条件判断的源码如下:

  // file: ObjcRuntime.h

  bool isNonFragile() const {
    switch (getKind()) {
    case FragileMacOSX: return false;
    case GCC: return false;
    case MacOSX: return true; // Mac
    case GNUstep: return true;
    case ObjFW: return true;
    case iOS: return true; // iOS
    case WatchOS: return true; // Watch
    }
    llvm_unreachable("bad kind");
  }

从源码可以看到，对于 iOS 系统和 Watch OS 系统，__OBJC2__ 宏是一定会定义的。但是对于 MAC 系统就要区分 MacOSX 与 FragileMacOSX。这些类型的定义源码如下:

// file: ObjcRuntime.h

class ObjCRuntime {
public:
  /// The basic Objective-C runtimes that we know about.
  enum Kind {
    /// 'macosx' is the Apple-provided NeXT-derived runtime on Mac OS
    /// X platforms that use the non-fragile ABI; the version is a
    /// release of that OS.
    MacOSX,

    /// 'macosx-fragile' is the Apple-provided NeXT-derived runtime on
    /// Mac OS X platforms that use the fragile ABI; the version is a
    /// release of that OS.
    FragileMacOSX,

    /// 'ios' is the Apple-provided NeXT-derived runtime on iOS or the iOS
    /// simulator;  it is always non-fragile.  The version is a release
    /// version of iOS.
    iOS,

    /// 'watchos' is a variant of iOS for Apple's watchOS. The version
    /// is a release version of watchOS.
    WatchOS,

    /// 'gcc' is the Objective-C runtime shipped with GCC, implementing a
    /// fragile Objective-C ABI
    GCC,

    /// 'gnustep' is the modern non-fragile GNUstep runtime.
    GNUstep,

    /// 'objfw' is the Objective-C runtime included in ObjFW
    ObjFW
  };

  ...
}

__has_feature

__has_feature 宏可以帮助我们判断一个功能是否可以由 Clang 编译器支持，Clang 文档原文如下:

These function-like macros take a single identifier argument that is the name of a feature. __has_feature evaluates to 1 if the feature is both supported by Clang and standardized in the current language standard or 0 if not

那么它的实现是怎样的呢？

首先 Clang 会注册 __has_feature 宏，注册的结果被保存在 Preprocessor 对象的实例变量 Ident__has_feature 中。源码如下所示:

 /// file: PPMacroExpansion.cpp

/// RegisterBuiltinMacros - Register builtin macros, such as __LINE__ with the
/// identifier table.
void Preprocessor::RegisterBuiltinMacros() {
  // 注入了许多常见的内置宏
  Ident__LINE__ = RegisterBuiltinMacro(*this, "__LINE__");
  Ident__FILE__ = RegisterBuiltinMacro(*this, "__FILE__");
  Ident__DATE__ = RegisterBuiltinMacro(*this, "__DATE__");
  Ident__TIME__ = RegisterBuiltinMacro(*this, "__TIME__");
  Ident__COUNTER__ = RegisterBuiltinMacro(*this, "__COUNTER__");
  Ident_Pragma  = RegisterBuiltinMacro(*this, "_Pragma");

  ...

  // Clang Extensions.
  Ident__FILE_NAME__      = RegisterBuiltinMacro(*this, "__FILE_NAME__");
  Ident__has_feature      = RegisterBuiltinMacro(*this, "__has_feature");  // __has_feature 被注入
  Ident__has_extension    = RegisterBuiltinMacro(*this, "__has_extension"); // __has_extension 被注入
  Ident__has_builtin      = RegisterBuiltinMacro(*this, "__has_builtin"); // __has_builtin 被注入

  ...
}

当 Clang 预编译源文件时如果遇到了 __has_feature 标识符，就会进行扩展，扩展的代码如下所示:

// file: PPMacroExpansion.cpp

void Preprocessor::ExpandBuiltinMacro(Token &Tok) {
   ...

   } else if (II == Ident__has_feature) {
    EvaluateFeatureLikeBuiltinMacro(OS, Tok, II, *this, false,
      [this](Token &Tok, bool &HasLexedNextToken) -> int {
        IdentifierInfo *II = ExpectFeatureIdentifierInfo(Tok, *this,
                                           diag::err_feature_check_malformed);
        return II && HasFeature(*this, II->getName()); // 最终 Clang 编译器调用 HasFeature 函数进行判断
      });
  } else if (II == Ident__has_extension) {
    ...
  }

  ...
}

从源码可以看到，Clang 的扩展结果通过调用 HasFeature 函数获取，HasFeature 函数接收要检测的功能名作为参数，源码如下:

// file: PPMacroExpansion.cpp

static bool HasFeature(const Preprocessor &PP, StringRef Feature) {
  const LangOptions &LangOpts = PP.getLangOpts();

  // Normalize the feature name, __foo__ becomes foo.
  if (Feature.startswith("__") && Feature.endswith("__") && Feature.size() >= 4)
    Feature = Feature.substr(2, Feature.size() - 4);

#define FEATURE(Name, Predicate) .Case(#Name, Predicate) // 下面的 Feature.def 里面使用了大量的 FEATURE 宏
  return llvm::StringSwitch(Feature) // StringSwitch 是一个类，它支持对字符串进行 switch-case 操作
#include "clang/Basic/Features.def" // 所有 Clang 支持的功能都定义在这个文件
      .Default(false); // 默认返回 false
#undef FEATURE
}

从源码可以看到，HasFeature 函数内部定义了一个 FEATURE 宏，这个宏在 Feature.def 文件中被大量使用，下面截取部分 Feature.def 文件内容:

// file: Feature.def

...

// Objective-C features
FEATURE(objc_arr, LangOpts.ObjCAutoRefCount) // FIXME: REMOVE?
FEATURE(objc_arc, LangOpts.ObjCAutoRefCount)
FEATURE(objc_arc_fields, true)  // ARC
FEATURE(objc_arc_weak, LangOpts.ObjCWeak) // weak
FEATURE(objc_default_synthesize_properties, LangOpts.ObjC)
FEATURE(objc_fixed_enum, LangOpts.ObjC)
FEATURE(objc_instancetype, LangOpts.ObjC) // instancetype
FEATURE(objc_kindof, LangOpts.ObjC)

...

经过宏扩展之后，HasFeature 函数最后的 return 语句实际上变成为:

return llvm::StringSwitch(Feature) 
...
.Case("objc_arr", LangOpts.ObjCAutoRefCount)
.Case("objc_arc", LangOpts.ObjCAutoRefCount)
.Case("objc_arc_fields", true)
.Case("objc_arc_weak", LangOpts.ObjCWeak)
.Case("objc_default_synthesize_properties", LangOpts.ObjC)
.Case("objc_fixed_enum", LangOpts.ObjC)
.Case("objc_instancetype", LangOpts.ObjC)
.Case("objc_kindof", LangOpts.ObjC)
...
.Default(false)

return 语句首先传入待检测的功能名，调用 StringSwitch 的构造函数生成一个 StringSwitch 对象，这个 StringSwitch 对象用来对 string 进行 switch-case 操作，它内部有 Case 和 Default 两个方法，定义如下:

template
class StringSwitch {
  ...

  // Case-sensitive case matchers
  StringSwitch &Case(StringLiteral S, T Value) {
    if (!Result && Str == S) { // 如果 switch-case 没有匹配的结果，本次 Case 方法才进行比较，否则如果已经匹配出结果，直接返回对象本身
      Result = std::move(Value); 
    }
    return *this; // 返回对象本身，形成链式调用
  }

  ..

  R Default(T Value) {
      if (Result)
        return std::move(*Result); // 匹配除了结果，直接返回结果
      return Value; // 未匹配出结果，返回默认值
  }

  ...
}

从源码可以看到，Case 方法只有在未匹配出结果时，才进行匹配操作，如果结果已经匹配，Case 方法直接返回对象本身，这样就可以形成链式调用。链式调用最后，会调用到 Default 方法，如果已经匹配到结果，Default 方法直接返回对应的匹配结果，否则就返回默认值。