在阅读 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 源码中找到)。
在 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 设备上该宏不会生效。
在 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(见下文)。
在 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__ 宏定义在 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__ 宏定义在 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 宏可以帮助我们判断一个功能是否可以由 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<bool>(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<bool>(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<typename T, typename R = T> 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 方法直接返回对应的匹配结果,否则就返回默认值。