ICode9

精准搜索请尝试: 精确搜索
首页 > 其他分享> 文章详细

iOS LLVM 中的宏定义

2022-07-30 19:31:50  阅读:234  来源: 互联网

标签:__ case LLVM 定义 Builder iOS llvm Triple 源码


在阅读 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<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 方法直接返回对应的匹配结果,否则就返回默认值。

标签:__,case,LLVM,定义,Builder,iOS,llvm,Triple,源码
来源: https://www.cnblogs.com/chaoguo1234/p/16535651.html

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有