/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp

Bug Summary

File:	tools/clang/lib/CodeGen/CGObjCGNU.cpp
Warning:	line 1865, column 20 The result of the left shift is undefined because the left operand is negative

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CGObjCGNU.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -mthread-model posix -mframe-pointer=none -relaxed-aliasing -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -ffunction-sections -fdata-sections -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -D CLANG_VENDOR="Debian " -D _DEBUG -D _GNU_SOURCE -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D __STDC_LIMIT_MACROS -I /build/llvm-toolchain-snapshot-10~svn373386/build-llvm/tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen -I /build/llvm-toolchain-snapshot-10~svn373386/tools/clang/include -I /build/llvm-toolchain-snapshot-10~svn373386/build-llvm/tools/clang/include -I /build/llvm-toolchain-snapshot-10~svn373386/build-llvm/include -I /build/llvm-toolchain-snapshot-10~svn373386/include -U NDEBUG -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/x86_64-linux-gnu/c++/6.3.0 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/6.3.0/../../../../include/c++/6.3.0/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-maybe-uninitialized -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir /build/llvm-toolchain-snapshot-10~svn373386/build-llvm/tools/clang/lib/CodeGen -fdebug-prefix-map=/build/llvm-toolchain-snapshot-10~svn373386=. -ferror-limit 19 -fmessage-length 0 -fvisibility-inlines-hidden -stack-protector 2 -fobjc-runtime=gcc -fno-common -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -analyzer-config stable-report-filename=true -faddrsig -o /tmp/scan-build-2019-10-02-042503-23017-1 -x c++ /build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp

/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp

→

1//===------- CGObjCGNU.cpp - Emit LLVM Code from ASTs for a Module --------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This provides Objective-C code generation targeting the GNU runtime.  The
10// class in this file generates structures used by the GNU Objective-C runtime
11// library.  These structures are defined in objc/objc.h and objc/objc-api.h in
12// the GNU runtime distribution.
13//
14//===----------------------------------------------------------------------===//

16#include "CGObjCRuntime.h"
17#include "CGCleanup.h"
18#include "CodeGenFunction.h"
19#include "CodeGenModule.h"
20#include "CGCXXABI.h"
21#include "clang/CodeGen/ConstantInitBuilder.h"
22#include "clang/AST/ASTContext.h"
23#include "clang/AST/Decl.h"
24#include "clang/AST/DeclObjC.h"
25#include "clang/AST/RecordLayout.h"
26#include "clang/AST/StmtObjC.h"
27#include "clang/Basic/FileManager.h"
28#include "clang/Basic/SourceManager.h"
29#include "llvm/ADT/SmallVector.h"
30#include "llvm/ADT/StringMap.h"
31#include "llvm/IR/DataLayout.h"
32#include "llvm/IR/Intrinsics.h"
33#include "llvm/IR/LLVMContext.h"
34#include "llvm/IR/Module.h"
35#include "llvm/Support/Compiler.h"
36#include "llvm/Support/ConvertUTF.h"
37#include <cctype>

39using namespace clang;
40using namespace CodeGen;

42namespace {

44std::string SymbolNameForMethod( StringRef ClassName,
   StringRef CategoryName, const Selector MethodName,
  bool isClassMethod) {
std::string MethodNameColonStripped = MethodName.getAsString();
std::replace(MethodNameColonStripped.begin(), MethodNameColonStripped.end(),
    ':', '_');
return (Twine(isClassMethod ? "_c_" : "_i_") + ClassName + "_" +
  CategoryName + "_" + MethodNameColonStripped).str();
52}

54/// Class that lazily initialises the runtime function.  Avoids inserting the
55/// types and the function declaration into a module if they're not used, and
56/// avoids constructing the type more than once if it's used more than once.
57class LazyRuntimeFunction {
CodeGenModule *CGM;
llvm::FunctionType *FTy;
const char *FunctionName;
llvm::FunctionCallee Function;

63public:
/// Constructor leaves this class uninitialized, because it is intended to
/// be used as a field in another class and not all of the types that are
/// used as arguments will necessarily be available at construction time.
LazyRuntimeFunction()
    : CGM(nullptr), FunctionName(nullptr), Function(nullptr) {}

/// Initialises the lazy function with the name, return type, and the types
/// of the arguments.
template <typename... Tys>
void init(CodeGenModule *Mod, const char *name, llvm::Type *RetTy,
          Tys *... Types) {
  CGM = Mod;
  FunctionName = name;
  Function = nullptr;
  if(sizeof...(Tys)) {
    SmallVector<llvm::Type *, 8> ArgTys({Types...});
    FTy = llvm::FunctionType::get(RetTy, ArgTys, false);
  }
  else {
    FTy = llvm::FunctionType::get(RetTy, None, false);
  }
}

llvm::FunctionType *getType() { return FTy; }

/// Overloaded cast operator, allows the class to be implicitly cast to an
/// LLVM constant.
operator llvm::FunctionCallee() {
  if (!Function) {
    if (!FunctionName)
      return nullptr;
    Function = CGM->CreateRuntimeFunction(FTy, FunctionName);
  }
  return Function;
}
99};


102/// GNU Objective-C runtime code generation.  This class implements the parts of
103/// Objective-C support that are specific to the GNU family of runtimes (GCC,
104/// GNUstep and ObjFW).
105class CGObjCGNU : public CGObjCRuntime {
106protected:
/// The LLVM module into which output is inserted
llvm::Module &TheModule;
/// strut objc_super.  Used for sending messages to super.  This structure
/// contains the receiver (object) and the expected class.
llvm::StructType *ObjCSuperTy;
/// struct objc_super*.  The type of the argument to the superclass message
/// lookup functions.
llvm::PointerType *PtrToObjCSuperTy;
/// LLVM type for selectors.  Opaque pointer (i8*) unless a header declaring
/// SEL is included in a header somewhere, in which case it will be whatever
/// type is declared in that header, most likely {i8*, i8*}.
llvm::PointerType *SelectorTy;
/// LLVM i8 type.  Cached here to avoid repeatedly getting it in all of the
/// places where it's used
llvm::IntegerType *Int8Ty;
/// Pointer to i8 - LLVM type of char*, for all of the places where the
/// runtime needs to deal with C strings.
llvm::PointerType *PtrToInt8Ty;
/// struct objc_protocol type
llvm::StructType *ProtocolTy;
/// Protocol * type.
llvm::PointerType *ProtocolPtrTy;
/// Instance Method Pointer type.  This is a pointer to a function that takes,
/// at a minimum, an object and a selector, and is the generic type for
/// Objective-C methods.  Due to differences between variadic / non-variadic
/// calling conventions, it must always be cast to the correct type before
/// actually being used.
llvm::PointerType *IMPTy;
/// Type of an untyped Objective-C object.  Clang treats id as a built-in type
/// when compiling Objective-C code, so this may be an opaque pointer (i8*),
/// but if the runtime header declaring it is included then it may be a
/// pointer to a structure.
llvm::PointerType *IdTy;
/// Pointer to a pointer to an Objective-C object.  Used in the new ABI
/// message lookup function and some GC-related functions.
llvm::PointerType *PtrToIdTy;
/// The clang type of id.  Used when using the clang CGCall infrastructure to
/// call Objective-C methods.
CanQualType ASTIdTy;
/// LLVM type for C int type.
llvm::IntegerType *IntTy;
/// LLVM type for an opaque pointer.  This is identical to PtrToInt8Ty, but is
/// used in the code to document the difference between i8* meaning a pointer
/// to a C string and i8* meaning a pointer to some opaque type.
llvm::PointerType *PtrTy;
/// LLVM type for C long type.  The runtime uses this in a lot of places where
/// it should be using intptr_t, but we can't fix this without breaking
/// compatibility with GCC...
llvm::IntegerType *LongTy;
/// LLVM type for C size_t.  Used in various runtime data structures.
llvm::IntegerType *SizeTy;
/// LLVM type for C intptr_t.
llvm::IntegerType *IntPtrTy;
/// LLVM type for C ptrdiff_t.  Mainly used in property accessor functions.
llvm::IntegerType *PtrDiffTy;
/// LLVM type for C int*.  Used for GCC-ABI-compatible non-fragile instance
/// variables.
llvm::PointerType *PtrToIntTy;
/// LLVM type for Objective-C BOOL type.
llvm::Type *BoolTy;
/// 32-bit integer type, to save us needing to look it up every time it's used.
llvm::IntegerType *Int32Ty;
/// 64-bit integer type, to save us needing to look it up every time it's used.
llvm::IntegerType *Int64Ty;
/// The type of struct objc_property.
llvm::StructType *PropertyMetadataTy;
/// Metadata kind used to tie method lookups to message sends.  The GNUstep
/// runtime provides some LLVM passes that can use this to do things like
/// automatic IMP caching and speculative inlining.
unsigned msgSendMDKind;
/// Does the current target use SEH-based exceptions? False implies
/// Itanium-style DWARF unwinding.
bool usesSEHExceptions;

/// Helper to check if we are targeting a specific runtime version or later.
bool isRuntime(ObjCRuntime::Kind kind, unsigned major, unsigned minor=0) {
  const ObjCRuntime &R = CGM.getLangOpts().ObjCRuntime;
  return (R.getKind() == kind) &&
    (R.getVersion() >= VersionTuple(major, minor));
}

std::string ManglePublicSymbol(StringRef Name) {
  return (StringRef(CGM.getTriple().isOSBinFormatCOFF() ? "$_" : "._") + Name).str();
}

std::string SymbolForProtocol(Twine Name) {
  return (ManglePublicSymbol("OBJC_PROTOCOL_") + Name).str();
}

std::string SymbolForProtocolRef(StringRef Name) {
  return (ManglePublicSymbol("OBJC_REF_PROTOCOL_") + Name).str();
}


/// Helper function that generates a constant string and returns a pointer to
/// the start of the string.  The result of this function can be used anywhere
/// where the C code specifies const char*.
llvm::Constant *MakeConstantString(StringRef Str, const char *Name = "") {
  ConstantAddress Array = CGM.GetAddrOfConstantCString(Str, Name);
  return llvm::ConstantExpr::getGetElementPtr(Array.getElementType(),
                                              Array.getPointer(), Zeros);
}

/// Emits a linkonce_odr string, whose name is the prefix followed by the
/// string value.  This allows the linker to combine the strings between
/// different modules.  Used for EH typeinfo names, selector strings, and a
/// few other things.
llvm::Constant *ExportUniqueString(const std::string &Str,
                                   const std::string &prefix,
                                   bool Private=false) {
  std::string name = prefix + Str;
  auto *ConstStr = TheModule.getGlobalVariable(name);
  if (!ConstStr) {
    llvm::Constant *value = llvm::ConstantDataArray::getString(VMContext,Str);
    auto *GV = new llvm::GlobalVariable(TheModule, value->getType(), true,
            llvm::GlobalValue::LinkOnceODRLinkage, value, name);
    GV->setComdat(TheModule.getOrInsertComdat(name));
    if (Private)
      GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
    ConstStr = GV;
  }
  return llvm::ConstantExpr::getGetElementPtr(ConstStr->getValueType(),
                                              ConstStr, Zeros);
}

/// Returns a property name and encoding string.
llvm::Constant *MakePropertyEncodingString(const ObjCPropertyDecl *PD,
                                           const Decl *Container) {
  assert(!isRuntime(ObjCRuntime::GNUstep, 2))((!isRuntime(ObjCRuntime::GNUstep, 2)) ? static_cast<void>
 (0) : __assert_fail ("!isRuntime(ObjCRuntime::GNUstep, 2)", "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 235, __PRETTY_FUNCTION__));
  if (isRuntime(ObjCRuntime::GNUstep, 1, 6)) {
    std::string NameAndAttributes;
    std::string TypeStr =
      CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container);
    NameAndAttributes += '\0';
    NameAndAttributes += TypeStr.length() + 3;
    NameAndAttributes += TypeStr;
    NameAndAttributes += '\0';
    NameAndAttributes += PD->getNameAsString();
    return MakeConstantString(NameAndAttributes);
  }
  return MakeConstantString(PD->getNameAsString());
}

/// Push the property attributes into two structure fields.
void PushPropertyAttributes(ConstantStructBuilder &Fields,
    const ObjCPropertyDecl *property, bool isSynthesized=true, bool
    isDynamic=true) {
  int attrs = property->getPropertyAttributes();
  // For read-only properties, clear the copy and retain flags
  if (attrs & ObjCPropertyDecl::OBJC_PR_readonly) {
    attrs &= ~ObjCPropertyDecl::OBJC_PR_copy;
    attrs &= ~ObjCPropertyDecl::OBJC_PR_retain;
    attrs &= ~ObjCPropertyDecl::OBJC_PR_weak;
    attrs &= ~ObjCPropertyDecl::OBJC_PR_strong;
  }
  // The first flags field has the same attribute values as clang uses internally
  Fields.addInt(Int8Ty, attrs & 0xff);
  attrs >>= 8;
  attrs <<= 2;
  // For protocol properties, synthesized and dynamic have no meaning, so we
  // reuse these flags to indicate that this is a protocol property (both set
  // has no meaning, as a property can't be both synthesized and dynamic)
  attrs |= isSynthesized ? (1<<0) : 0;
  attrs |= isDynamic ? (1<<1) : 0;
  // The second field is the next four fields left shifted by two, with the
  // low bit set to indicate whether the field is synthesized or dynamic.
  Fields.addInt(Int8Ty, attrs & 0xff);
  // Two padding fields
  Fields.addInt(Int8Ty, 0);
  Fields.addInt(Int8Ty, 0);
}

virtual llvm::Constant *GenerateCategoryProtocolList(const
    ObjCCategoryDecl *OCD);
virtual ConstantArrayBuilder PushPropertyListHeader(ConstantStructBuilder &Fields,
    int count) {
    // int count;
    Fields.addInt(IntTy, count);
    // int size; (only in GNUstep v2 ABI.
    if (isRuntime(ObjCRuntime::GNUstep, 2)) {
      llvm::DataLayout td(&TheModule);
      Fields.addInt(IntTy, td.getTypeSizeInBits(PropertyMetadataTy) /
          CGM.getContext().getCharWidth());
    }
    // struct objc_property_list *next;
    Fields.add(NULLPtr);
    // struct objc_property properties[]
    return Fields.beginArray(PropertyMetadataTy);
}
virtual void PushProperty(ConstantArrayBuilder &PropertiesArray,
          const ObjCPropertyDecl *property,
          const Decl *OCD,
          bool isSynthesized=true, bool
          isDynamic=true) {
  auto Fields = PropertiesArray.beginStruct(PropertyMetadataTy);
  ASTContext &Context = CGM.getContext();
  Fields.add(MakePropertyEncodingString(property, OCD));
  PushPropertyAttributes(Fields, property, isSynthesized, isDynamic);
  auto addPropertyMethod = [&](const ObjCMethodDecl *accessor) {
    if (accessor) {
      std::string TypeStr = Context.getObjCEncodingForMethodDecl(accessor);
      llvm::Constant *TypeEncoding = MakeConstantString(TypeStr);
      Fields.add(MakeConstantString(accessor->getSelector().getAsString()));
      Fields.add(TypeEncoding);
    } else {
      Fields.add(NULLPtr);
      Fields.add(NULLPtr);
    }
  };
  addPropertyMethod(property->getGetterMethodDecl());
  addPropertyMethod(property->getSetterMethodDecl());
  Fields.finishAndAddTo(PropertiesArray);
}

/// Ensures that the value has the required type, by inserting a bitcast if
/// required.  This function lets us avoid inserting bitcasts that are
/// redundant.
llvm::Value* EnforceType(CGBuilderTy &B, llvm::Value *V, llvm::Type *Ty) {
  if (V->getType() == Ty) return V;
  return B.CreateBitCast(V, Ty);
}
Address EnforceType(CGBuilderTy &B, Address V, llvm::Type *Ty) {
  if (V.getType() == Ty) return V;
  return B.CreateBitCast(V, Ty);
}

// Some zeros used for GEPs in lots of places.
llvm::Constant *Zeros[2];
/// Null pointer value.  Mainly used as a terminator in various arrays.
llvm::Constant *NULLPtr;
/// LLVM context.
llvm::LLVMContext &VMContext;

340protected:

/// Placeholder for the class.  Lots of things refer to the class before we've
/// actually emitted it.  We use this alias as a placeholder, and then replace
/// it with a pointer to the class structure before finally emitting the
/// module.
llvm::GlobalAlias *ClassPtrAlias;
/// Placeholder for the metaclass.  Lots of things refer to the class before
/// we've / actually emitted it.  We use this alias as a placeholder, and then
/// replace / it with a pointer to the metaclass structure before finally
/// emitting the / module.
llvm::GlobalAlias *MetaClassPtrAlias;
/// All of the classes that have been generated for this compilation units.
std::vector<llvm::Constant*> Classes;
/// All of the categories that have been generated for this compilation units.
std::vector<llvm::Constant*> Categories;
/// All of the Objective-C constant strings that have been generated for this
/// compilation units.
std::vector<llvm::Constant*> ConstantStrings;
/// Map from string values to Objective-C constant strings in the output.
/// Used to prevent emitting Objective-C strings more than once.  This should
/// not be required at all - CodeGenModule should manage this list.
llvm::StringMap<llvm::Constant*> ObjCStrings;
/// All of the protocols that have been declared.
llvm::StringMap<llvm::Constant*> ExistingProtocols;
/// For each variant of a selector, we store the type encoding and a
/// placeholder value.  For an untyped selector, the type will be the empty
/// string.  Selector references are all done via the module's selector table,
/// so we create an alias as a placeholder and then replace it with the real
/// value later.
typedef std::pair<std::string, llvm::GlobalAlias*> TypedSelector;
/// Type of the selector map.  This is roughly equivalent to the structure
/// used in the GNUstep runtime, which maintains a list of all of the valid
/// types for a selector in a table.
typedef llvm::DenseMap<Selector, SmallVector<TypedSelector, 2> >
  SelectorMap;
/// A map from selectors to selector types.  This allows us to emit all
/// selectors of the same name and type together.
SelectorMap SelectorTable;

/// Selectors related to memory management.  When compiling in GC mode, we
/// omit these.
Selector RetainSel, ReleaseSel, AutoreleaseSel;
/// Runtime functions used for memory management in GC mode.  Note that clang
/// supports code generation for calling these functions, but neither GNU
/// runtime actually supports this API properly yet.
LazyRuntimeFunction IvarAssignFn, StrongCastAssignFn, MemMoveFn, WeakReadFn,
  WeakAssignFn, GlobalAssignFn;

typedef std::pair<std::string, std::string> ClassAliasPair;
/// All classes that have aliases set for them.
std::vector<ClassAliasPair> ClassAliases;

393protected:
/// Function used for throwing Objective-C exceptions.
LazyRuntimeFunction ExceptionThrowFn;
/// Function used for rethrowing exceptions, used at the end of \@finally or
/// \@synchronize blocks.
LazyRuntimeFunction ExceptionReThrowFn;
/// Function called when entering a catch function.  This is required for
/// differentiating Objective-C exceptions and foreign exceptions.
LazyRuntimeFunction EnterCatchFn;
/// Function called when exiting from a catch block.  Used to do exception
/// cleanup.
LazyRuntimeFunction ExitCatchFn;
/// Function called when entering an \@synchronize block.  Acquires the lock.
LazyRuntimeFunction SyncEnterFn;
/// Function called when exiting an \@synchronize block.  Releases the lock.
LazyRuntimeFunction SyncExitFn;

410private:
/// Function called if fast enumeration detects that the collection is
/// modified during the update.
LazyRuntimeFunction EnumerationMutationFn;
/// Function for implementing synthesized property getters that return an
/// object.
LazyRuntimeFunction GetPropertyFn;
/// Function for implementing synthesized property setters that return an
/// object.
LazyRuntimeFunction SetPropertyFn;
/// Function used for non-object declared property getters.
LazyRuntimeFunction GetStructPropertyFn;
/// Function used for non-object declared property setters.
LazyRuntimeFunction SetStructPropertyFn;

425protected:
/// The version of the runtime that this class targets.  Must match the
/// version in the runtime.
int RuntimeVersion;
/// The version of the protocol class.  Used to differentiate between ObjC1
/// and ObjC2 protocols.  Objective-C 1 protocols can not contain optional
/// components and can not contain declared properties.  We always emit
/// Objective-C 2 property structures, but we have to pretend that they're
/// Objective-C 1 property structures when targeting the GCC runtime or it
/// will abort.
const int ProtocolVersion;
/// The version of the class ABI.  This value is used in the class structure
/// and indicates how various fields should be interpreted.
const int ClassABIVersion;
/// Generates an instance variable list structure.  This is a structure
/// containing a size and an array of structures containing instance variable
/// metadata.  This is used purely for introspection in the fragile ABI.  In
/// the non-fragile ABI, it's used for instance variable fixup.
virtual llvm::Constant *GenerateIvarList(ArrayRef<llvm::Constant *> IvarNames,
                           ArrayRef<llvm::Constant *> IvarTypes,
                           ArrayRef<llvm::Constant *> IvarOffsets,
                           ArrayRef<llvm::Constant *> IvarAlign,
                           ArrayRef<Qualifiers::ObjCLifetime> IvarOwnership);

/// Generates a method list structure.  This is a structure containing a size
/// and an array of structures containing method metadata.
///
/// This structure is used by both classes and categories, and contains a next
/// pointer allowing them to be chained together in a linked list.
llvm::Constant *GenerateMethodList(StringRef ClassName,
    StringRef CategoryName,
    ArrayRef<const ObjCMethodDecl*> Methods,
    bool isClassMethodList);

/// Emits an empty protocol.  This is used for \@protocol() where no protocol
/// is found.  The runtime will (hopefully) fix up the pointer to refer to the
/// real protocol.
virtual llvm::Constant *GenerateEmptyProtocol(StringRef ProtocolName);

/// Generates a list of property metadata structures.  This follows the same
/// pattern as method and instance variable metadata lists.
llvm::Constant *GeneratePropertyList(const Decl *Container,
    const ObjCContainerDecl *OCD,
    bool isClassProperty=false,
    bool protocolOptionalProperties=false);

/// Generates a list of referenced protocols.  Classes, categories, and
/// protocols all use this structure.
llvm::Constant *GenerateProtocolList(ArrayRef<std::string> Protocols);

/// To ensure that all protocols are seen by the runtime, we add a category on
/// a class defined in the runtime, declaring no methods, but adopting the
/// protocols.  This is a horribly ugly hack, but it allows us to collect all
/// of the protocols without changing the ABI.
void GenerateProtocolHolderCategory();

/// Generates a class structure.
llvm::Constant *GenerateClassStructure(
    llvm::Constant *MetaClass,
    llvm::Constant *SuperClass,
    unsigned info,
    const char *Name,
    llvm::Constant *Version,
    llvm::Constant *InstanceSize,
    llvm::Constant *IVars,
    llvm::Constant *Methods,
    llvm::Constant *Protocols,
    llvm::Constant *IvarOffsets,
    llvm::Constant *Properties,
    llvm::Constant *StrongIvarBitmap,
    llvm::Constant *WeakIvarBitmap,
    bool isMeta=false);

/// Generates a method list.  This is used by protocols to define the required
/// and optional methods.
virtual llvm::Constant *GenerateProtocolMethodList(
    ArrayRef<const ObjCMethodDecl*> Methods);
/// Emits optional and required method lists.
template<class T>
void EmitProtocolMethodList(T &&Methods, llvm::Constant *&Required,
    llvm::Constant *&Optional) {
  SmallVector<const ObjCMethodDecl*, 16> RequiredMethods;
  SmallVector<const ObjCMethodDecl*, 16> OptionalMethods;
  for (const auto *I : Methods)
    if (I->isOptional())
      OptionalMethods.push_back(I);
    else
      RequiredMethods.push_back(I);
  Required = GenerateProtocolMethodList(RequiredMethods);
  Optional = GenerateProtocolMethodList(OptionalMethods);
}

/// Returns a selector with the specified type encoding.  An empty string is
/// used to return an untyped selector (with the types field set to NULL).
virtual llvm::Value *GetTypedSelector(CodeGenFunction &CGF, Selector Sel,
                                      const std::string &TypeEncoding);

/// Returns the name of ivar offset variables.  In the GNUstep v1 ABI, this
/// contains the class and ivar names, in the v2 ABI this contains the type
/// encoding as well.
virtual std::string GetIVarOffsetVariableName(const ObjCInterfaceDecl *ID,
                                              const ObjCIvarDecl *Ivar) {
  const std::string Name = "__objc_ivar_offset_" + ID->getNameAsString()
    + '.' + Ivar->getNameAsString();
  return Name;
}
/// Returns the variable used to store the offset of an instance variable.
llvm::GlobalVariable *ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID,
    const ObjCIvarDecl *Ivar);
/// Emits a reference to a class.  This allows the linker to object if there
/// is no class of the matching name.
void EmitClassRef(const std::string &className);

/// Emits a pointer to the named class
virtual llvm::Value *GetClassNamed(CodeGenFunction &CGF,
                                   const std::string &Name, bool isWeak);

/// Looks up the method for sending a message to the specified object.  This
/// mechanism differs between the GCC and GNU runtimes, so this method must be
/// overridden in subclasses.
virtual llvm::Value *LookupIMP(CodeGenFunction &CGF,
                               llvm::Value *&Receiver,
                               llvm::Value *cmd,
                               llvm::MDNode *node,
                               MessageSendInfo &MSI) = 0;

/// Looks up the method for sending a message to a superclass.  This
/// mechanism differs between the GCC and GNU runtimes, so this method must
/// be overridden in subclasses.
virtual llvm::Value *LookupIMPSuper(CodeGenFunction &CGF,
                                    Address ObjCSuper,
                                    llvm::Value *cmd,
                                    MessageSendInfo &MSI) = 0;

/// Libobjc2 uses a bitfield representation where small(ish) bitfields are
/// stored in a 64-bit value with the low bit set to 1 and the remaining 63
/// bits set to their values, LSB first, while larger ones are stored in a
/// structure of this / form:
///
/// struct { int32_t length; int32_t values[length]; };
///
/// The values in the array are stored in host-endian format, with the least
/// significant bit being assumed to come first in the bitfield.  Therefore,
/// a bitfield with the 64th bit set will be (int64_t)&{ 2, [0, 1<<31] },
/// while a bitfield / with the 63rd bit set will be 1<<64.
llvm::Constant *MakeBitField(ArrayRef<bool> bits);

572public:
CGObjCGNU(CodeGenModule &cgm, unsigned runtimeABIVersion,
    unsigned protocolClassVersion, unsigned classABI=1);

ConstantAddress GenerateConstantString(const StringLiteral *) override;

RValue
GenerateMessageSend(CodeGenFunction &CGF, ReturnValueSlot Return,
                    QualType ResultType, Selector Sel,
                    llvm::Value *Receiver, const CallArgList &CallArgs,
                    const ObjCInterfaceDecl *Class,
                    const ObjCMethodDecl *Method) override;
RValue
GenerateMessageSendSuper(CodeGenFunction &CGF, ReturnValueSlot Return,
                         QualType ResultType, Selector Sel,
                         const ObjCInterfaceDecl *Class,
                         bool isCategoryImpl, llvm::Value *Receiver,
                         bool IsClassMessage, const CallArgList &CallArgs,
                         const ObjCMethodDecl *Method) override;
llvm::Value *GetClass(CodeGenFunction &CGF,
                      const ObjCInterfaceDecl *OID) override;
llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override;
Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override;
llvm::Value *GetSelector(CodeGenFunction &CGF,
                         const ObjCMethodDecl *Method) override;
virtual llvm::Constant *GetConstantSelector(Selector Sel,
                                            const std::string &TypeEncoding) {
  llvm_unreachable("Runtime unable to generate constant selector")::llvm::llvm_unreachable_internal("Runtime unable to generate constant selector"
, "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 599);
}
llvm::Constant *GetConstantSelector(const ObjCMethodDecl *M) {
  return GetConstantSelector(M->getSelector(),
      CGM.getContext().getObjCEncodingForMethodDecl(M));
}
llvm::Constant *GetEHType(QualType T) override;

llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
                               const ObjCContainerDecl *CD) override;
void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override;
llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
                                 const ObjCProtocolDecl *PD) override;
void GenerateProtocol(const ObjCProtocolDecl *PD) override;
llvm::Function *ModuleInitFunction() override;
llvm::FunctionCallee GetPropertyGetFunction() override;
llvm::FunctionCallee GetPropertySetFunction() override;
llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic,
                                                     bool copy) override;
llvm::FunctionCallee GetSetStructFunction() override;
llvm::FunctionCallee GetGetStructFunction() override;
llvm::FunctionCallee GetCppAtomicObjectGetFunction() override;
llvm::FunctionCallee GetCppAtomicObjectSetFunction() override;
llvm::FunctionCallee EnumerationMutationFunction() override;

void EmitTryStmt(CodeGenFunction &CGF,
                 const ObjCAtTryStmt &S) override;
void EmitSynchronizedStmt(CodeGenFunction &CGF,
                          const ObjCAtSynchronizedStmt &S) override;
void EmitThrowStmt(CodeGenFunction &CGF,
                   const ObjCAtThrowStmt &S,
                   bool ClearInsertionPoint=true) override;
llvm::Value * EmitObjCWeakRead(CodeGenFunction &CGF,
                               Address AddrWeakObj) override;
void EmitObjCWeakAssign(CodeGenFunction &CGF,
                        llvm::Value *src, Address dst) override;
void EmitObjCGlobalAssign(CodeGenFunction &CGF,
                          llvm::Value *src, Address dest,
                          bool threadlocal=false) override;
void EmitObjCIvarAssign(CodeGenFunction &CGF, llvm::Value *src,
                        Address dest, llvm::Value *ivarOffset) override;
void EmitObjCStrongCastAssign(CodeGenFunction &CGF,
                              llvm::Value *src, Address dest) override;
void EmitGCMemmoveCollectable(CodeGenFunction &CGF, Address DestPtr,
                              Address SrcPtr,
                              llvm::Value *Size) override;
LValue EmitObjCValueForIvar(CodeGenFunction &CGF, QualType ObjectTy,
                            llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
                            unsigned CVRQualifiers) override;
llvm::Value *EmitIvarOffset(CodeGenFunction &CGF,
                            const ObjCInterfaceDecl *Interface,
                            const ObjCIvarDecl *Ivar) override;
llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
llvm::Constant *BuildGCBlockLayout(CodeGenModule &CGM,
                                   const CGBlockInfo &blockInfo) override {
  return NULLPtr;
}
llvm::Constant *BuildRCBlockLayout(CodeGenModule &CGM,
                                   const CGBlockInfo &blockInfo) override {
  return NULLPtr;
}

llvm::Constant *BuildByrefLayout(CodeGenModule &CGM, QualType T) override {
  return NULLPtr;
}
666};

668/// Class representing the legacy GCC Objective-C ABI.  This is the default when
669/// -fobjc-nonfragile-abi is not specified.
670///
671/// The GCC ABI target actually generates code that is approximately compatible
672/// with the new GNUstep runtime ABI, but refrains from using any features that
673/// would not work with the GCC runtime.  For example, clang always generates
674/// the extended form of the class structure, and the extra fields are simply
675/// ignored by GCC libobjc.
676class CGObjCGCC : public CGObjCGNU {
/// The GCC ABI message lookup function.  Returns an IMP pointing to the
/// method implementation for this message.
LazyRuntimeFunction MsgLookupFn;
/// The GCC ABI superclass message lookup function.  Takes a pointer to a
/// structure describing the receiver and the class, and a selector as
/// arguments.  Returns the IMP for the corresponding method.
LazyRuntimeFunction MsgLookupSuperFn;

685protected:
llvm::Value *LookupIMP(CodeGenFunction &CGF, llvm::Value *&Receiver,
                       llvm::Value *cmd, llvm::MDNode *node,
                       MessageSendInfo &MSI) override {
  CGBuilderTy &Builder = CGF.Builder;
  llvm::Value *args[] = {
          EnforceType(Builder, Receiver, IdTy),
          EnforceType(Builder, cmd, SelectorTy) };
  llvm::CallBase *imp = CGF.EmitRuntimeCallOrInvoke(MsgLookupFn, args);
  imp->setMetadata(msgSendMDKind, node);
  return imp;
}

llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper,
                            llvm::Value *cmd, MessageSendInfo &MSI) override {
  CGBuilderTy &Builder = CGF.Builder;
  llvm::Value *lookupArgs[] = {EnforceType(Builder, ObjCSuper,
      PtrToObjCSuperTy).getPointer(), cmd};
  return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFn, lookupArgs);
}

706public:
CGObjCGCC(CodeGenModule &Mod) : CGObjCGNU(Mod, 8, 2) {
  // IMP objc_msg_lookup(id, SEL);
  MsgLookupFn.init(&CGM, "objc_msg_lookup", IMPTy, IdTy, SelectorTy);
  // IMP objc_msg_lookup_super(struct objc_super*, SEL);
  MsgLookupSuperFn.init(&CGM, "objc_msg_lookup_super", IMPTy,
                        PtrToObjCSuperTy, SelectorTy);
}
714};

716/// Class used when targeting the new GNUstep runtime ABI.
717class CGObjCGNUstep : public CGObjCGNU {
  /// The slot lookup function.  Returns a pointer to a cacheable structure
  /// that contains (among other things) the IMP.
  LazyRuntimeFunction SlotLookupFn;
  /// The GNUstep ABI superclass message lookup function.  Takes a pointer to
  /// a structure describing the receiver and the class, and a selector as
  /// arguments.  Returns the slot for the corresponding method.  Superclass
  /// message lookup rarely changes, so this is a good caching opportunity.
  LazyRuntimeFunction SlotLookupSuperFn;
  /// Specialised function for setting atomic retain properties
  LazyRuntimeFunction SetPropertyAtomic;
  /// Specialised function for setting atomic copy properties
  LazyRuntimeFunction SetPropertyAtomicCopy;
  /// Specialised function for setting nonatomic retain properties
  LazyRuntimeFunction SetPropertyNonAtomic;
  /// Specialised function for setting nonatomic copy properties
  LazyRuntimeFunction SetPropertyNonAtomicCopy;
  /// Function to perform atomic copies of C++ objects with nontrivial copy
  /// constructors from Objective-C ivars.
  LazyRuntimeFunction CxxAtomicObjectGetFn;
  /// Function to perform atomic copies of C++ objects with nontrivial copy
  /// constructors to Objective-C ivars.
  LazyRuntimeFunction CxxAtomicObjectSetFn;
  /// Type of an slot structure pointer.  This is returned by the various
  /// lookup functions.
  llvm::Type *SlotTy;

public:
  llvm::Constant *GetEHType(QualType T) override;

protected:
  llvm::Value *LookupIMP(CodeGenFunction &CGF, llvm::Value *&Receiver,
                         llvm::Value *cmd, llvm::MDNode *node,
                         MessageSendInfo &MSI) override {
    CGBuilderTy &Builder = CGF.Builder;
    llvm::FunctionCallee LookupFn = SlotLookupFn;

    // Store the receiver on the stack so that we can reload it later
    Address ReceiverPtr =
      CGF.CreateTempAlloca(Receiver->getType(), CGF.getPointerAlign());
    Builder.CreateStore(Receiver, ReceiverPtr);

    llvm::Value *self;

    if (isa<ObjCMethodDecl>(CGF.CurCodeDecl)) {
      self = CGF.LoadObjCSelf();
    } else {
      self = llvm::ConstantPointerNull::get(IdTy);
    }

    // The lookup function is guaranteed not to capture the receiver pointer.
    if (auto *LookupFn2 = dyn_cast<llvm::Function>(LookupFn.getCallee()))
      LookupFn2->addParamAttr(0, llvm::Attribute::NoCapture);

    llvm::Value *args[] = {
            EnforceType(Builder, ReceiverPtr.getPointer(), PtrToIdTy),
            EnforceType(Builder, cmd, SelectorTy),
            EnforceType(Builder, self, IdTy) };
    llvm::CallBase *slot = CGF.EmitRuntimeCallOrInvoke(LookupFn, args);
    slot->setOnlyReadsMemory();
    slot->setMetadata(msgSendMDKind, node);

    // Load the imp from the slot
    llvm::Value *imp = Builder.CreateAlignedLoad(
        Builder.CreateStructGEP(nullptr, slot, 4), CGF.getPointerAlign());

    // The lookup function may have changed the receiver, so make sure we use
    // the new one.
    Receiver = Builder.CreateLoad(ReceiverPtr, true);
    return imp;
  }

  llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper,
                              llvm::Value *cmd,
                              MessageSendInfo &MSI) override {
    CGBuilderTy &Builder = CGF.Builder;
    llvm::Value *lookupArgs[] = {ObjCSuper.getPointer(), cmd};

    llvm::CallInst *slot =
      CGF.EmitNounwindRuntimeCall(SlotLookupSuperFn, lookupArgs);
    slot->setOnlyReadsMemory();

    return Builder.CreateAlignedLoad(Builder.CreateStructGEP(nullptr, slot, 4),
                                     CGF.getPointerAlign());
  }

public:
  CGObjCGNUstep(CodeGenModule &Mod) : CGObjCGNUstep(Mod, 9, 3, 1) {}
  CGObjCGNUstep(CodeGenModule &Mod, unsigned ABI, unsigned ProtocolABI,
      unsigned ClassABI) :
    CGObjCGNU(Mod, ABI, ProtocolABI, ClassABI) {
    const ObjCRuntime &R = CGM.getLangOpts().ObjCRuntime;

    llvm::StructType *SlotStructTy =
        llvm::StructType::get(PtrTy, PtrTy, PtrTy, IntTy, IMPTy);
    SlotTy = llvm::PointerType::getUnqual(SlotStructTy);
    // Slot_t objc_msg_lookup_sender(id *receiver, SEL selector, id sender);
    SlotLookupFn.init(&CGM, "objc_msg_lookup_sender", SlotTy, PtrToIdTy,
                      SelectorTy, IdTy);
    // Slot_t objc_slot_lookup_super(struct objc_super*, SEL);
    SlotLookupSuperFn.init(&CGM, "objc_slot_lookup_super", SlotTy,
                           PtrToObjCSuperTy, SelectorTy);
    // If we're in ObjC++ mode, then we want to make 
    if (usesSEHExceptions) {
        llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
        // void objc_exception_rethrow(void)
        ExceptionReThrowFn.init(&CGM, "objc_exception_rethrow", VoidTy);
    } else if (CGM.getLangOpts().CPlusPlus) {
      llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
      // void *__cxa_begin_catch(void *e)
      EnterCatchFn.init(&CGM, "__cxa_begin_catch", PtrTy, PtrTy);
      // void __cxa_end_catch(void)
      ExitCatchFn.init(&CGM, "__cxa_end_catch", VoidTy);
      // void _Unwind_Resume_or_Rethrow(void*)
      ExceptionReThrowFn.init(&CGM, "_Unwind_Resume_or_Rethrow", VoidTy,
                              PtrTy);
    } else if (R.getVersion() >= VersionTuple(1, 7)) {
      llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
      // id objc_begin_catch(void *e)
      EnterCatchFn.init(&CGM, "objc_begin_catch", IdTy, PtrTy);
      // void objc_end_catch(void)
      ExitCatchFn.init(&CGM, "objc_end_catch", VoidTy);
      // void _Unwind_Resume_or_Rethrow(void*)
      ExceptionReThrowFn.init(&CGM, "objc_exception_rethrow", VoidTy, PtrTy);
    }
    llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
    SetPropertyAtomic.init(&CGM, "objc_setProperty_atomic", VoidTy, IdTy,
                           SelectorTy, IdTy, PtrDiffTy);
    SetPropertyAtomicCopy.init(&CGM, "objc_setProperty_atomic_copy", VoidTy,
                               IdTy, SelectorTy, IdTy, PtrDiffTy);
    SetPropertyNonAtomic.init(&CGM, "objc_setProperty_nonatomic", VoidTy,
                              IdTy, SelectorTy, IdTy, PtrDiffTy);
    SetPropertyNonAtomicCopy.init(&CGM, "objc_setProperty_nonatomic_copy",
                                  VoidTy, IdTy, SelectorTy, IdTy, PtrDiffTy);
    // void objc_setCppObjectAtomic(void *dest, const void *src, void
    // *helper);
    CxxAtomicObjectSetFn.init(&CGM, "objc_setCppObjectAtomic", VoidTy, PtrTy,
                              PtrTy, PtrTy);
    // void objc_getCppObjectAtomic(void *dest, const void *src, void
    // *helper);
    CxxAtomicObjectGetFn.init(&CGM, "objc_getCppObjectAtomic", VoidTy, PtrTy,
                              PtrTy, PtrTy);
  }

  llvm::FunctionCallee GetCppAtomicObjectGetFunction() override {
    // The optimised functions were added in version 1.7 of the GNUstep
    // runtime.
    assert (CGM.getLangOpts().ObjCRuntime.getVersion() >=((CGM.getLangOpts().ObjCRuntime.getVersion() >= VersionTuple
(1, 7)) ? static_cast<void> (0) : __assert_fail ("CGM.getLangOpts().ObjCRuntime.getVersion() >= VersionTuple(1, 7)"
, "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 865, __PRETTY_FUNCTION__))
        VersionTuple(1, 7))((CGM.getLangOpts().ObjCRuntime.getVersion() >= VersionTuple
(1, 7)) ? static_cast<void> (0) : __assert_fail ("CGM.getLangOpts().ObjCRuntime.getVersion() >= VersionTuple(1, 7)"
, "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 865, __PRETTY_FUNCTION__));
    return CxxAtomicObjectGetFn;
  }

  llvm::FunctionCallee GetCppAtomicObjectSetFunction() override {
    // The optimised functions were added in version 1.7 of the GNUstep
    // runtime.
    assert (CGM.getLangOpts().ObjCRuntime.getVersion() >=((CGM.getLangOpts().ObjCRuntime.getVersion() >= VersionTuple
(1, 7)) ? static_cast<void> (0) : __assert_fail ("CGM.getLangOpts().ObjCRuntime.getVersion() >= VersionTuple(1, 7)"
, "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 873, __PRETTY_FUNCTION__))
        VersionTuple(1, 7))((CGM.getLangOpts().ObjCRuntime.getVersion() >= VersionTuple
(1, 7)) ? static_cast<void> (0) : __assert_fail ("CGM.getLangOpts().ObjCRuntime.getVersion() >= VersionTuple(1, 7)"
, "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 873, __PRETTY_FUNCTION__));
    return CxxAtomicObjectSetFn;
  }

  llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic,
                                                       bool copy) override {
    // The optimised property functions omit the GC check, and so are not
    // safe to use in GC mode.  The standard functions are fast in GC mode,
    // so there is less advantage in using them.
    assert ((CGM.getLangOpts().getGC() == LangOptions::NonGC))(((CGM.getLangOpts().getGC() == LangOptions::NonGC)) ? static_cast
<void> (0) : __assert_fail ("(CGM.getLangOpts().getGC() == LangOptions::NonGC)"
, "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 882, __PRETTY_FUNCTION__));
    // The optimised functions were added in version 1.7 of the GNUstep
    // runtime.
    assert (CGM.getLangOpts().ObjCRuntime.getVersion() >=((CGM.getLangOpts().ObjCRuntime.getVersion() >= VersionTuple
(1, 7)) ? static_cast<void> (0) : __assert_fail ("CGM.getLangOpts().ObjCRuntime.getVersion() >= VersionTuple(1, 7)"
, "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 886, __PRETTY_FUNCTION__))
        VersionTuple(1, 7))((CGM.getLangOpts().ObjCRuntime.getVersion() >= VersionTuple
(1, 7)) ? static_cast<void> (0) : __assert_fail ("CGM.getLangOpts().ObjCRuntime.getVersion() >= VersionTuple(1, 7)"
, "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 886, __PRETTY_FUNCTION__));

    if (atomic) {
      if (copy) return SetPropertyAtomicCopy;
      return SetPropertyAtomic;
    }

    return copy ? SetPropertyNonAtomicCopy : SetPropertyNonAtomic;
  }
895};

897/// GNUstep Objective-C ABI version 2 implementation.
898/// This is the ABI that provides a clean break with the legacy GCC ABI and
899/// cleans up a number of things that were added to work around 1980s linkers.
900class CGObjCGNUstep2 : public CGObjCGNUstep {
enum SectionKind
{
  SelectorSection = 0,
  ClassSection,
  ClassReferenceSection,
  CategorySection,
  ProtocolSection,
  ProtocolReferenceSection,
  ClassAliasSection,
  ConstantStringSection
};
static const char *const SectionsBaseNames[8];
static const char *const PECOFFSectionsBaseNames[8];
template<SectionKind K>
std::string sectionName() {
  if (CGM.getTriple().isOSBinFormatCOFF()) {
    std::string name(PECOFFSectionsBaseNames[K]);
    name += "$m";
    return name;
  }
  return SectionsBaseNames[K];
}
/// The GCC ABI superclass message lookup function.  Takes a pointer to a
/// structure describing the receiver and the class, and a selector as
/// arguments.  Returns the IMP for the corresponding method.
LazyRuntimeFunction MsgLookupSuperFn;
/// A flag indicating if we've emitted at least one protocol.
/// If we haven't, then we need to emit an empty protocol, to ensure that the
/// __start__objc_protocols and __stop__objc_protocols sections exist.
bool EmittedProtocol = false;
/// A flag indicating if we've emitted at least one protocol reference.
/// If we haven't, then we need to emit an empty protocol, to ensure that the
/// __start__objc_protocol_refs and __stop__objc_protocol_refs sections
/// exist.
bool EmittedProtocolRef = false;
/// A flag indicating if we've emitted at least one class.
/// If we haven't, then we need to emit an empty protocol, to ensure that the
/// __start__objc_classes and __stop__objc_classes sections / exist.
bool EmittedClass = false;
/// Generate the name of a symbol for a reference to a class.  Accesses to
/// classes should be indirected via this.

typedef std::pair<std::string, std::pair<llvm::Constant*, int>> EarlyInitPair;
std::vector<EarlyInitPair> EarlyInitList;

std::string SymbolForClassRef(StringRef Name, bool isWeak) {
  if (isWeak)
    return (ManglePublicSymbol("OBJC_WEAK_REF_CLASS_") + Name).str();
  else
    return (ManglePublicSymbol("OBJC_REF_CLASS_") + Name).str();
}
/// Generate the name of a class symbol.
std::string SymbolForClass(StringRef Name) {
  return (ManglePublicSymbol("OBJC_CLASS_") + Name).str();
}
void CallRuntimeFunction(CGBuilderTy &B, StringRef FunctionName,
    ArrayRef<llvm::Value*> Args) {
  SmallVector<llvm::Type *,8> Types;
  for (auto *Arg : Args)
    Types.push_back(Arg->getType());
  llvm::FunctionType *FT = llvm::FunctionType::get(B.getVoidTy(), Types,
      false);
  llvm::FunctionCallee Fn = CGM.CreateRuntimeFunction(FT, FunctionName);
  B.CreateCall(Fn, Args);
}

ConstantAddress GenerateConstantString(const StringLiteral *SL) override {

  auto Str = SL->getString();
  CharUnits Align = CGM.getPointerAlign();

  // Look for an existing one
  llvm::StringMap<llvm::Constant*>::iterator old = ObjCStrings.find(Str);
  if (old != ObjCStrings.end())
    return ConstantAddress(old->getValue(), Align);

  bool isNonASCII = SL->containsNonAscii();

  auto LiteralLength = SL->getLength();

  if ((CGM.getTarget().getPointerWidth(0) == 64) &&
      (LiteralLength < 9) && !isNonASCII) {
    // Tiny strings are only used on 64-bit platforms.  They store 8 7-bit
    // ASCII characters in the high 56 bits, followed by a 4-bit length and a
    // 3-bit tag (which is always 4).
    uint64_t str = 0;
    // Fill in the characters
    for (unsigned i=0 ; i<LiteralLength ; i++)
      str |= ((uint64_t)SL->getCodeUnit(i)) << ((64 - 4 - 3) - (i*7));
    // Fill in the length
    str |= LiteralLength << 3;
    // Set the tag
    str |= 4;
    auto *ObjCStr = llvm::ConstantExpr::getIntToPtr(
        llvm::ConstantInt::get(Int64Ty, str), IdTy);
    ObjCStrings[Str] = ObjCStr;
    return ConstantAddress(ObjCStr, Align);
  }

  StringRef StringClass = CGM.getLangOpts().ObjCConstantStringClass;

  if (StringClass.empty()) StringClass = "NSConstantString";

  std::string Sym = SymbolForClass(StringClass);

  llvm::Constant *isa = TheModule.getNamedGlobal(Sym);

  if (!isa) {
    isa = new llvm::GlobalVariable(TheModule, IdTy, /* isConstant */false,
            llvm::GlobalValue::ExternalLinkage, nullptr, Sym);
    if (CGM.getTriple().isOSBinFormatCOFF()) {
      cast<llvm::GlobalValue>(isa)->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
    }
  } else if (isa->getType() != PtrToIdTy)
    isa = llvm::ConstantExpr::getBitCast(isa, PtrToIdTy);

  //  struct
  //  {
  //    Class isa;
  //    uint32_t flags;
  //    uint32_t length; // Number of codepoints
  //    uint32_t size; // Number of bytes
  //    uint32_t hash;
  //    const char *data;
  //  };

  ConstantInitBuilder Builder(CGM);
  auto Fields = Builder.beginStruct();
  if (!CGM.getTriple().isOSBinFormatCOFF()) {
    Fields.add(isa);
  } else {
    Fields.addNullPointer(PtrTy);
  }
  // For now, all non-ASCII strings are represented as UTF-16.  As such, the
  // number of bytes is simply double the number of UTF-16 codepoints.  In
  // ASCII strings, the number of bytes is equal to the number of non-ASCII
  // codepoints.
  if (isNonASCII) {
    unsigned NumU8CodeUnits = Str.size();
    // A UTF-16 representation of a unicode string contains at most the same
    // number of code units as a UTF-8 representation.  Allocate that much
    // space, plus one for the final null character.
    SmallVector<llvm::UTF16, 128> ToBuf(NumU8CodeUnits + 1);
    const llvm::UTF8 *FromPtr = (const llvm::UTF8 *)Str.data();
    llvm::UTF16 *ToPtr = &ToBuf[0];
    (void)llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumU8CodeUnits,
        &ToPtr, ToPtr + NumU8CodeUnits, llvm::strictConversion);
    uint32_t StringLength = ToPtr - &ToBuf[0];
    // Add null terminator
    *ToPtr = 0;
    // Flags: 2 indicates UTF-16 encoding
    Fields.addInt(Int32Ty, 2);
    // Number of UTF-16 codepoints
    Fields.addInt(Int32Ty, StringLength);
    // Number of bytes
    Fields.addInt(Int32Ty, StringLength * 2);
    // Hash.  Not currently initialised by the compiler.
    Fields.addInt(Int32Ty, 0);
    // pointer to the data string.
    auto Arr = llvm::makeArrayRef(&ToBuf[0], ToPtr+1);
    auto *C = llvm::ConstantDataArray::get(VMContext, Arr);
    auto *Buffer = new llvm::GlobalVariable(TheModule, C->getType(),
        /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage, C, ".str");
    Buffer->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
    Fields.add(Buffer);
  } else {
    // Flags: 0 indicates ASCII encoding
    Fields.addInt(Int32Ty, 0);
    // Number of UTF-16 codepoints, each ASCII byte is a UTF-16 codepoint
    Fields.addInt(Int32Ty, Str.size());
    // Number of bytes
    Fields.addInt(Int32Ty, Str.size());
    // Hash.  Not currently initialised by the compiler.
    Fields.addInt(Int32Ty, 0);
    // Data pointer
    Fields.add(MakeConstantString(Str));
  }
  std::string StringName;
  bool isNamed = !isNonASCII;
  if (isNamed) {
    StringName = ".objc_str_";
    for (int i=0,e=Str.size() ; i<e ; ++i) {
      unsigned char c = Str[i];
      if (isalnum(c))
        StringName += c;
      else if (c == ' ')
        StringName += '_';
      else {
        isNamed = false;
        break;
      }
    }
  }
  auto *ObjCStrGV =
    Fields.finishAndCreateGlobal(
        isNamed ? StringRef(StringName) : ".objc_string",
        Align, false, isNamed ? llvm::GlobalValue::LinkOnceODRLinkage
                              : llvm::GlobalValue::PrivateLinkage);
  ObjCStrGV->setSection(sectionName<ConstantStringSection>());
  if (isNamed) {
    ObjCStrGV->setComdat(TheModule.getOrInsertComdat(StringName));
    ObjCStrGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
  }
  if (CGM.getTriple().isOSBinFormatCOFF()) {
    std::pair<llvm::Constant*, int> v{ObjCStrGV, 0};
    EarlyInitList.emplace_back(Sym, v);
  }
  llvm::Constant *ObjCStr = llvm::ConstantExpr::getBitCast(ObjCStrGV, IdTy);
  ObjCStrings[Str] = ObjCStr;
  ConstantStrings.push_back(ObjCStr);
  return ConstantAddress(ObjCStr, Align);
}

void PushProperty(ConstantArrayBuilder &PropertiesArray,
          const ObjCPropertyDecl *property,
          const Decl *OCD,
          bool isSynthesized=true, bool
          isDynamic=true) override {
  // struct objc_property
  // {
  //   const char *name;
  //   const char *attributes;
  //   const char *type;
  //   SEL getter;
  //   SEL setter;
  // };
  auto Fields = PropertiesArray.beginStruct(PropertyMetadataTy);
  ASTContext &Context = CGM.getContext();
  Fields.add(MakeConstantString(property->getNameAsString()));
  std::string TypeStr =
    CGM.getContext().getObjCEncodingForPropertyDecl(property, OCD);
  Fields.add(MakeConstantString(TypeStr));
  std::string typeStr;
  Context.getObjCEncodingForType(property->getType(), typeStr);
  Fields.add(MakeConstantString(typeStr));
  auto addPropertyMethod = [&](const ObjCMethodDecl *accessor) {
    if (accessor) {
      std::string TypeStr = Context.getObjCEncodingForMethodDecl(accessor);
      Fields.add(GetConstantSelector(accessor->getSelector(), TypeStr));
    } else {
      Fields.add(NULLPtr);
    }
  };
  addPropertyMethod(property->getGetterMethodDecl());
  addPropertyMethod(property->getSetterMethodDecl());
  Fields.finishAndAddTo(PropertiesArray);
}

llvm::Constant *
GenerateProtocolMethodList(ArrayRef<const ObjCMethodDecl*> Methods) override {
  // struct objc_protocol_method_description
  // {
  //   SEL selector;
  //   const char *types;
  // };
  llvm::StructType *ObjCMethodDescTy =
    llvm::StructType::get(CGM.getLLVMContext(),
        { PtrToInt8Ty, PtrToInt8Ty });
  ASTContext &Context = CGM.getContext();
  ConstantInitBuilder Builder(CGM);
  // struct objc_protocol_method_description_list
  // {
  //   int count;
  //   int size;
  //   struct objc_protocol_method_description methods[];
  // };
  auto MethodList = Builder.beginStruct();
  // int count;
  MethodList.addInt(IntTy, Methods.size());
  // int size; // sizeof(struct objc_method_description)
  llvm::DataLayout td(&TheModule);
  MethodList.addInt(IntTy, td.getTypeSizeInBits(ObjCMethodDescTy) /
      CGM.getContext().getCharWidth());
  // struct objc_method_description[]
  auto MethodArray = MethodList.beginArray(ObjCMethodDescTy);
  for (auto *M : Methods) {
    auto Method = MethodArray.beginStruct(ObjCMethodDescTy);
    Method.add(CGObjCGNU::GetConstantSelector(M));
    Method.add(GetTypeString(Context.getObjCEncodingForMethodDecl(M, true)));
    Method.finishAndAddTo(MethodArray);
  }
  MethodArray.finishAndAddTo(MethodList);
  return MethodList.finishAndCreateGlobal(".objc_protocol_method_list",
                                          CGM.getPointerAlign());
}
llvm::Constant *GenerateCategoryProtocolList(const ObjCCategoryDecl *OCD)
  override {
  SmallVector<llvm::Constant*, 16> Protocols;
  for (const auto *PI : OCD->getReferencedProtocols())
    Protocols.push_back(
        llvm::ConstantExpr::getBitCast(GenerateProtocolRef(PI),
          ProtocolPtrTy));
  return GenerateProtocolList(Protocols);
}

llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper,
                            llvm::Value *cmd, MessageSendInfo &MSI) override {
  // Don't access the slot unless we're trying to cache the result.
  CGBuilderTy &Builder = CGF.Builder;
  llvm::Value *lookupArgs[] = {CGObjCGNU::EnforceType(Builder, ObjCSuper,
      PtrToObjCSuperTy).getPointer(), cmd};
  return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFn, lookupArgs);
}

llvm::GlobalVariable *GetClassVar(StringRef Name, bool isWeak=false) {
  std::string SymbolName = SymbolForClassRef(Name, isWeak);
  auto *ClassSymbol = TheModule.getNamedGlobal(SymbolName);
  if (ClassSymbol)
    return ClassSymbol;
  ClassSymbol = new llvm::GlobalVariable(TheModule,
      IdTy, false, llvm::GlobalValue::ExternalLinkage,
      nullptr, SymbolName);
  // If this is a weak symbol, then we are creating a valid definition for
  // the symbol, pointing to a weak definition of the real class pointer.  If
  // this is not a weak reference, then we are expecting another compilation
  // unit to provide the real indirection symbol.
  if (isWeak)
    ClassSymbol->setInitializer(new llvm::GlobalVariable(TheModule,
        Int8Ty, false, llvm::GlobalValue::ExternalWeakLinkage,
        nullptr, SymbolForClass(Name)));
  else {
    if (CGM.getTriple().isOSBinFormatCOFF()) {
      IdentifierInfo &II = CGM.getContext().Idents.get(Name);
      TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl();
      DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl);

      const ObjCInterfaceDecl *OID = nullptr;
      for (const auto &Result : DC->lookup(&II))
        if ((OID = dyn_cast<ObjCInterfaceDecl>(Result)))
          break;

      // The first Interface we find may be a @class,
      // which should only be treated as the source of
      // truth in the absence of a true declaration.
      const ObjCInterfaceDecl *OIDDef = OID->getDefinition();
      if (OIDDef != nullptr)
        OID = OIDDef;

      auto Storage = llvm::GlobalValue::DefaultStorageClass;
      if (OID->hasAttr<DLLImportAttr>())
        Storage = llvm::GlobalValue::DLLImportStorageClass;
      else if (OID->hasAttr<DLLExportAttr>())
        Storage = llvm::GlobalValue::DLLExportStorageClass;

      cast<llvm::GlobalValue>(ClassSymbol)->setDLLStorageClass(Storage);
    }
  }
  assert(ClassSymbol->getName() == SymbolName)((ClassSymbol->getName() == SymbolName) ? static_cast<void
> (0) : __assert_fail ("ClassSymbol->getName() == SymbolName"
, "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 1248, __PRETTY_FUNCTION__));
  return ClassSymbol;
}
llvm::Value *GetClassNamed(CodeGenFunction &CGF,
                           const std::string &Name,
                           bool isWeak) override {
  return CGF.Builder.CreateLoad(Address(GetClassVar(Name, isWeak),
        CGM.getPointerAlign()));
}
int32_t FlagsForOwnership(Qualifiers::ObjCLifetime Ownership) {
  // typedef enum {
  //   ownership_invalid = 0,
  //   ownership_strong  = 1,
  //   ownership_weak    = 2,
  //   ownership_unsafe  = 3
  // } ivar_ownership;
  int Flag;
  switch (Ownership) {
    case Qualifiers::OCL_Strong:
        Flag = 1;
        break;
    case Qualifiers::OCL_Weak:
        Flag = 2;
        break;
    case Qualifiers::OCL_ExplicitNone:
        Flag = 3;
        break;
    case Qualifiers::OCL_None:
    case Qualifiers::OCL_Autoreleasing:
      assert(Ownership != Qualifiers::OCL_Autoreleasing)((Ownership != Qualifiers::OCL_Autoreleasing) ? static_cast<
void> (0) : __assert_fail ("Ownership != Qualifiers::OCL_Autoreleasing"
, "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 1277, __PRETTY_FUNCTION__));
      Flag = 0;
  }
  return Flag;
}
llvm::Constant *GenerateIvarList(ArrayRef<llvm::Constant *> IvarNames,
                 ArrayRef<llvm::Constant *> IvarTypes,
                 ArrayRef<llvm::Constant *> IvarOffsets,
                 ArrayRef<llvm::Constant *> IvarAlign,
                 ArrayRef<Qualifiers::ObjCLifetime> IvarOwnership) override {
  llvm_unreachable("Method should not be called!")::llvm::llvm_unreachable_internal("Method should not be called!"
, "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 1287);
}

llvm::Constant *GenerateEmptyProtocol(StringRef ProtocolName) override {
  std::string Name = SymbolForProtocol(ProtocolName);
  auto *GV = TheModule.getGlobalVariable(Name);
  if (!GV) {
    // Emit a placeholder symbol.
    GV = new llvm::GlobalVariable(TheModule, ProtocolTy, false,
        llvm::GlobalValue::ExternalLinkage, nullptr, Name);
    GV->setAlignment(CGM.getPointerAlign().getQuantity());
  }
  return llvm::ConstantExpr::getBitCast(GV, ProtocolPtrTy);
}

/// Existing protocol references.
llvm::StringMap<llvm::Constant*> ExistingProtocolRefs;

llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
                                 const ObjCProtocolDecl *PD) override {
  auto Name = PD->getNameAsString();
  auto *&Ref = ExistingProtocolRefs[Name];
  if (!Ref) {
    auto *&Protocol = ExistingProtocols[Name];
    if (!Protocol)
      Protocol = GenerateProtocolRef(PD);
    std::string RefName = SymbolForProtocolRef(Name);
    assert(!TheModule.getGlobalVariable(RefName))((!TheModule.getGlobalVariable(RefName)) ? static_cast<void
> (0) : __assert_fail ("!TheModule.getGlobalVariable(RefName)"
, "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 1314, __PRETTY_FUNCTION__));
    // Emit a reference symbol.
    auto GV = new llvm::GlobalVariable(TheModule, ProtocolPtrTy,
        false, llvm::GlobalValue::LinkOnceODRLinkage,
        llvm::ConstantExpr::getBitCast(Protocol, ProtocolPtrTy), RefName);
    GV->setComdat(TheModule.getOrInsertComdat(RefName));
    GV->setSection(sectionName<ProtocolReferenceSection>());
    GV->setAlignment(CGM.getPointerAlign().getQuantity());
    Ref = GV;
  }
  EmittedProtocolRef = true;
  return CGF.Builder.CreateAlignedLoad(Ref, CGM.getPointerAlign());
}

llvm::Constant *GenerateProtocolList(ArrayRef<llvm::Constant*> Protocols) {
  llvm::ArrayType *ProtocolArrayTy = llvm::ArrayType::get(ProtocolPtrTy,
      Protocols.size());
  llvm::Constant * ProtocolArray = llvm::ConstantArray::get(ProtocolArrayTy,
      Protocols);
  ConstantInitBuilder builder(CGM);
  auto ProtocolBuilder = builder.beginStruct();
  ProtocolBuilder.addNullPointer(PtrTy);
  ProtocolBuilder.addInt(SizeTy, Protocols.size());
  ProtocolBuilder.add(ProtocolArray);
  return ProtocolBuilder.finishAndCreateGlobal(".objc_protocol_list",
      CGM.getPointerAlign(), false, llvm::GlobalValue::InternalLinkage);
}

void GenerateProtocol(const ObjCProtocolDecl *PD) override {
  // Do nothing - we only emit referenced protocols.
}
llvm::Constant *GenerateProtocolRef(const ObjCProtocolDecl *PD) {
  std::string ProtocolName = PD->getNameAsString();
  auto *&Protocol = ExistingProtocols[ProtocolName];
  if (Protocol)
    return Protocol;

  EmittedProtocol = true;

  auto SymName = SymbolForProtocol(ProtocolName);
  auto *OldGV = TheModule.getGlobalVariable(SymName);

  // Use the protocol definition, if there is one.
  if (const ObjCProtocolDecl *Def = PD->getDefinition())
    PD = Def;
  else {
    // If there is no definition, then create an external linkage symbol and
    // hope that someone else fills it in for us (and fail to link if they
    // don't).
    assert(!OldGV)((!OldGV) ? static_cast<void> (0) : __assert_fail ("!OldGV"
, "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 1363, __PRETTY_FUNCTION__));
    Protocol = new llvm::GlobalVariable(TheModule, ProtocolTy,
      /*isConstant*/false,
      llvm::GlobalValue::ExternalLinkage, nullptr, SymName);
    return Protocol;
  }

  SmallVector<llvm::Constant*, 16> Protocols;
  for (const auto *PI : PD->protocols())
    Protocols.push_back(
        llvm::ConstantExpr::getBitCast(GenerateProtocolRef(PI),
          ProtocolPtrTy));
  llvm::Constant *ProtocolList = GenerateProtocolList(Protocols);

  // Collect information about methods
  llvm::Constant *InstanceMethodList, *OptionalInstanceMethodList;
  llvm::Constant *ClassMethodList, *OptionalClassMethodList;
  EmitProtocolMethodList(PD->instance_methods(), InstanceMethodList,
      OptionalInstanceMethodList);
  EmitProtocolMethodList(PD->class_methods(), ClassMethodList,
      OptionalClassMethodList);

  // The isa pointer must be set to a magic number so the runtime knows it's
  // the correct layout.
  ConstantInitBuilder builder(CGM);
  auto ProtocolBuilder = builder.beginStruct();
  ProtocolBuilder.add(llvm::ConstantExpr::getIntToPtr(
        llvm::ConstantInt::get(Int32Ty, ProtocolVersion), IdTy));
  ProtocolBuilder.add(MakeConstantString(ProtocolName));
  ProtocolBuilder.add(ProtocolList);
  ProtocolBuilder.add(InstanceMethodList);
  ProtocolBuilder.add(ClassMethodList);
  ProtocolBuilder.add(OptionalInstanceMethodList);
  ProtocolBuilder.add(OptionalClassMethodList);
  // Required instance properties
  ProtocolBuilder.add(GeneratePropertyList(nullptr, PD, false, false));
  // Optional instance properties
  ProtocolBuilder.add(GeneratePropertyList(nullptr, PD, false, true));
  // Required class properties
  ProtocolBuilder.add(GeneratePropertyList(nullptr, PD, true, false));
  // Optional class properties
  ProtocolBuilder.add(GeneratePropertyList(nullptr, PD, true, true));

  auto *GV = ProtocolBuilder.finishAndCreateGlobal(SymName,
      CGM.getPointerAlign(), false, llvm::GlobalValue::ExternalLinkage);
  GV->setSection(sectionName<ProtocolSection>());
  GV->setComdat(TheModule.getOrInsertComdat(SymName));
  if (OldGV) {
    OldGV->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GV,
          OldGV->getType()));
    OldGV->removeFromParent();
    GV->setName(SymName);
  }
  Protocol = GV;
  return GV;
}
llvm::Constant *EnforceType(llvm::Constant *Val, llvm::Type *Ty) {
  if (Val->getType() == Ty)
    return Val;
  return llvm::ConstantExpr::getBitCast(Val, Ty);
}
llvm::Value *GetTypedSelector(CodeGenFunction &CGF, Selector Sel,
                              const std::string &TypeEncoding) override {
  return GetConstantSelector(Sel, TypeEncoding);
}
llvm::Constant  *GetTypeString(llvm::StringRef TypeEncoding) {
  if (TypeEncoding.empty())
    return NULLPtr;
  std::string MangledTypes = TypeEncoding;
  std::replace(MangledTypes.begin(), MangledTypes.end(),
    '@', '\1');
  std::string TypesVarName = ".objc_sel_types_" + MangledTypes;
  auto *TypesGlobal = TheModule.getGlobalVariable(TypesVarName);
  if (!TypesGlobal) {
    llvm::Constant *Init = llvm::ConstantDataArray::getString(VMContext,
        TypeEncoding);
    auto *GV = new llvm::GlobalVariable(TheModule, Init->getType(),
        true, llvm::GlobalValue::LinkOnceODRLinkage, Init, TypesVarName);
    GV->setComdat(TheModule.getOrInsertComdat(TypesVarName));
    GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
    TypesGlobal = GV;
  }
  return llvm::ConstantExpr::getGetElementPtr(TypesGlobal->getValueType(),
      TypesGlobal, Zeros);
}
llvm::Constant *GetConstantSelector(Selector Sel,
                                    const std::string &TypeEncoding) override {
  // @ is used as a special character in symbol names (used for symbol
  // versioning), so mangle the name to not include it.  Replace it with a
  // character that is not a valid type encoding character (and, being
  // non-printable, never will be!)
  std::string MangledTypes = TypeEncoding;
  std::replace(MangledTypes.begin(), MangledTypes.end(),
    '@', '\1');
  auto SelVarName = (StringRef(".objc_selector_") + Sel.getAsString() + "_" +
    MangledTypes).str();
  if (auto *GV = TheModule.getNamedGlobal(SelVarName))
    return EnforceType(GV, SelectorTy);
  ConstantInitBuilder builder(CGM);
  auto SelBuilder = builder.beginStruct();
  SelBuilder.add(ExportUniqueString(Sel.getAsString(), ".objc_sel_name_",
        true));
  SelBuilder.add(GetTypeString(TypeEncoding));
  auto *GV = SelBuilder.finishAndCreateGlobal(SelVarName,
      CGM.getPointerAlign(), false, llvm::GlobalValue::LinkOnceODRLinkage);
  GV->setComdat(TheModule.getOrInsertComdat(SelVarName));
  GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
  GV->setSection(sectionName<SelectorSection>());
  auto *SelVal = EnforceType(GV, SelectorTy);
  return SelVal;
}
llvm::StructType *emptyStruct = nullptr;

/// Return pointers to the start and end of a section.  On ELF platforms, we
/// use the __start_ and __stop_ symbols that GNU-compatible linkers will set
/// to the start and end of section names, as long as those section names are
/// valid identifiers and the symbols are referenced but not defined.  On
/// Windows, we use the fact that MSVC-compatible linkers will lexically sort
/// by subsections and place everything that we want to reference in a middle
/// subsection and then insert zero-sized symbols in subsections a and z.
std::pair<llvm::Constant*,llvm::Constant*>
GetSectionBounds(StringRef Section) {
  if (CGM.getTriple().isOSBinFormatCOFF()) {
    if (emptyStruct == nullptr) {
      emptyStruct = llvm::StructType::create(VMContext, ".objc_section_sentinel");
      emptyStruct->setBody({}, /*isPacked*/true);
    }
    auto ZeroInit = llvm::Constant::getNullValue(emptyStruct);
    auto Sym = [&](StringRef Prefix, StringRef SecSuffix) {
      auto *Sym = new llvm::GlobalVariable(TheModule, emptyStruct,
          /*isConstant*/false,
          llvm::GlobalValue::LinkOnceODRLinkage, ZeroInit, Prefix +
          Section);
      Sym->setVisibility(llvm::GlobalValue::HiddenVisibility);
      Sym->setSection((Section + SecSuffix).str());
      Sym->setComdat(TheModule.getOrInsertComdat((Prefix +
          Section).str()));
      Sym->setAlignment(CGM.getPointerAlign().getQuantity());
      return Sym;
    };
    return { Sym("__start_", "$a"), Sym("__stop", "$z") };
  }
  auto *Start = new llvm::GlobalVariable(TheModule, PtrTy,
      /*isConstant*/false,
      llvm::GlobalValue::ExternalLinkage, nullptr, StringRef("__start_") +
      Section);
  Start->setVisibility(llvm::GlobalValue::HiddenVisibility);
  auto *Stop = new llvm::GlobalVariable(TheModule, PtrTy,
      /*isConstant*/false,
      llvm::GlobalValue::ExternalLinkage, nullptr, StringRef("__stop_") +
      Section);
  Stop->setVisibility(llvm::GlobalValue::HiddenVisibility);
  return { Start, Stop };
}
CatchTypeInfo getCatchAllTypeInfo() override {
  return CGM.getCXXABI().getCatchAllTypeInfo();
}
llvm::Function *ModuleInitFunction() override {
  llvm::Function *LoadFunction = llvm::Function::Create(
    llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), false),
    llvm::GlobalValue::LinkOnceODRLinkage, ".objcv2_load_function",
    &TheModule);
  LoadFunction->setVisibility(llvm::GlobalValue::HiddenVisibility);
  LoadFunction->setComdat(TheModule.getOrInsertComdat(".objcv2_load_function"));

  llvm::BasicBlock *EntryBB =
      llvm::BasicBlock::Create(VMContext, "entry", LoadFunction);
  CGBuilderTy B(CGM, VMContext);
  B.SetInsertPoint(EntryBB);
  ConstantInitBuilder builder(CGM);
  auto InitStructBuilder = builder.beginStruct();
  InitStructBuilder.addInt(Int64Ty, 0);
  auto &sectionVec = CGM.getTriple().isOSBinFormatCOFF() ? PECOFFSectionsBaseNames : SectionsBaseNames;
  for (auto *s : sectionVec) {
    auto bounds = GetSectionBounds(s);
    InitStructBuilder.add(bounds.first);
    InitStructBuilder.add(bounds.second);
  }
  auto *InitStruct = InitStructBuilder.finishAndCreateGlobal(".objc_init",
      CGM.getPointerAlign(), false, llvm::GlobalValue::LinkOnceODRLinkage);
  InitStruct->setVisibility(llvm::GlobalValue::HiddenVisibility);
  InitStruct->setComdat(TheModule.getOrInsertComdat(".objc_init"));

  CallRuntimeFunction(B, "__objc_load", {InitStruct});;
  B.CreateRetVoid();
  // Make sure that the optimisers don't delete this function.
  CGM.addCompilerUsedGlobal(LoadFunction);
  // FIXME: Currently ELF only!
  // We have to do this by hand, rather than with @llvm.ctors, so that the
  // linker can remove the duplicate invocations.
  auto *InitVar = new llvm::GlobalVariable(TheModule, LoadFunction->getType(),
      /*isConstant*/true, llvm::GlobalValue::LinkOnceAnyLinkage,
      LoadFunction, ".objc_ctor");
  // Check that this hasn't been renamed.  This shouldn't happen, because
  // this function should be called precisely once.
  assert(InitVar->getName() == ".objc_ctor")((InitVar->getName() == ".objc_ctor") ? static_cast<void
> (0) : __assert_fail ("InitVar->getName() == \".objc_ctor\""
, "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 1558, __PRETTY_FUNCTION__));
  // In Windows, initialisers are sorted by the suffix.  XCL is for library
  // initialisers, which run before user initialisers.  We are running
  // Objective-C loads at the end of library load.  This means +load methods
  // will run before any other static constructors, but that static
  // constructors can see a fully initialised Objective-C state.
  if (CGM.getTriple().isOSBinFormatCOFF())
      InitVar->setSection(".CRT$XCLz");
  else
  {
    if (CGM.getCodeGenOpts().UseInitArray)
      InitVar->setSection(".init_array");
    else
      InitVar->setSection(".ctors");
  }
  InitVar->setVisibility(llvm::GlobalValue::HiddenVisibility);
  InitVar->setComdat(TheModule.getOrInsertComdat(".objc_ctor"));
  CGM.addUsedGlobal(InitVar);
  for (auto *C : Categories) {
    auto *Cat = cast<llvm::GlobalVariable>(C->stripPointerCasts());
    Cat->setSection(sectionName<CategorySection>());
    CGM.addUsedGlobal(Cat);
  }
  auto createNullGlobal = [&](StringRef Name, ArrayRef<llvm::Constant*> Init,
      StringRef Section) {
    auto nullBuilder = builder.beginStruct();
    for (auto *F : Init)
      nullBuilder.add(F);
    auto GV = nullBuilder.finishAndCreateGlobal(Name, CGM.getPointerAlign(),
        false, llvm::GlobalValue::LinkOnceODRLinkage);
    GV->setSection(Section);
    GV->setComdat(TheModule.getOrInsertComdat(Name));
    GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
    CGM.addUsedGlobal(GV);
    return GV;
  };
  for (auto clsAlias : ClassAliases)
    createNullGlobal(std::string(".objc_class_alias") +
        clsAlias.second, { MakeConstantString(clsAlias.second),
        GetClassVar(clsAlias.first) }, sectionName<ClassAliasSection>());
  // On ELF platforms, add a null value for each special section so that we
  // can always guarantee that the _start and _stop symbols will exist and be
  // meaningful.  This is not required on COFF platforms, where our start and
  // stop symbols will create the section.
  if (!CGM.getTriple().isOSBinFormatCOFF()) {
    createNullGlobal(".objc_null_selector", {NULLPtr, NULLPtr},
        sectionName<SelectorSection>());
    if (Categories.empty())
      createNullGlobal(".objc_null_category", {NULLPtr, NULLPtr,
                    NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr},
          sectionName<CategorySection>());
    if (!EmittedClass) {
      createNullGlobal(".objc_null_cls_init_ref", NULLPtr,
          sectionName<ClassSection>());
      createNullGlobal(".objc_null_class_ref", { NULLPtr, NULLPtr },
          sectionName<ClassReferenceSection>());
    }
    if (!EmittedProtocol)
      createNullGlobal(".objc_null_protocol", {NULLPtr, NULLPtr, NULLPtr,
          NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr,
          NULLPtr}, sectionName<ProtocolSection>());
    if (!EmittedProtocolRef)
      createNullGlobal(".objc_null_protocol_ref", {NULLPtr},
          sectionName<ProtocolReferenceSection>());
    if (ClassAliases.empty())
      createNullGlobal(".objc_null_class_alias", { NULLPtr, NULLPtr },
          sectionName<ClassAliasSection>());
    if (ConstantStrings.empty()) {
      auto i32Zero = llvm::ConstantInt::get(Int32Ty, 0);
      createNullGlobal(".objc_null_constant_string", { NULLPtr, i32Zero,
          i32Zero, i32Zero, i32Zero, NULLPtr },
          sectionName<ConstantStringSection>());
    }
  }
  ConstantStrings.clear();
  Categories.clear();
  Classes.clear();

  if (EarlyInitList.size() > 0) {
    auto *Init = llvm::Function::Create(llvm::FunctionType::get(CGM.VoidTy,
          {}), llvm::GlobalValue::InternalLinkage, ".objc_early_init",
        &CGM.getModule());
    llvm::IRBuilder<> b(llvm::BasicBlock::Create(CGM.getLLVMContext(), "entry",
          Init));
    for (const auto &lateInit : EarlyInitList) {
      auto *global = TheModule.getGlobalVariable(lateInit.first);
      if (global) {
        b.CreateAlignedStore(global,
            b.CreateStructGEP(lateInit.second.first, lateInit.second.second), CGM.getPointerAlign().getQuantity());
      }
    }
    b.CreateRetVoid();
    // We can't use the normal LLVM global initialisation array, because we
    // need to specify that this runs early in library initialisation.
    auto *InitVar = new llvm::GlobalVariable(CGM.getModule(), Init->getType(), 
        /*isConstant*/true, llvm::GlobalValue::InternalLinkage,
        Init, ".objc_early_init_ptr");
    InitVar->setSection(".CRT$XCLb");
    CGM.addUsedGlobal(InitVar);
  }
  return nullptr;
}
/// In the v2 ABI, ivar offset variables use the type encoding in their name
/// to trigger linker failures if the types don't match.
std::string GetIVarOffsetVariableName(const ObjCInterfaceDecl *ID,
                                      const ObjCIvarDecl *Ivar) override {
  std::string TypeEncoding;
  CGM.getContext().getObjCEncodingForType(Ivar->getType(), TypeEncoding);
  // Prevent the @ from being interpreted as a symbol version.
  std::replace(TypeEncoding.begin(), TypeEncoding.end(),
    '@', '\1');
  const std::string Name = "__objc_ivar_offset_" + ID->getNameAsString()
    + '.' + Ivar->getNameAsString() + '.' + TypeEncoding;
  return Name;
}
llvm::Value *EmitIvarOffset(CodeGenFunction &CGF,
                            const ObjCInterfaceDecl *Interface,
                            const ObjCIvarDecl *Ivar) override {
  const std::string Name = GetIVarOffsetVariableName(Ivar->getContainingInterface(), Ivar);
  llvm::GlobalVariable *IvarOffsetPointer = TheModule.getNamedGlobal(Name);
  if (!IvarOffsetPointer)
    IvarOffsetPointer = new llvm::GlobalVariable(TheModule, IntTy, false,
            llvm::GlobalValue::ExternalLinkage, nullptr, Name);
  CharUnits Align = CGM.getIntAlign();
  llvm::Value *Offset = CGF.Builder.CreateAlignedLoad(IvarOffsetPointer, Align);
  if (Offset->getType() != PtrDiffTy)
    Offset = CGF.Builder.CreateZExtOrBitCast(Offset, PtrDiffTy);
  return Offset;
}
void GenerateClass(const ObjCImplementationDecl *OID) override {
  ASTContext &Context = CGM.getContext();
  bool IsCOFF = CGM.getTriple().isOSBinFormatCOFF();

  // Get the class name
  ObjCInterfaceDecl *classDecl =
      const_cast<ObjCInterfaceDecl *>(OID->getClassInterface());
  std::string className = classDecl->getNameAsString();
  auto *classNameConstant = MakeConstantString(className);

  ConstantInitBuilder builder(CGM);
  auto metaclassFields = builder.beginStruct();
  // struct objc_class *isa;
  metaclassFields.addNullPointer(PtrTy);
  // struct objc_class *super_class;
  metaclassFields.addNullPointer(PtrTy);
  // const char *name;
  metaclassFields.add(classNameConstant);
  // long version;
  metaclassFields.addInt(LongTy, 0);
  // unsigned long info;
  // objc_class_flag_meta
  metaclassFields.addInt(LongTy, 1);
  // long instance_size;
  // Setting this to zero is consistent with the older ABI, but it might be
  // more sensible to set this to sizeof(struct objc_class)
  metaclassFields.addInt(LongTy, 0);
  // struct objc_ivar_list *ivars;
  metaclassFields.addNullPointer(PtrTy);
  // struct objc_method_list *methods
  // FIXME: Almost identical code is copied and pasted below for the
  // class, but refactoring it cleanly requires C++14 generic lambdas.
  if (OID->classmeth_begin() == OID->classmeth_end())
1
Taking false branch→
    metaclassFields.addNullPointer(PtrTy);
  else {
    SmallVector<ObjCMethodDecl*, 16> ClassMethods;
    ClassMethods.insert(ClassMethods.begin(), OID->classmeth_begin(),
        OID->classmeth_end());
    metaclassFields.addBitCast(
            GenerateMethodList(className, "", ClassMethods, true),
            PtrTy);
  }
  // void *dtable;
  metaclassFields.addNullPointer(PtrTy);
  // IMP cxx_construct;
  metaclassFields.addNullPointer(PtrTy);
  // IMP cxx_destruct;
  metaclassFields.addNullPointer(PtrTy);
  // struct objc_class *subclass_list
  metaclassFields.addNullPointer(PtrTy);
  // struct objc_class *sibling_class
  metaclassFields.addNullPointer(PtrTy);
  // struct objc_protocol_list *protocols;
  metaclassFields.addNullPointer(PtrTy);
  // struct reference_list *extra_data;
  metaclassFields.addNullPointer(PtrTy);
  // long abi_version;
  metaclassFields.addInt(LongTy, 0);
  // struct objc_property_list *properties
  metaclassFields.add(GeneratePropertyList(OID, classDecl, /*isClassProperty*/true));

  auto *metaclass = metaclassFields.finishAndCreateGlobal(
      ManglePublicSymbol("OBJC_METACLASS_") + className,
      CGM.getPointerAlign());

  auto classFields = builder.beginStruct();
  // struct objc_class *isa;
  classFields.add(metaclass);
  // struct objc_class *super_class;
  // Get the superclass name.
  const ObjCInterfaceDecl * SuperClassDecl =
    OID->getClassInterface()->getSuperClass();
  llvm::Constant *SuperClass = nullptr;
  if (SuperClassDecl) {
2
←
Assuming 'SuperClassDecl' is null→
3
←
Taking false branch→
    auto SuperClassName = SymbolForClass(SuperClassDecl->getNameAsString());
    SuperClass = TheModule.getNamedGlobal(SuperClassName);
    if (!SuperClass)
    {
      SuperClass = new llvm::GlobalVariable(TheModule, PtrTy, false,
          llvm::GlobalValue::ExternalLinkage, nullptr, SuperClassName);
      if (IsCOFF) {
        auto Storage = llvm::GlobalValue::DefaultStorageClass;
        if (SuperClassDecl->hasAttr<DLLImportAttr>())
          Storage = llvm::GlobalValue::DLLImportStorageClass;
        else if (SuperClassDecl->hasAttr<DLLExportAttr>())
          Storage = llvm::GlobalValue::DLLExportStorageClass;

        cast<llvm::GlobalValue>(SuperClass)->setDLLStorageClass(Storage);
      }
    }
    if (!IsCOFF)
      classFields.add(llvm::ConstantExpr::getBitCast(SuperClass, PtrTy));
    else
      classFields.addNullPointer(PtrTy);
  } else
    classFields.addNullPointer(PtrTy);
  // const char *name;
  classFields.add(classNameConstant);
  // long version;
  classFields.addInt(LongTy, 0);
  // unsigned long info;
  // !objc_class_flag_meta
  classFields.addInt(LongTy, 0);
  // long instance_size;
  int superInstanceSize = !SuperClassDecl3.1
'SuperClassDecl' is null
1
'SuperClassDecl' is null
 ? 0 :
4
←
'?' condition is true→
    Context.getASTObjCInterfaceLayout(SuperClassDecl).getSize().getQuantity();
  // Instance size is negative for classes that have not yet had their ivar
  // layout calculated.
  classFields.addInt(LongTy,
    0 - (Context.getASTObjCImplementationLayout(OID).getSize().getQuantity() -
    superInstanceSize));

  if (classDecl->all_declared_ivar_begin() == nullptr)
5
←
Assuming the condition is false→
6
←
Taking false branch→
    classFields.addNullPointer(PtrTy);
  else {
    int ivar_count = 0;
    for (const ObjCIvarDecl *IVD = classDecl->all_declared_ivar_begin(); IVD;
7
←
Loop condition is false. Execution continues on line 1805→
         IVD = IVD->getNextIvar()) ivar_count++;
    llvm::DataLayout td(&TheModule);
    // struct objc_ivar_list *ivars;
    ConstantInitBuilder b(CGM);
    auto ivarListBuilder = b.beginStruct();
    // int count;
    ivarListBuilder.addInt(IntTy, ivar_count);
    // size_t size;
    llvm::StructType *ObjCIvarTy = llvm::StructType::get(
      PtrToInt8Ty,
      PtrToInt8Ty,
      PtrToInt8Ty,
      Int32Ty,
      Int32Ty);
    ivarListBuilder.addInt(SizeTy, td.getTypeSizeInBits(ObjCIvarTy) /
        CGM.getContext().getCharWidth());
    // struct objc_ivar ivars[]
    auto ivarArrayBuilder = ivarListBuilder.beginArray();
    for (const ObjCIvarDecl *IVD = classDecl->all_declared_ivar_begin(); IVD;
8
←
Loop condition is true.  Entering loop body→
         IVD = IVD->getNextIvar()) {
      auto ivarTy = IVD->getType();
      auto ivarBuilder = ivarArrayBuilder.beginStruct();
      // const char *name;
      ivarBuilder.add(MakeConstantString(IVD->getNameAsString()));
      // const char *type;
      std::string TypeStr;
      //Context.getObjCEncodingForType(ivarTy, TypeStr, IVD, true);
      Context.getObjCEncodingForMethodParameter(Decl::OBJC_TQ_None, ivarTy, TypeStr, true);
      ivarBuilder.add(MakeConstantString(TypeStr));
      // int *offset;
      uint64_t BaseOffset = ComputeIvarBaseOffset(CGM, OID, IVD);
      uint64_t Offset = BaseOffset - superInstanceSize;
      llvm::Constant *OffsetValue = llvm::ConstantInt::get(IntTy, Offset);
      std::string OffsetName = GetIVarOffsetVariableName(classDecl, IVD);
      llvm::GlobalVariable *OffsetVar = TheModule.getGlobalVariable(OffsetName);
      if (OffsetVar)
9
←
Assuming 'OffsetVar' is null→
10
←
Taking false branch→
        OffsetVar->setInitializer(OffsetValue);
      else
        OffsetVar = new llvm::GlobalVariable(TheModule, IntTy,
          false, llvm::GlobalValue::ExternalLinkage,
          OffsetValue, OffsetName);
      auto ivarVisibility =
          (IVD->getAccessControl() == ObjCIvarDecl::Private ||
11
←
Assuming the condition is false→
14
←
'?' condition is false→
           IVD->getAccessControl() == ObjCIvarDecl::Package ||
12
←
Assuming the condition is false→
           classDecl->getVisibility() == HiddenVisibility) ?
13
←
Assuming the condition is false→
                  llvm::GlobalValue::HiddenVisibility :
                  llvm::GlobalValue::DefaultVisibility;
      OffsetVar->setVisibility(ivarVisibility);
      ivarBuilder.add(OffsetVar);
      // Ivar size
      ivarBuilder.addInt(Int32Ty,
          CGM.getContext().getTypeSizeInChars(ivarTy).getQuantity());
      // Alignment will be stored as a base-2 log of the alignment.
      int align = llvm::Log2_32(Context.getTypeAlignInChars(ivarTy).getQuantity());
15
←
Calling 'Log2_32'→
17
←
Returning from 'Log2_32'→
18
←
'align' initialized to -1→
      // Objects that require more than 2^64-byte alignment should be impossible!
      assert18.1
'align' is < 64
1
'align' is < 64
(align < 64)((align < 64) ? static_cast<void> (0) : __assert_fail
 ("align < 64", "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 1859, __PRETTY_FUNCTION__));
19
←
'?' condition is true→
      // uint32_t flags;
      // Bits 0-1 are ownership.
      // Bit 2 indicates an extended type encoding
      // Bits 3-8 contain log2(aligment)
      ivarBuilder.addInt(Int32Ty,
          (align << 3) | (1<<2) |
20
←
The result of the left shift is undefined because the left operand is negative
          FlagsForOwnership(ivarTy.getQualifiers().getObjCLifetime()));
      ivarBuilder.finishAndAddTo(ivarArrayBuilder);
    }
    ivarArrayBuilder.finishAndAddTo(ivarListBuilder);
    auto ivarList = ivarListBuilder.finishAndCreateGlobal(".objc_ivar_list",
        CGM.getPointerAlign(), /*constant*/ false,
        llvm::GlobalValue::PrivateLinkage);
    classFields.add(ivarList);
  }
  // struct objc_method_list *methods
  SmallVector<const ObjCMethodDecl*, 16> InstanceMethods;
  InstanceMethods.insert(InstanceMethods.begin(), OID->instmeth_begin(),
      OID->instmeth_end());
  for (auto *propImpl : OID->property_impls())
    if (propImpl->getPropertyImplementation() ==
        ObjCPropertyImplDecl::Synthesize) {
      ObjCPropertyDecl *prop = propImpl->getPropertyDecl();
      auto addIfExists = [&](const ObjCMethodDecl* OMD) {
        if (OMD)
          InstanceMethods.push_back(OMD);
      };
      addIfExists(prop->getGetterMethodDecl());
      addIfExists(prop->getSetterMethodDecl());
    }

  if (InstanceMethods.size() == 0)
    classFields.addNullPointer(PtrTy);
  else
    classFields.addBitCast(
            GenerateMethodList(className, "", InstanceMethods, false),
            PtrTy);
  // void *dtable;
  classFields.addNullPointer(PtrTy);
  // IMP cxx_construct;
  classFields.addNullPointer(PtrTy);
  // IMP cxx_destruct;
  classFields.addNullPointer(PtrTy);
  // struct objc_class *subclass_list
  classFields.addNullPointer(PtrTy);
  // struct objc_class *sibling_class
  classFields.addNullPointer(PtrTy);
  // struct objc_protocol_list *protocols;
  SmallVector<llvm::Constant*, 16> Protocols;
  for (const auto *I : classDecl->protocols())
    Protocols.push_back(
        llvm::ConstantExpr::getBitCast(GenerateProtocolRef(I),
          ProtocolPtrTy));
  if (Protocols.empty())
    classFields.addNullPointer(PtrTy);
  else
    classFields.add(GenerateProtocolList(Protocols));
  // struct reference_list *extra_data;
  classFields.addNullPointer(PtrTy);
  // long abi_version;
  classFields.addInt(LongTy, 0);
  // struct objc_property_list *properties
  classFields.add(GeneratePropertyList(OID, classDecl));

  auto *classStruct =
    classFields.finishAndCreateGlobal(SymbolForClass(className),
      CGM.getPointerAlign(), false, llvm::GlobalValue::ExternalLinkage);

  auto *classRefSymbol = GetClassVar(className);
  classRefSymbol->setSection(sectionName<ClassReferenceSection>());
  classRefSymbol->setInitializer(llvm::ConstantExpr::getBitCast(classStruct, IdTy));

  if (IsCOFF) {
    // we can't import a class struct.
    if (OID->getClassInterface()->hasAttr<DLLExportAttr>()) {
      cast<llvm::GlobalValue>(classStruct)->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
      cast<llvm::GlobalValue>(classRefSymbol)->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
    }

    if (SuperClass) {
      std::pair<llvm::Constant*, int> v{classStruct, 1};
      EarlyInitList.emplace_back(SuperClass->getName(), std::move(v));
    }

  }


  // Resolve the class aliases, if they exist.
  // FIXME: Class pointer aliases shouldn't exist!
  if (ClassPtrAlias) {
    ClassPtrAlias->replaceAllUsesWith(
        llvm::ConstantExpr::getBitCast(classStruct, IdTy));
    ClassPtrAlias->eraseFromParent();
    ClassPtrAlias = nullptr;
  }
  if (auto Placeholder =
      TheModule.getNamedGlobal(SymbolForClass(className)))
    if (Placeholder != classStruct) {
      Placeholder->replaceAllUsesWith(
          llvm::ConstantExpr::getBitCast(classStruct, Placeholder->getType()));
      Placeholder->eraseFromParent();
      classStruct->setName(SymbolForClass(className));
    }
  if (MetaClassPtrAlias) {
    MetaClassPtrAlias->replaceAllUsesWith(
        llvm::ConstantExpr::getBitCast(metaclass, IdTy));
    MetaClassPtrAlias->eraseFromParent();
    MetaClassPtrAlias = nullptr;
  }
  assert(classStruct->getName() == SymbolForClass(className))((classStruct->getName() == SymbolForClass(className)) ? static_cast
<void> (0) : __assert_fail ("classStruct->getName() == SymbolForClass(className)"
, "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 1969, __PRETTY_FUNCTION__));

  auto classInitRef = new llvm::GlobalVariable(TheModule,
      classStruct->getType(), false, llvm::GlobalValue::ExternalLinkage,
      classStruct, ManglePublicSymbol("OBJC_INIT_CLASS_") + className);
  classInitRef->setSection(sectionName<ClassSection>());
  CGM.addUsedGlobal(classInitRef);

  EmittedClass = true;
}
public:
  CGObjCGNUstep2(CodeGenModule &Mod) : CGObjCGNUstep(Mod, 10, 4, 2) {
    MsgLookupSuperFn.init(&CGM, "objc_msg_lookup_super", IMPTy,
                          PtrToObjCSuperTy, SelectorTy);
    // struct objc_property
    // {
    //   const char *name;
    //   const char *attributes;
    //   const char *type;
    //   SEL getter;
    //   SEL setter;
    // }
    PropertyMetadataTy =
      llvm::StructType::get(CGM.getLLVMContext(),
          { PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty });
  }

1996};

1998const char *const CGObjCGNUstep2::SectionsBaseNames[8] =
1999{
2000"__objc_selectors",
2001"__objc_classes",
2002"__objc_class_refs",
2003"__objc_cats",
2004"__objc_protocols",
2005"__objc_protocol_refs",
2006"__objc_class_aliases",
2007"__objc_constant_string"
2008};

2010const char *const CGObjCGNUstep2::PECOFFSectionsBaseNames[8] =
2011{
2012".objcrt$SEL",
2013".objcrt$CLS",
2014".objcrt$CLR",
2015".objcrt$CAT",
2016".objcrt$PCL",
2017".objcrt$PCR",
2018".objcrt$CAL",
2019".objcrt$STR"
2020};

2022/// Support for the ObjFW runtime.
2023class CGObjCObjFW: public CGObjCGNU {
2024protected:
/// The GCC ABI message lookup function.  Returns an IMP pointing to the
/// method implementation for this message.
LazyRuntimeFunction MsgLookupFn;
/// stret lookup function.  While this does not seem to make sense at the
/// first look, this is required to call the correct forwarding function.
LazyRuntimeFunction MsgLookupFnSRet;
/// The GCC ABI superclass message lookup function.  Takes a pointer to a
/// structure describing the receiver and the class, and a selector as
/// arguments.  Returns the IMP for the corresponding method.
LazyRuntimeFunction MsgLookupSuperFn, MsgLookupSuperFnSRet;

llvm::Value *LookupIMP(CodeGenFunction &CGF, llvm::Value *&Receiver,
                       llvm::Value *cmd, llvm::MDNode *node,
                       MessageSendInfo &MSI) override {
  CGBuilderTy &Builder = CGF.Builder;
  llvm::Value *args[] = {
          EnforceType(Builder, Receiver, IdTy),
          EnforceType(Builder, cmd, SelectorTy) };

  llvm::CallBase *imp;
  if (CGM.ReturnTypeUsesSRet(MSI.CallInfo))
    imp = CGF.EmitRuntimeCallOrInvoke(MsgLookupFnSRet, args);
  else
    imp = CGF.EmitRuntimeCallOrInvoke(MsgLookupFn, args);

  imp->setMetadata(msgSendMDKind, node);
  return imp;
}

llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper,
                            llvm::Value *cmd, MessageSendInfo &MSI) override {
  CGBuilderTy &Builder = CGF.Builder;
  llvm::Value *lookupArgs[] = {
      EnforceType(Builder, ObjCSuper.getPointer(), PtrToObjCSuperTy), cmd,
  };

  if (CGM.ReturnTypeUsesSRet(MSI.CallInfo))
    return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFnSRet, lookupArgs);
  else
    return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFn, lookupArgs);
}

llvm::Value *GetClassNamed(CodeGenFunction &CGF, const std::string &Name,
                           bool isWeak) override {
  if (isWeak)
    return CGObjCGNU::GetClassNamed(CGF, Name, isWeak);

  EmitClassRef(Name);
  std::string SymbolName = "_OBJC_CLASS_" + Name;
  llvm::GlobalVariable *ClassSymbol = TheModule.getGlobalVariable(SymbolName);
  if (!ClassSymbol)
    ClassSymbol = new llvm::GlobalVariable(TheModule, LongTy, false,
                                           llvm::GlobalValue::ExternalLinkage,
                                           nullptr, SymbolName);
  return ClassSymbol;
}

2082public:
CGObjCObjFW(CodeGenModule &Mod): CGObjCGNU(Mod, 9, 3) {
  // IMP objc_msg_lookup(id, SEL);
  MsgLookupFn.init(&CGM, "objc_msg_lookup", IMPTy, IdTy, SelectorTy);
  MsgLookupFnSRet.init(&CGM, "objc_msg_lookup_stret", IMPTy, IdTy,
                       SelectorTy);
  // IMP objc_msg_lookup_super(struct objc_super*, SEL);
  MsgLookupSuperFn.init(&CGM, "objc_msg_lookup_super", IMPTy,
                        PtrToObjCSuperTy, SelectorTy);
  MsgLookupSuperFnSRet.init(&CGM, "objc_msg_lookup_super_stret", IMPTy,
                            PtrToObjCSuperTy, SelectorTy);
}
2094};
2095} // end anonymous namespace

2097/// Emits a reference to a dummy variable which is emitted with each class.
2098/// This ensures that a linker error will be generated when trying to link
2099/// together modules where a referenced class is not defined.
2100void CGObjCGNU::EmitClassRef(const std::string &className) {
std::string symbolRef = "__objc_class_ref_" + className;
// Don't emit two copies of the same symbol
if (TheModule.getGlobalVariable(symbolRef))
  return;
std::string symbolName = "__objc_class_name_" + className;
llvm::GlobalVariable *ClassSymbol = TheModule.getGlobalVariable(symbolName);
if (!ClassSymbol) {
  ClassSymbol = new llvm::GlobalVariable(TheModule, LongTy, false,
                                         llvm::GlobalValue::ExternalLinkage,
                                         nullptr, symbolName);
}
new llvm::GlobalVariable(TheModule, ClassSymbol->getType(), true,
  llvm::GlobalValue::WeakAnyLinkage, ClassSymbol, symbolRef);
2114}

2116CGObjCGNU::CGObjCGNU(CodeGenModule &cgm, unsigned runtimeABIVersion,
                   unsigned protocolClassVersion, unsigned classABI)
: CGObjCRuntime(cgm), TheModule(CGM.getModule()),
  VMContext(cgm.getLLVMContext()), ClassPtrAlias(nullptr),
  MetaClassPtrAlias(nullptr), RuntimeVersion(runtimeABIVersion),
  ProtocolVersion(protocolClassVersion), ClassABIVersion(classABI) {

msgSendMDKind = VMContext.getMDKindID("GNUObjCMessageSend");
usesSEHExceptions =
    cgm.getContext().getTargetInfo().getTriple().isWindowsMSVCEnvironment();

CodeGenTypes &Types = CGM.getTypes();
IntTy = cast<llvm::IntegerType>(
    Types.ConvertType(CGM.getContext().IntTy));
LongTy = cast<llvm::IntegerType>(
    Types.ConvertType(CGM.getContext().LongTy));
SizeTy = cast<llvm::IntegerType>(
    Types.ConvertType(CGM.getContext().getSizeType()));
PtrDiffTy = cast<llvm::IntegerType>(
    Types.ConvertType(CGM.getContext().getPointerDiffType()));
BoolTy = CGM.getTypes().ConvertType(CGM.getContext().BoolTy);

Int8Ty = llvm::Type::getInt8Ty(VMContext);
// C string type.  Used in lots of places.
PtrToInt8Ty = llvm::PointerType::getUnqual(Int8Ty);
ProtocolPtrTy = llvm::PointerType::getUnqual(
    Types.ConvertType(CGM.getContext().getObjCProtoType()));

Zeros[0] = llvm::ConstantInt::get(LongTy, 0);
Zeros[1] = Zeros[0];
NULLPtr = llvm::ConstantPointerNull::get(PtrToInt8Ty);
// Get the selector Type.
QualType selTy = CGM.getContext().getObjCSelType();
if (QualType() == selTy) {
  SelectorTy = PtrToInt8Ty;
} else {
  SelectorTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(selTy));
}

PtrToIntTy = llvm::PointerType::getUnqual(IntTy);
PtrTy = PtrToInt8Ty;

Int32Ty = llvm::Type::getInt32Ty(VMContext);
Int64Ty = llvm::Type::getInt64Ty(VMContext);

IntPtrTy =
    CGM.getDataLayout().getPointerSizeInBits() == 32 ? Int32Ty : Int64Ty;

// Object type
QualType UnqualIdTy = CGM.getContext().getObjCIdType();
ASTIdTy = CanQualType();
if (UnqualIdTy != QualType()) {
  ASTIdTy = CGM.getContext().getCanonicalType(UnqualIdTy);
  IdTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(ASTIdTy));
} else {
  IdTy = PtrToInt8Ty;
}
PtrToIdTy = llvm::PointerType::getUnqual(IdTy);
ProtocolTy = llvm::StructType::get(IdTy,
    PtrToInt8Ty, // name
    PtrToInt8Ty, // protocols
    PtrToInt8Ty, // instance methods
    PtrToInt8Ty, // class methods
    PtrToInt8Ty, // optional instance methods
    PtrToInt8Ty, // optional class methods
    PtrToInt8Ty, // properties
    PtrToInt8Ty);// optional properties

// struct objc_property_gsv1
// {
//   const char *name;
//   char attributes;
//   char attributes2;
//   char unused1;
//   char unused2;
//   const char *getter_name;
//   const char *getter_types;
//   const char *setter_name;
//   const char *setter_types;
// }
PropertyMetadataTy = llvm::StructType::get(CGM.getLLVMContext(), {
    PtrToInt8Ty, Int8Ty, Int8Ty, Int8Ty, Int8Ty, PtrToInt8Ty, PtrToInt8Ty,
    PtrToInt8Ty, PtrToInt8Ty });

ObjCSuperTy = llvm::StructType::get(IdTy, IdTy);
PtrToObjCSuperTy = llvm::PointerType::getUnqual(ObjCSuperTy);

llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);

// void objc_exception_throw(id);
ExceptionThrowFn.init(&CGM, "objc_exception_throw", VoidTy, IdTy);
ExceptionReThrowFn.init(&CGM, "objc_exception_throw", VoidTy, IdTy);
// int objc_sync_enter(id);
SyncEnterFn.init(&CGM, "objc_sync_enter", IntTy, IdTy);
// int objc_sync_exit(id);
SyncExitFn.init(&CGM, "objc_sync_exit", IntTy, IdTy);

// void objc_enumerationMutation (id)
EnumerationMutationFn.init(&CGM, "objc_enumerationMutation", VoidTy, IdTy);

// id objc_getProperty(id, SEL, ptrdiff_t, BOOL)
GetPropertyFn.init(&CGM, "objc_getProperty", IdTy, IdTy, SelectorTy,
                   PtrDiffTy, BoolTy);
// void objc_setProperty(id, SEL, ptrdiff_t, id, BOOL, BOOL)
SetPropertyFn.init(&CGM, "objc_setProperty", VoidTy, IdTy, SelectorTy,
                   PtrDiffTy, IdTy, BoolTy, BoolTy);
// void objc_setPropertyStruct(void*, void*, ptrdiff_t, BOOL, BOOL)
GetStructPropertyFn.init(&CGM, "objc_getPropertyStruct", VoidTy, PtrTy, PtrTy,
                         PtrDiffTy, BoolTy, BoolTy);
// void objc_setPropertyStruct(void*, void*, ptrdiff_t, BOOL, BOOL)
SetStructPropertyFn.init(&CGM, "objc_setPropertyStruct", VoidTy, PtrTy, PtrTy,
                         PtrDiffTy, BoolTy, BoolTy);

// IMP type
llvm::Type *IMPArgs[] = { IdTy, SelectorTy };
IMPTy = llvm::PointerType::getUnqual(llvm::FunctionType::get(IdTy, IMPArgs,
            true));

const LangOptions &Opts = CGM.getLangOpts();
if ((Opts.getGC() != LangOptions::NonGC) || Opts.ObjCAutoRefCount)
  RuntimeVersion = 10;

// Don't bother initialising the GC stuff unless we're compiling in GC mode
if (Opts.getGC() != LangOptions::NonGC) {
  // This is a bit of an hack.  We should sort this out by having a proper
  // CGObjCGNUstep subclass for GC, but we may want to really support the old
  // ABI and GC added in ObjectiveC2.framework, so we fudge it a bit for now
  // Get selectors needed in GC mode
  RetainSel = GetNullarySelector("retain", CGM.getContext());
  ReleaseSel = GetNullarySelector("release", CGM.getContext());
  AutoreleaseSel = GetNullarySelector("autorelease", CGM.getContext());

  // Get functions needed in GC mode

  // id objc_assign_ivar(id, id, ptrdiff_t);
  IvarAssignFn.init(&CGM, "objc_assign_ivar", IdTy, IdTy, IdTy, PtrDiffTy);
  // id objc_assign_strongCast (id, id*)
  StrongCastAssignFn.init(&CGM, "objc_assign_strongCast", IdTy, IdTy,
                          PtrToIdTy);
  // id objc_assign_global(id, id*);
  GlobalAssignFn.init(&CGM, "objc_assign_global", IdTy, IdTy, PtrToIdTy);
  // id objc_assign_weak(id, id*);
  WeakAssignFn.init(&CGM, "objc_assign_weak", IdTy, IdTy, PtrToIdTy);
  // id objc_read_weak(id*);
  WeakReadFn.init(&CGM, "objc_read_weak", IdTy, PtrToIdTy);
  // void *objc_memmove_collectable(void*, void *, size_t);
  MemMoveFn.init(&CGM, "objc_memmove_collectable", PtrTy, PtrTy, PtrTy,
                 SizeTy);
}
2265}

2267llvm::Value *CGObjCGNU::GetClassNamed(CodeGenFunction &CGF,
                                    const std::string &Name, bool isWeak) {
llvm::Constant *ClassName = MakeConstantString(Name);
// With the incompatible ABI, this will need to be replaced with a direct
// reference to the class symbol.  For the compatible nonfragile ABI we are
// still performing this lookup at run time but emitting the symbol for the
// class externally so that we can make the switch later.
//
// Libobjc2 contains an LLVM pass that replaces calls to objc_lookup_class
// with memoized versions or with static references if it's safe to do so.
if (!isWeak)
  EmitClassRef(Name);

llvm::FunctionCallee ClassLookupFn = CGM.CreateRuntimeFunction(
    llvm::FunctionType::get(IdTy, PtrToInt8Ty, true), "objc_lookup_class");
return CGF.EmitNounwindRuntimeCall(ClassLookupFn, ClassName);
2283}

2285// This has to perform the lookup every time, since posing and related
2286// techniques can modify the name -> class mapping.
2287llvm::Value *CGObjCGNU::GetClass(CodeGenFunction &CGF,
                               const ObjCInterfaceDecl *OID) {
auto *Value =
    GetClassNamed(CGF, OID->getNameAsString(), OID->isWeakImported());
if (auto *ClassSymbol = dyn_cast<llvm::GlobalVariable>(Value))
  CGM.setGVProperties(ClassSymbol, OID);
return Value;
2294}

2296llvm::Value *CGObjCGNU::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) {
auto *Value  = GetClassNamed(CGF, "NSAutoreleasePool", false);
if (CGM.getTriple().isOSBinFormatCOFF()) {
  if (auto *ClassSymbol = dyn_cast<llvm::GlobalVariable>(Value)) {
    IdentifierInfo &II = CGF.CGM.getContext().Idents.get("NSAutoreleasePool");
    TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl();
    DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl);

    const VarDecl *VD = nullptr;
    for (const auto &Result : DC->lookup(&II))
      if ((VD = dyn_cast<VarDecl>(Result)))
        break;

    CGM.setGVProperties(ClassSymbol, VD);
  }
}
return Value;
2313}

2315llvm::Value *CGObjCGNU::GetTypedSelector(CodeGenFunction &CGF, Selector Sel,
                                       const std::string &TypeEncoding) {
SmallVectorImpl<TypedSelector> &Types = SelectorTable[Sel];
llvm::GlobalAlias *SelValue = nullptr;

for (SmallVectorImpl<TypedSelector>::iterator i = Types.begin(),
    e = Types.end() ; i!=e ; i++) {
  if (i->first == TypeEncoding) {
    SelValue = i->second;
    break;
  }
}
if (!SelValue) {
  SelValue = llvm::GlobalAlias::create(
      SelectorTy->getElementType(), 0, llvm::GlobalValue::PrivateLinkage,
      ".objc_selector_" + Sel.getAsString(), &TheModule);
  Types.emplace_back(TypeEncoding, SelValue);
}

return SelValue;
2335}

2337Address CGObjCGNU::GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) {
llvm::Value *SelValue = GetSelector(CGF, Sel);

// Store it to a temporary.  Does this satisfy the semantics of
// GetAddrOfSelector?  Hopefully.
Address tmp = CGF.CreateTempAlloca(SelValue->getType(),
                                   CGF.getPointerAlign());
CGF.Builder.CreateStore(SelValue, tmp);
return tmp;
2346}

2348llvm::Value *CGObjCGNU::GetSelector(CodeGenFunction &CGF, Selector Sel) {
return GetTypedSelector(CGF, Sel, std::string());
2350}

2352llvm::Value *CGObjCGNU::GetSelector(CodeGenFunction &CGF,
                                  const ObjCMethodDecl *Method) {
std::string SelTypes = CGM.getContext().getObjCEncodingForMethodDecl(Method);
return GetTypedSelector(CGF, Method->getSelector(), SelTypes);
2356}

2358llvm::Constant *CGObjCGNU::GetEHType(QualType T) {
if (T->isObjCIdType() || T->isObjCQualifiedIdType()) {
  // With the old ABI, there was only one kind of catchall, which broke
  // foreign exceptions.  With the new ABI, we use __objc_id_typeinfo as
  // a pointer indicating object catchalls, and NULL to indicate real
  // catchalls
  if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
    return MakeConstantString("@id");
  } else {
    return nullptr;
  }
}

// All other types should be Objective-C interface pointer types.
const ObjCObjectPointerType *OPT = T->getAs<ObjCObjectPointerType>();
assert(OPT && "Invalid @catch type.")((OPT && "Invalid @catch type.") ? static_cast<void
> (0) : __assert_fail ("OPT && \"Invalid @catch type.\""
, "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 2373, __PRETTY_FUNCTION__));
const ObjCInterfaceDecl *IDecl = OPT->getObjectType()->getInterface();
assert(IDecl && "Invalid @catch type.")((IDecl && "Invalid @catch type.") ? static_cast<void
> (0) : __assert_fail ("IDecl && \"Invalid @catch type.\""
, "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 2375, __PRETTY_FUNCTION__));
return MakeConstantString(IDecl->getIdentifier()->getName());
2377}

2379llvm::Constant *CGObjCGNUstep::GetEHType(QualType T) {
if (usesSEHExceptions)
  return CGM.getCXXABI().getAddrOfRTTIDescriptor(T);

if (!CGM.getLangOpts().CPlusPlus)
  return CGObjCGNU::GetEHType(T);

// For Objective-C++, we want to provide the ability to catch both C++ and
// Objective-C objects in the same function.

// There's a particular fixed type info for 'id'.
if (T->isObjCIdType() ||
    T->isObjCQualifiedIdType()) {
  llvm::Constant *IDEHType =
    CGM.getModule().getGlobalVariable("__objc_id_type_info");
  if (!IDEHType)
    IDEHType =
      new llvm::GlobalVariable(CGM.getModule(), PtrToInt8Ty,
                               false,
                               llvm::GlobalValue::ExternalLinkage,
                               nullptr, "__objc_id_type_info");
  return llvm::ConstantExpr::getBitCast(IDEHType, PtrToInt8Ty);
}

const ObjCObjectPointerType *PT =
  T->getAs<ObjCObjectPointerType>();
assert(PT && "Invalid @catch type.")((PT && "Invalid @catch type.") ? static_cast<void
> (0) : __assert_fail ("PT && \"Invalid @catch type.\""
, "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 2405, __PRETTY_FUNCTION__));
const ObjCInterfaceType *IT = PT->getInterfaceType();
assert(IT && "Invalid @catch type.")((IT && "Invalid @catch type.") ? static_cast<void
> (0) : __assert_fail ("IT && \"Invalid @catch type.\""
, "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 2407, __PRETTY_FUNCTION__));
std::string className = IT->getDecl()->getIdentifier()->getName();

std::string typeinfoName = "__objc_eh_typeinfo_" + className;

// Return the existing typeinfo if it exists
llvm::Constant *typeinfo = TheModule.getGlobalVariable(typeinfoName);
if (typeinfo)
  return llvm::ConstantExpr::getBitCast(typeinfo, PtrToInt8Ty);

// Otherwise create it.

// vtable for gnustep::libobjc::__objc_class_type_info
// It's quite ugly hard-coding this.  Ideally we'd generate it using the host
// platform's name mangling.
const char *vtableName = "_ZTVN7gnustep7libobjc22__objc_class_type_infoE";
auto *Vtable = TheModule.getGlobalVariable(vtableName);
if (!Vtable) {
  Vtable = new llvm::GlobalVariable(TheModule, PtrToInt8Ty, true,
                                    llvm::GlobalValue::ExternalLinkage,
                                    nullptr, vtableName);
}
llvm::Constant *Two = llvm::ConstantInt::get(IntTy, 2);
auto *BVtable = llvm::ConstantExpr::getBitCast(
    llvm::ConstantExpr::getGetElementPtr(Vtable->getValueType(), Vtable, Two),
    PtrToInt8Ty);

llvm::Constant *typeName =
  ExportUniqueString(className, "__objc_eh_typename_");

ConstantInitBuilder builder(CGM);
auto fields = builder.beginStruct();
fields.add(BVtable);
fields.add(typeName);
llvm::Constant *TI =
  fields.finishAndCreateGlobal("__objc_eh_typeinfo_" + className,
                               CGM.getPointerAlign(),
                               /*constant*/ false,
                               llvm::GlobalValue::LinkOnceODRLinkage);
return llvm::ConstantExpr::getBitCast(TI, PtrToInt8Ty);
2447}

2449/// Generate an NSConstantString object.
2450ConstantAddress CGObjCGNU::GenerateConstantString(const StringLiteral *SL) {

std::string Str = SL->getString().str();
CharUnits Align = CGM.getPointerAlign();

// Look for an existing one
llvm::StringMap<llvm::Constant*>::iterator old = ObjCStrings.find(Str);
if (old != ObjCStrings.end())
  return ConstantAddress(old->getValue(), Align);

StringRef StringClass = CGM.getLangOpts().ObjCConstantStringClass;

if (StringClass.empty()) StringClass = "NSConstantString";

std::string Sym = "_OBJC_CLASS_";
Sym += StringClass;

llvm::Constant *isa = TheModule.getNamedGlobal(Sym);

if (!isa)
  isa = new llvm::GlobalVariable(TheModule, IdTy, /* isConstant */false,
          llvm::GlobalValue::ExternalWeakLinkage, nullptr, Sym);
else if (isa->getType() != PtrToIdTy)
  isa = llvm::ConstantExpr::getBitCast(isa, PtrToIdTy);

ConstantInitBuilder Builder(CGM);
auto Fields = Builder.beginStruct();
Fields.add(isa);
Fields.add(MakeConstantString(Str));
Fields.addInt(IntTy, Str.size());
llvm::Constant *ObjCStr =
  Fields.finishAndCreateGlobal(".objc_str", Align);
ObjCStr = llvm::ConstantExpr::getBitCast(ObjCStr, PtrToInt8Ty);
ObjCStrings[Str] = ObjCStr;
ConstantStrings.push_back(ObjCStr);
return ConstantAddress(ObjCStr, Align);
2486}

2488///Generates a message send where the super is the receiver.  This is a message
2489///send to self with special delivery semantics indicating which class's method
2490///should be called.
2491RValue
2492CGObjCGNU::GenerateMessageSendSuper(CodeGenFunction &CGF,
                                  ReturnValueSlot Return,
                                  QualType ResultType,
                                  Selector Sel,
                                  const ObjCInterfaceDecl *Class,
                                  bool isCategoryImpl,
                                  llvm::Value *Receiver,
                                  bool IsClassMessage,
                                  const CallArgList &CallArgs,
                                  const ObjCMethodDecl *Method) {
CGBuilderTy &Builder = CGF.Builder;
if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) {
  if (Sel == RetainSel || Sel == AutoreleaseSel) {
    return RValue::get(EnforceType(Builder, Receiver,
                CGM.getTypes().ConvertType(ResultType)));
  }
  if (Sel == ReleaseSel) {
    return RValue::get(nullptr);
  }
}

llvm::Value *cmd = GetSelector(CGF, Sel);
CallArgList ActualArgs;

ActualArgs.add(RValue::get(EnforceType(Builder, Receiver, IdTy)), ASTIdTy);
ActualArgs.add(RValue::get(cmd), CGF.getContext().getObjCSelType());
ActualArgs.addFrom(CallArgs);

MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs);

llvm::Value *ReceiverClass = nullptr;
bool isV2ABI = isRuntime(ObjCRuntime::GNUstep, 2);
if (isV2ABI) {
  ReceiverClass = GetClassNamed(CGF,
      Class->getSuperClass()->getNameAsString(), /*isWeak*/false);
  if (IsClassMessage)  {
    // Load the isa pointer of the superclass is this is a class method.
    ReceiverClass = Builder.CreateBitCast(ReceiverClass,
                                          llvm::PointerType::getUnqual(IdTy));
    ReceiverClass =
      Builder.CreateAlignedLoad(ReceiverClass, CGF.getPointerAlign());
  }
  ReceiverClass = EnforceType(Builder, ReceiverClass, IdTy);
} else {
  if (isCategoryImpl) {
    llvm::FunctionCallee classLookupFunction = nullptr;
    if (IsClassMessage)  {
      classLookupFunction = CGM.CreateRuntimeFunction(llvm::FunctionType::get(
            IdTy, PtrTy, true), "objc_get_meta_class");
    } else {
      classLookupFunction = CGM.CreateRuntimeFunction(llvm::FunctionType::get(
            IdTy, PtrTy, true), "objc_get_class");
    }
    ReceiverClass = Builder.CreateCall(classLookupFunction,
        MakeConstantString(Class->getNameAsString()));
  } else {
    // Set up global aliases for the metaclass or class pointer if they do not
    // already exist.  These will are forward-references which will be set to
    // pointers to the class and metaclass structure created for the runtime
    // load function.  To send a message to super, we look up the value of the
    // super_class pointer from either the class or metaclass structure.
    if (IsClassMessage)  {
      if (!MetaClassPtrAlias) {
        MetaClassPtrAlias = llvm::GlobalAlias::create(
            IdTy->getElementType(), 0, llvm::GlobalValue::InternalLinkage,
            ".objc_metaclass_ref" + Class->getNameAsString(), &TheModule);
      }
      ReceiverClass = MetaClassPtrAlias;
    } else {
      if (!ClassPtrAlias) {
        ClassPtrAlias = llvm::GlobalAlias::create(
            IdTy->getElementType(), 0, llvm::GlobalValue::InternalLinkage,
            ".objc_class_ref" + Class->getNameAsString(), &TheModule);
      }
      ReceiverClass = ClassPtrAlias;
    }
  }
  // Cast the pointer to a simplified version of the class structure
  llvm::Type *CastTy = llvm::StructType::get(IdTy, IdTy);
  ReceiverClass = Builder.CreateBitCast(ReceiverClass,
                                        llvm::PointerType::getUnqual(CastTy));
  // Get the superclass pointer
  ReceiverClass = Builder.CreateStructGEP(CastTy, ReceiverClass, 1);
  // Load the superclass pointer
  ReceiverClass =
    Builder.CreateAlignedLoad(ReceiverClass, CGF.getPointerAlign());
}
// Construct the structure used to look up the IMP
llvm::StructType *ObjCSuperTy =
    llvm::StructType::get(Receiver->getType(), IdTy);

Address ObjCSuper = CGF.CreateTempAlloca(ObjCSuperTy,
                            CGF.getPointerAlign());

Builder.CreateStore(Receiver, Builder.CreateStructGEP(ObjCSuper, 0));
Builder.CreateStore(ReceiverClass, Builder.CreateStructGEP(ObjCSuper, 1));

ObjCSuper = EnforceType(Builder, ObjCSuper, PtrToObjCSuperTy);

// Get the IMP
llvm::Value *imp = LookupIMPSuper(CGF, ObjCSuper, cmd, MSI);
imp = EnforceType(Builder, imp, MSI.MessengerType);

llvm::Metadata *impMD[] = {
    llvm::MDString::get(VMContext, Sel.getAsString()),
    llvm::MDString::get(VMContext, Class->getSuperClass()->getNameAsString()),
    llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
        llvm::Type::getInt1Ty(VMContext), IsClassMessage))};
llvm::MDNode *node = llvm::MDNode::get(VMContext, impMD);

CGCallee callee(CGCalleeInfo(), imp);

llvm::CallBase *call;
RValue msgRet = CGF.EmitCall(MSI.CallInfo, callee, Return, ActualArgs, &call);
call->setMetadata(msgSendMDKind, node);
return msgRet;
2608}

2610/// Generate code for a message send expression.
2611RValue
2612CGObjCGNU::GenerateMessageSend(CodeGenFunction &CGF,
                             ReturnValueSlot Return,
                             QualType ResultType,
                             Selector Sel,
                             llvm::Value *Receiver,
                             const CallArgList &CallArgs,
                             const ObjCInterfaceDecl *Class,
                             const ObjCMethodDecl *Method) {
CGBuilderTy &Builder = CGF.Builder;

// Strip out message sends to retain / release in GC mode
if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) {
  if (Sel == RetainSel || Sel == AutoreleaseSel) {
    return RValue::get(EnforceType(Builder, Receiver,
                CGM.getTypes().ConvertType(ResultType)));
  }
  if (Sel == ReleaseSel) {
    return RValue::get(nullptr);
  }
}

// If the return type is something that goes in an integer register, the
// runtime will handle 0 returns.  For other cases, we fill in the 0 value
// ourselves.
//
// The language spec says the result of this kind of message send is
// undefined, but lots of people seem to have forgotten to read that
// paragraph and insist on sending messages to nil that have structure
// returns.  With GCC, this generates a random return value (whatever happens
// to be on the stack / in those registers at the time) on most platforms,
// and generates an illegal instruction trap on SPARC.  With LLVM it corrupts
// the stack.
bool isPointerSizedReturn = (ResultType->isAnyPointerType() ||
    ResultType->isIntegralOrEnumerationType() || ResultType->isVoidType());

llvm::BasicBlock *startBB = nullptr;
llvm::BasicBlock *messageBB = nullptr;
llvm::BasicBlock *continueBB = nullptr;

if (!isPointerSizedReturn) {
  startBB = Builder.GetInsertBlock();
  messageBB = CGF.createBasicBlock("msgSend");
  continueBB = CGF.createBasicBlock("continue");

  llvm::Value *isNil = Builder.CreateICmpEQ(Receiver,
          llvm::Constant::getNullValue(Receiver->getType()));
  Builder.CreateCondBr(isNil, continueBB, messageBB);
  CGF.EmitBlock(messageBB);
}

IdTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(ASTIdTy));
llvm::Value *cmd;
if (Method)
  cmd = GetSelector(CGF, Method);
else
  cmd = GetSelector(CGF, Sel);
cmd = EnforceType(Builder, cmd, SelectorTy);
Receiver = EnforceType(Builder, Receiver, IdTy);

llvm::Metadata *impMD[] = {
    llvm::MDString::get(VMContext, Sel.getAsString()),
    llvm::MDString::get(VMContext, Class ? Class->getNameAsString() : ""),
    llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
        llvm::Type::getInt1Ty(VMContext), Class != nullptr))};
llvm::MDNode *node = llvm::MDNode::get(VMContext, impMD);

CallArgList ActualArgs;
ActualArgs.add(RValue::get(Receiver), ASTIdTy);
ActualArgs.add(RValue::get(cmd), CGF.getContext().getObjCSelType());
ActualArgs.addFrom(CallArgs);

MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs);

// Get the IMP to call
llvm::Value *imp;

// If we have non-legacy dispatch specified, we try using the objc_msgSend()
// functions.  These are not supported on all platforms (or all runtimes on a
// given platform), so we
switch (CGM.getCodeGenOpts().getObjCDispatchMethod()) {
  case CodeGenOptions::Legacy:
    imp = LookupIMP(CGF, Receiver, cmd, node, MSI);
    break;
  case CodeGenOptions::Mixed:
  case CodeGenOptions::NonLegacy:
    if (CGM.ReturnTypeUsesFPRet(ResultType)) {
      imp =
          CGM.CreateRuntimeFunction(llvm::FunctionType::get(IdTy, IdTy, true),
                                    "objc_msgSend_fpret")
              .getCallee();
    } else if (CGM.ReturnTypeUsesSRet(MSI.CallInfo)) {
      // The actual types here don't matter - we're going to bitcast the
      // function anyway
      imp =
          CGM.CreateRuntimeFunction(llvm::FunctionType::get(IdTy, IdTy, true),
                                    "objc_msgSend_stret")
              .getCallee();
    } else {
      imp = CGM.CreateRuntimeFunction(
                   llvm::FunctionType::get(IdTy, IdTy, true), "objc_msgSend")
                .getCallee();
    }
}

// Reset the receiver in case the lookup modified it
ActualArgs[0] = CallArg(RValue::get(Receiver), ASTIdTy);

imp = EnforceType(Builder, imp, MSI.MessengerType);

llvm::CallBase *call;
CGCallee callee(CGCalleeInfo(), imp);
RValue msgRet = CGF.EmitCall(MSI.CallInfo, callee, Return, ActualArgs, &call);
call->setMetadata(msgSendMDKind, node);


if (!isPointerSizedReturn) {
  messageBB = CGF.Builder.GetInsertBlock();
  CGF.Builder.CreateBr(continueBB);
  CGF.EmitBlock(continueBB);
  if (msgRet.isScalar()) {
    llvm::Value *v = msgRet.getScalarVal();
    llvm::PHINode *phi = Builder.CreatePHI(v->getType(), 2);
    phi->addIncoming(v, messageBB);
    phi->addIncoming(llvm::Constant::getNullValue(v->getType()), startBB);
    msgRet = RValue::get(phi);
  } else if (msgRet.isAggregate()) {
    Address v = msgRet.getAggregateAddress();
    llvm::PHINode *phi = Builder.CreatePHI(v.getType(), 2);
    llvm::Type *RetTy = v.getElementType();
    Address NullVal = CGF.CreateTempAlloca(RetTy, v.getAlignment(), "null");
    CGF.InitTempAlloca(NullVal, llvm::Constant::getNullValue(RetTy));
    phi->addIncoming(v.getPointer(), messageBB);
    phi->addIncoming(NullVal.getPointer(), startBB);
    msgRet = RValue::getAggregate(Address(phi, v.getAlignment()));
  } else /* isComplex() */ {
    std::pair<llvm::Value*,llvm::Value*> v = msgRet.getComplexVal();
    llvm::PHINode *phi = Builder.CreatePHI(v.first->getType(), 2);
    phi->addIncoming(v.first, messageBB);
    phi->addIncoming(llvm::Constant::getNullValue(v.first->getType()),
        startBB);
    llvm::PHINode *phi2 = Builder.CreatePHI(v.second->getType(), 2);
    phi2->addIncoming(v.second, messageBB);
    phi2->addIncoming(llvm::Constant::getNullValue(v.second->getType()),
        startBB);
    msgRet = RValue::getComplex(phi, phi2);
  }
}
return msgRet;
2760}

2762/// Generates a MethodList.  Used in construction of a objc_class and
2763/// objc_category structures.
2764llvm::Constant *CGObjCGNU::
2765GenerateMethodList(StringRef ClassName,
                 StringRef CategoryName,
                 ArrayRef<const ObjCMethodDecl*> Methods,
                 bool isClassMethodList) {
if (Methods.empty())
  return NULLPtr;

ConstantInitBuilder Builder(CGM);

auto MethodList = Builder.beginStruct();
MethodList.addNullPointer(CGM.Int8PtrTy);
MethodList.addInt(Int32Ty, Methods.size());

// Get the method structure type.
llvm::StructType *ObjCMethodTy =
  llvm::StructType::get(CGM.getLLVMContext(), {
    PtrToInt8Ty, // Really a selector, but the runtime creates it us.
    PtrToInt8Ty, // Method types
    IMPTy        // Method pointer
  });
bool isV2ABI = isRuntime(ObjCRuntime::GNUstep, 2);
if (isV2ABI) {
  // size_t size;
  llvm::DataLayout td(&TheModule);
  MethodList.addInt(SizeTy, td.getTypeSizeInBits(ObjCMethodTy) /
      CGM.getContext().getCharWidth());
  ObjCMethodTy =
    llvm::StructType::get(CGM.getLLVMContext(), {
      IMPTy,       // Method pointer
      PtrToInt8Ty, // Selector
      PtrToInt8Ty  // Extended type encoding
    });
} else {
  ObjCMethodTy =
    llvm::StructType::get(CGM.getLLVMContext(), {
      PtrToInt8Ty, // Really a selector, but the runtime creates it us.
      PtrToInt8Ty, // Method types
      IMPTy        // Method pointer
    });
}
auto MethodArray = MethodList.beginArray();
ASTContext &Context = CGM.getContext();
for (const auto *OMD : Methods) {
  llvm::Constant *FnPtr =
    TheModule.getFunction(SymbolNameForMethod(ClassName, CategoryName,
                                              OMD->getSelector(),
                                              isClassMethodList));
  assert(FnPtr && "Can't generate metadata for method that doesn't exist")((FnPtr && "Can't generate metadata for method that doesn't exist"
) ? static_cast<void> (0) : __assert_fail ("FnPtr && \"Can't generate metadata for method that doesn't exist\""
, "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 2812, __PRETTY_FUNCTION__));
  auto Method = MethodArray.beginStruct(ObjCMethodTy);
  if (isV2ABI) {
    Method.addBitCast(FnPtr, IMPTy);
    Method.add(GetConstantSelector(OMD->getSelector(),
        Context.getObjCEncodingForMethodDecl(OMD)));
    Method.add(MakeConstantString(Context.getObjCEncodingForMethodDecl(OMD, true)));
  } else {
    Method.add(MakeConstantString(OMD->getSelector().getAsString()));
    Method.add(MakeConstantString(Context.getObjCEncodingForMethodDecl(OMD)));
    Method.addBitCast(FnPtr, IMPTy);
  }
  Method.finishAndAddTo(MethodArray);
}
MethodArray.finishAndAddTo(MethodList);

// Create an instance of the structure
return MethodList.finishAndCreateGlobal(".objc_method_list",
                                        CGM.getPointerAlign());
2831}

2833/// Generates an IvarList.  Used in construction of a objc_class.
2834llvm::Constant *CGObjCGNU::
2835GenerateIvarList(ArrayRef<llvm::Constant *> IvarNames,
               ArrayRef<llvm::Constant *> IvarTypes,
               ArrayRef<llvm::Constant *> IvarOffsets,
               ArrayRef<llvm::Constant *> IvarAlign,
               ArrayRef<Qualifiers::ObjCLifetime> IvarOwnership) {
if (IvarNames.empty())
  return NULLPtr;

ConstantInitBuilder Builder(CGM);

// Structure containing array count followed by array.
auto IvarList = Builder.beginStruct();
IvarList.addInt(IntTy, (int)IvarNames.size());

// Get the ivar structure type.
llvm::StructType *ObjCIvarTy =
    llvm::StructType::get(PtrToInt8Ty, PtrToInt8Ty, IntTy);

// Array of ivar structures.
auto Ivars = IvarList.beginArray(ObjCIvarTy);
for (unsigned int i = 0, e = IvarNames.size() ; i < e ; i++) {
  auto Ivar = Ivars.beginStruct(ObjCIvarTy);
  Ivar.add(IvarNames[i]);
  Ivar.add(IvarTypes[i]);
  Ivar.add(IvarOffsets[i]);
  Ivar.finishAndAddTo(Ivars);
}
Ivars.finishAndAddTo(IvarList);

// Create an instance of the structure
return IvarList.finishAndCreateGlobal(".objc_ivar_list",
                                      CGM.getPointerAlign());
2867}

2869/// Generate a class structure
2870llvm::Constant *CGObjCGNU::GenerateClassStructure(
  llvm::Constant *MetaClass,
  llvm::Constant *SuperClass,
  unsigned info,
  const char *Name,
  llvm::Constant *Version,
  llvm::Constant *InstanceSize,
  llvm::Constant *IVars,
  llvm::Constant *Methods,
  llvm::Constant *Protocols,
  llvm::Constant *IvarOffsets,
  llvm::Constant *Properties,
  llvm::Constant *StrongIvarBitmap,
  llvm::Constant *WeakIvarBitmap,
  bool isMeta) {
// Set up the class structure
// Note:  Several of these are char*s when they should be ids.  This is
// because the runtime performs this translation on load.
//
// Fields marked New ABI are part of the GNUstep runtime.  We emit them
// anyway; the classes will still work with the GNU runtime, they will just
// be ignored.
llvm::StructType *ClassTy = llvm::StructType::get(
    PtrToInt8Ty,        // isa
    PtrToInt8Ty,        // super_class
    PtrToInt8Ty,        // name
    LongTy,             // version
    LongTy,             // info
    LongTy,             // instance_size
    IVars->getType(),   // ivars
    Methods->getType(), // methods
    // These are all filled in by the runtime, so we pretend
    PtrTy, // dtable
    PtrTy, // subclass_list
    PtrTy, // sibling_class
    PtrTy, // protocols
    PtrTy, // gc_object_type
    // New ABI:
    LongTy,                 // abi_version
    IvarOffsets->getType(), // ivar_offsets
    Properties->getType(),  // properties
    IntPtrTy,               // strong_pointers
    IntPtrTy                // weak_pointers
    );

ConstantInitBuilder Builder(CGM);
auto Elements = Builder.beginStruct(ClassTy);

// Fill in the structure

// isa
Elements.addBitCast(MetaClass, PtrToInt8Ty);
// super_class
Elements.add(SuperClass);
// name
Elements.add(MakeConstantString(Name, ".class_name"));
// version
Elements.addInt(LongTy, 0);
// info
Elements.addInt(LongTy, info);
// instance_size
if (isMeta) {
  llvm::DataLayout td(&TheModule);
  Elements.addInt(LongTy,
                  td.getTypeSizeInBits(ClassTy) /
                    CGM.getContext().getCharWidth());
} else
  Elements.add(InstanceSize);
// ivars
Elements.add(IVars);
// methods
Elements.add(Methods);
// These are all filled in by the runtime, so we pretend
// dtable
Elements.add(NULLPtr);
// subclass_list
Elements.add(NULLPtr);
// sibling_class
Elements.add(NULLPtr);
// protocols
Elements.addBitCast(Protocols, PtrTy);
// gc_object_type
Elements.add(NULLPtr);
// abi_version
Elements.addInt(LongTy, ClassABIVersion);
// ivar_offsets
Elements.add(IvarOffsets);
// properties
Elements.add(Properties);
// strong_pointers
Elements.add(StrongIvarBitmap);
// weak_pointers
Elements.add(WeakIvarBitmap);
// Create an instance of the structure
// This is now an externally visible symbol, so that we can speed up class
// messages in the next ABI.  We may already have some weak references to
// this, so check and fix them properly.
std::string ClassSym((isMeta ? "_OBJC_METACLASS_": "_OBJC_CLASS_") +
        std::string(Name));
llvm::GlobalVariable *ClassRef = TheModule.getNamedGlobal(ClassSym);
llvm::Constant *Class =
  Elements.finishAndCreateGlobal(ClassSym, CGM.getPointerAlign(), false,
                                 llvm::GlobalValue::ExternalLinkage);
if (ClassRef) {
  ClassRef->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(Class,
                ClassRef->getType()));
  ClassRef->removeFromParent();
  Class->setName(ClassSym);
}
return Class;
2980}

2982llvm::Constant *CGObjCGNU::
2983GenerateProtocolMethodList(ArrayRef<const ObjCMethodDecl*> Methods) {
// Get the method structure type.
llvm::StructType *ObjCMethodDescTy =
  llvm::StructType::get(CGM.getLLVMContext(), { PtrToInt8Ty, PtrToInt8Ty });
ASTContext &Context = CGM.getContext();
ConstantInitBuilder Builder(CGM);
auto MethodList = Builder.beginStruct();
MethodList.addInt(IntTy, Methods.size());
auto MethodArray = MethodList.beginArray(ObjCMethodDescTy);
for (auto *M : Methods) {
  auto Method = MethodArray.beginStruct(ObjCMethodDescTy);
  Method.add(MakeConstantString(M->getSelector().getAsString()));
  Method.add(MakeConstantString(Context.getObjCEncodingForMethodDecl(M)));
  Method.finishAndAddTo(MethodArray);
}
MethodArray.finishAndAddTo(MethodList);
return MethodList.finishAndCreateGlobal(".objc_method_list",
                                        CGM.getPointerAlign());
3001}

3003// Create the protocol list structure used in classes, categories and so on
3004llvm::Constant *
3005CGObjCGNU::GenerateProtocolList(ArrayRef<std::string> Protocols) {

ConstantInitBuilder Builder(CGM);
auto ProtocolList = Builder.beginStruct();
ProtocolList.add(NULLPtr);
ProtocolList.addInt(LongTy, Protocols.size());

auto Elements = ProtocolList.beginArray(PtrToInt8Ty);
for (const std::string *iter = Protocols.begin(), *endIter = Protocols.end();
    iter != endIter ; iter++) {
  llvm::Constant *protocol = nullptr;
  llvm::StringMap<llvm::Constant*>::iterator value =
    ExistingProtocols.find(*iter);
  if (value == ExistingProtocols.end()) {
    protocol = GenerateEmptyProtocol(*iter);
  } else {
    protocol = value->getValue();
  }
  Elements.addBitCast(protocol, PtrToInt8Ty);
}
Elements.finishAndAddTo(ProtocolList);
return ProtocolList.finishAndCreateGlobal(".objc_protocol_list",
                                          CGM.getPointerAlign());
3028}

3030llvm::Value *CGObjCGNU::GenerateProtocolRef(CodeGenFunction &CGF,
                                          const ObjCProtocolDecl *PD) {
llvm::Constant *&protocol = ExistingProtocols[PD->getNameAsString()];
if (!protocol)
  GenerateProtocol(PD);
llvm::Type *T =
  CGM.getTypes().ConvertType(CGM.getContext().getObjCProtoType());
return CGF.Builder.CreateBitCast(protocol, llvm::PointerType::getUnqual(T));
3038}

3040llvm::Constant *
3041CGObjCGNU::GenerateEmptyProtocol(StringRef ProtocolName) {
llvm::Constant *ProtocolList = GenerateProtocolList({});
llvm::Constant *MethodList = GenerateProtocolMethodList({});
MethodList = llvm::ConstantExpr::getBitCast(MethodList, PtrToInt8Ty);
// Protocols are objects containing lists of the methods implemented and
// protocols adopted.
ConstantInitBuilder Builder(CGM);
auto Elements = Builder.beginStruct();

// The isa pointer must be set to a magic number so the runtime knows it's
// the correct layout.
Elements.add(llvm::ConstantExpr::getIntToPtr(
        llvm::ConstantInt::get(Int32Ty, ProtocolVersion), IdTy));

Elements.add(MakeConstantString(ProtocolName, ".objc_protocol_name"));
Elements.add(ProtocolList); /* .protocol_list */
Elements.add(MethodList);   /* .instance_methods */
Elements.add(MethodList);   /* .class_methods */
Elements.add(MethodList);   /* .optional_instance_methods */
Elements.add(MethodList);   /* .optional_class_methods */
Elements.add(NULLPtr);      /* .properties */
Elements.add(NULLPtr);      /* .optional_properties */
return Elements.finishAndCreateGlobal(SymbolForProtocol(ProtocolName),
                                      CGM.getPointerAlign());
3065}

3067void CGObjCGNU::GenerateProtocol(const ObjCProtocolDecl *PD) {
std::string ProtocolName = PD->getNameAsString();

// Use the protocol definition, if there is one.
if (const ObjCProtocolDecl *Def = PD->getDefinition())
  PD = Def;

SmallVector<std::string, 16> Protocols;
for (const auto *PI : PD->protocols())
  Protocols.push_back(PI->getNameAsString());
SmallVector<const ObjCMethodDecl*, 16> InstanceMethods;
SmallVector<const ObjCMethodDecl*, 16> OptionalInstanceMethods;
for (const auto *I : PD->instance_methods())
  if (I->isOptional())
    OptionalInstanceMethods.push_back(I);
  else
    InstanceMethods.push_back(I);
// Collect information about class methods:
SmallVector<const ObjCMethodDecl*, 16> ClassMethods;
SmallVector<const ObjCMethodDecl*, 16> OptionalClassMethods;
for (const auto *I : PD->class_methods())
  if (I->isOptional())
    OptionalClassMethods.push_back(I);
  else
    ClassMethods.push_back(I);

llvm::Constant *ProtocolList = GenerateProtocolList(Protocols);
llvm::Constant *InstanceMethodList =
  GenerateProtocolMethodList(InstanceMethods);
llvm::Constant *ClassMethodList =
  GenerateProtocolMethodList(ClassMethods);
llvm::Constant *OptionalInstanceMethodList =
  GenerateProtocolMethodList(OptionalInstanceMethods);
llvm::Constant *OptionalClassMethodList =
  GenerateProtocolMethodList(OptionalClassMethods);

// Property metadata: name, attributes, isSynthesized, setter name, setter
// types, getter name, getter types.
// The isSynthesized value is always set to 0 in a protocol.  It exists to
// simplify the runtime library by allowing it to use the same data
// structures for protocol metadata everywhere.

llvm::Constant *PropertyList =
  GeneratePropertyList(nullptr, PD, false, false);
llvm::Constant *OptionalPropertyList =
  GeneratePropertyList(nullptr, PD, false, true);

// Protocols are objects containing lists of the methods implemented and
// protocols adopted.
// The isa pointer must be set to a magic number so the runtime knows it's
// the correct layout.
ConstantInitBuilder Builder(CGM);
auto Elements = Builder.beginStruct();
Elements.add(
    llvm::ConstantExpr::getIntToPtr(
        llvm::ConstantInt::get(Int32Ty, ProtocolVersion), IdTy));
Elements.add(MakeConstantString(ProtocolName));
Elements.add(ProtocolList);
Elements.add(InstanceMethodList);
Elements.add(ClassMethodList);
Elements.add(OptionalInstanceMethodList);
Elements.add(OptionalClassMethodList);
Elements.add(PropertyList);
Elements.add(OptionalPropertyList);
ExistingProtocols[ProtocolName] =
  llvm::ConstantExpr::getBitCast(
    Elements.finishAndCreateGlobal(".objc_protocol", CGM.getPointerAlign()),
    IdTy);
3135}
3136void CGObjCGNU::GenerateProtocolHolderCategory() {
// Collect information about instance methods

ConstantInitBuilder Builder(CGM);
auto Elements = Builder.beginStruct();

const std::string ClassName = "__ObjC_Protocol_Holder_Ugly_Hack";
const std::string CategoryName = "AnotherHack";
Elements.add(MakeConstantString(CategoryName));
Elements.add(MakeConstantString(ClassName));
// Instance method list
Elements.addBitCast(GenerateMethodList(
        ClassName, CategoryName, {}, false), PtrTy);
// Class method list
Elements.addBitCast(GenerateMethodList(
        ClassName, CategoryName, {}, true), PtrTy);

// Protocol list
ConstantInitBuilder ProtocolListBuilder(CGM);
auto ProtocolList = ProtocolListBuilder.beginStruct();
ProtocolList.add(NULLPtr);
ProtocolList.addInt(LongTy, ExistingProtocols.size());
auto ProtocolElements = ProtocolList.beginArray(PtrTy);
for (auto iter = ExistingProtocols.begin(), endIter = ExistingProtocols.end();
     iter != endIter ; iter++) {
  ProtocolElements.addBitCast(iter->getValue(), PtrTy);
}
ProtocolElements.finishAndAddTo(ProtocolList);
Elements.addBitCast(
                 ProtocolList.finishAndCreateGlobal(".objc_protocol_list",
                                                    CGM.getPointerAlign()),
                 PtrTy);
Categories.push_back(llvm::ConstantExpr::getBitCast(
      Elements.finishAndCreateGlobal("", CGM.getPointerAlign()),
      PtrTy));
3171}

3173/// Libobjc2 uses a bitfield representation where small(ish) bitfields are
3174/// stored in a 64-bit value with the low bit set to 1 and the remaining 63
3175/// bits set to their values, LSB first, while larger ones are stored in a
3176/// structure of this / form:
3177///
3178/// struct { int32_t length; int32_t values[length]; };
3179///
3180/// The values in the array are stored in host-endian format, with the least
3181/// significant bit being assumed to come first in the bitfield.  Therefore, a
3182/// bitfield with the 64th bit set will be (int64_t)&{ 2, [0, 1<<31] }, while a
3183/// bitfield / with the 63rd bit set will be 1<<64.
3184llvm::Constant *CGObjCGNU::MakeBitField(ArrayRef<bool> bits) {
int bitCount = bits.size();
int ptrBits = CGM.getDataLayout().getPointerSizeInBits();
if (bitCount < ptrBits) {
  uint64_t val = 1;
  for (int i=0 ; i<bitCount ; ++i) {
    if (bits[i]) val |= 1ULL<<(i+1);
  }
  return llvm::ConstantInt::get(IntPtrTy, val);
}
SmallVector<llvm::Constant *, 8> values;
int v=0;
while (v < bitCount) {
  int32_t word = 0;
  for (int i=0 ; (i<32) && (v<bitCount)  ; ++i) {
    if (bits[v]) word |= 1<<i;
    v++;
  }
  values.push_back(llvm::ConstantInt::get(Int32Ty, word));
}

ConstantInitBuilder builder(CGM);
auto fields = builder.beginStruct();
fields.addInt(Int32Ty, values.size());
auto array = fields.beginArray();
for (auto v : values) array.add(v);
array.finishAndAddTo(fields);

llvm::Constant *GS =
  fields.finishAndCreateGlobal("", CharUnits::fromQuantity(4));
llvm::Constant *ptr = llvm::ConstantExpr::getPtrToInt(GS, IntPtrTy);
return ptr;
3216}

3218llvm::Constant *CGObjCGNU::GenerateCategoryProtocolList(const
  ObjCCategoryDecl *OCD) {
SmallVector<std::string, 16> Protocols;
for (const auto *PD : OCD->getReferencedProtocols())
  Protocols.push_back(PD->getNameAsString());
return GenerateProtocolList(Protocols);
3224}

3226void CGObjCGNU::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
const ObjCInterfaceDecl *Class = OCD->getClassInterface();
std::string ClassName = Class->getNameAsString();
std::string CategoryName = OCD->getNameAsString();

// Collect the names of referenced protocols
const ObjCCategoryDecl *CatDecl = OCD->getCategoryDecl();

ConstantInitBuilder Builder(CGM);
auto Elements = Builder.beginStruct();
Elements.add(MakeConstantString(CategoryName));
Elements.add(MakeConstantString(ClassName));
// Instance method list
SmallVector<ObjCMethodDecl*, 16> InstanceMethods;
InstanceMethods.insert(InstanceMethods.begin(), OCD->instmeth_begin(),
    OCD->instmeth_end());
Elements.addBitCast(
        GenerateMethodList(ClassName, CategoryName, InstanceMethods, false),
        PtrTy);
// Class method list

SmallVector<ObjCMethodDecl*, 16> ClassMethods;
ClassMethods.insert(ClassMethods.begin(), OCD->classmeth_begin(),
    OCD->classmeth_end());
Elements.addBitCast(
        GenerateMethodList(ClassName, CategoryName, ClassMethods, true),
        PtrTy);
// Protocol list
Elements.addBitCast(GenerateCategoryProtocolList(CatDecl), PtrTy);
if (isRuntime(ObjCRuntime::GNUstep, 2)) {
  const ObjCCategoryDecl *Category =
    Class->FindCategoryDeclaration(OCD->getIdentifier());
  if (Category) {
    // Instance properties
    Elements.addBitCast(GeneratePropertyList(OCD, Category, false), PtrTy);
    // Class properties
    Elements.addBitCast(GeneratePropertyList(OCD, Category, true), PtrTy);
  } else {
    Elements.addNullPointer(PtrTy);
    Elements.addNullPointer(PtrTy);
  }
}

Categories.push_back(llvm::ConstantExpr::getBitCast(
      Elements.finishAndCreateGlobal(
        std::string(".objc_category_")+ClassName+CategoryName,
        CGM.getPointerAlign()),
      PtrTy));
3274}

3276llvm::Constant *CGObjCGNU::GeneratePropertyList(const Decl *Container,
  const ObjCContainerDecl *OCD,
  bool isClassProperty,
  bool protocolOptionalProperties) {

SmallVector<const ObjCPropertyDecl *, 16> Properties;
llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet;
bool isProtocol = isa<ObjCProtocolDecl>(OCD);
ASTContext &Context = CGM.getContext();

std::function<void(const ObjCProtocolDecl *Proto)> collectProtocolProperties
  = [&](const ObjCProtocolDecl *Proto) {
    for (const auto *P : Proto->protocols())
      collectProtocolProperties(P);
    for (const auto *PD : Proto->properties()) {
      if (isClassProperty != PD->isClassProperty())
        continue;
      // Skip any properties that are declared in protocols that this class
      // conforms to but are not actually implemented by this class.
      if (!isProtocol && !Context.getObjCPropertyImplDeclForPropertyDecl(PD, Container))
        continue;
      if (!PropertySet.insert(PD->getIdentifier()).second)
        continue;
      Properties.push_back(PD);
    }
  };

if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
  for (const ObjCCategoryDecl *ClassExt : OID->known_extensions())
    for (auto *PD : ClassExt->properties()) {
      if (isClassProperty != PD->isClassProperty())
        continue;
      PropertySet.insert(PD->getIdentifier());
      Properties.push_back(PD);
    }

for (const auto *PD : OCD->properties()) {
  if (isClassProperty != PD->isClassProperty())
    continue;
  // If we're generating a list for a protocol, skip optional / required ones
  // when generating the other list.
  if (isProtocol && (protocolOptionalProperties != PD->isOptional()))
    continue;
  // Don't emit duplicate metadata for properties that were already in a
  // class extension.
  if (!PropertySet.insert(PD->getIdentifier()).second)
    continue;

  Properties.push_back(PD);
}

if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
  for (const auto *P : OID->all_referenced_protocols())
    collectProtocolProperties(P);
else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD))
  for (const auto *P : CD->protocols())
    collectProtocolProperties(P);

auto numProperties = Properties.size();

if (numProperties == 0)
  return NULLPtr;

ConstantInitBuilder builder(CGM);
auto propertyList = builder.beginStruct();
auto properties = PushPropertyListHeader(propertyList, numProperties);

// Add all of the property methods need adding to the method list and to the
// property metadata list.
for (auto *property : Properties) {
  bool isSynthesized = false;
  bool isDynamic = false;
  if (!isProtocol) {
    auto *propertyImpl = Context.getObjCPropertyImplDeclForPropertyDecl(property, Container);
    if (propertyImpl) {
      isSynthesized = (propertyImpl->getPropertyImplementation() ==
          ObjCPropertyImplDecl::Synthesize);
      isDynamic = (propertyImpl->getPropertyImplementation() ==
          ObjCPropertyImplDecl::Dynamic);
    }
  }
  PushProperty(properties, property, Container, isSynthesized, isDynamic);
}
properties.finishAndAddTo(propertyList);

return propertyList.finishAndCreateGlobal(".objc_property_list",
                                          CGM.getPointerAlign());
3363}

3365void CGObjCGNU::RegisterAlias(const ObjCCompatibleAliasDecl *OAD) {
// Get the class declaration for which the alias is specified.
ObjCInterfaceDecl *ClassDecl =
  const_cast<ObjCInterfaceDecl *>(OAD->getClassInterface());
ClassAliases.emplace_back(ClassDecl->getNameAsString(),
                          OAD->getNameAsString());
3371}

3373void CGObjCGNU::GenerateClass(const ObjCImplementationDecl *OID) {
ASTContext &Context = CGM.getContext();

// Get the superclass name.
const ObjCInterfaceDecl * SuperClassDecl =
  OID->getClassInterface()->getSuperClass();
std::string SuperClassName;
if (SuperClassDecl) {
  SuperClassName = SuperClassDecl->getNameAsString();
  EmitClassRef(SuperClassName);
}

// Get the class name
ObjCInterfaceDecl *ClassDecl =
    const_cast<ObjCInterfaceDecl *>(OID->getClassInterface());
std::string ClassName = ClassDecl->getNameAsString();

// Emit the symbol that is used to generate linker errors if this class is
// referenced in other modules but not declared.
std::string classSymbolName = "__objc_class_name_" + ClassName;
if (auto *symbol = TheModule.getGlobalVariable(classSymbolName)) {
  symbol->setInitializer(llvm::ConstantInt::get(LongTy, 0));
} else {
  new llvm::GlobalVariable(TheModule, LongTy, false,
                           llvm::GlobalValue::ExternalLinkage,
                           llvm::ConstantInt::get(LongTy, 0),
                           classSymbolName);
}

// Get the size of instances.
int instanceSize =
  Context.getASTObjCImplementationLayout(OID).getSize().getQuantity();

// Collect information about instance variables.
SmallVector<llvm::Constant*, 16> IvarNames;
SmallVector<llvm::Constant*, 16> IvarTypes;
SmallVector<llvm::Constant*, 16> IvarOffsets;
SmallVector<llvm::Constant*, 16> IvarAligns;
SmallVector<Qualifiers::ObjCLifetime, 16> IvarOwnership;

ConstantInitBuilder IvarOffsetBuilder(CGM);
auto IvarOffsetValues = IvarOffsetBuilder.beginArray(PtrToIntTy);
SmallVector<bool, 16> WeakIvars;
SmallVector<bool, 16> StrongIvars;

int superInstanceSize = !SuperClassDecl ? 0 :
  Context.getASTObjCInterfaceLayout(SuperClassDecl).getSize().getQuantity();
// For non-fragile ivars, set the instance size to 0 - {the size of just this
// class}.  The runtime will then set this to the correct value on load.
if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
  instanceSize = 0 - (instanceSize - superInstanceSize);
}

for (const ObjCIvarDecl *IVD = ClassDecl->all_declared_ivar_begin(); IVD;
     IVD = IVD->getNextIvar()) {
    // Store the name
    IvarNames.push_back(MakeConstantString(IVD->getNameAsString()));
    // Get the type encoding for this ivar
    std::string TypeStr;
    Context.getObjCEncodingForType(IVD->getType(), TypeStr, IVD);
    IvarTypes.push_back(MakeConstantString(TypeStr));
    IvarAligns.push_back(llvm::ConstantInt::get(IntTy,
          Context.getTypeSize(IVD->getType())));
    // Get the offset
    uint64_t BaseOffset = ComputeIvarBaseOffset(CGM, OID, IVD);
    uint64_t Offset = BaseOffset;
    if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
      Offset = BaseOffset - superInstanceSize;
    }
    llvm::Constant *OffsetValue = llvm::ConstantInt::get(IntTy, Offset);
    // Create the direct offset value
    std::string OffsetName = "__objc_ivar_offset_value_" + ClassName +"." +
        IVD->getNameAsString();

    llvm::GlobalVariable *OffsetVar = TheModule.getGlobalVariable(OffsetName);
    if (OffsetVar) {
      OffsetVar->setInitializer(OffsetValue);
      // If this is the real definition, change its linkage type so that
      // different modules will use this one, rather than their private
      // copy.
      OffsetVar->setLinkage(llvm::GlobalValue::ExternalLinkage);
    } else
      OffsetVar = new llvm::GlobalVariable(TheModule, Int32Ty,
        false, llvm::GlobalValue::ExternalLinkage,
        OffsetValue, OffsetName);
    IvarOffsets.push_back(OffsetValue);
    IvarOffsetValues.add(OffsetVar);
    Qualifiers::ObjCLifetime lt = IVD->getType().getQualifiers().getObjCLifetime();
    IvarOwnership.push_back(lt);
    switch (lt) {
      case Qualifiers::OCL_Strong:
        StrongIvars.push_back(true);
        WeakIvars.push_back(false);
        break;
      case Qualifiers::OCL_Weak:
        StrongIvars.push_back(false);
        WeakIvars.push_back(true);
        break;
      default:
        StrongIvars.push_back(false);
        WeakIvars.push_back(false);
    }
}
llvm::Constant *StrongIvarBitmap = MakeBitField(StrongIvars);
llvm::Constant *WeakIvarBitmap = MakeBitField(WeakIvars);
llvm::GlobalVariable *IvarOffsetArray =
  IvarOffsetValues.finishAndCreateGlobal(".ivar.offsets",
                                         CGM.getPointerAlign());

// Collect information about instance methods
SmallVector<const ObjCMethodDecl*, 16> InstanceMethods;
InstanceMethods.insert(InstanceMethods.begin(), OID->instmeth_begin(),
    OID->instmeth_end());

SmallVector<const ObjCMethodDecl*, 16> ClassMethods;
ClassMethods.insert(ClassMethods.begin(), OID->classmeth_begin(),
    OID->classmeth_end());

// Collect the same information about synthesized properties, which don't
// show up in the instance method lists.
for (auto *propertyImpl : OID->property_impls())
  if (propertyImpl->getPropertyImplementation() ==
      ObjCPropertyImplDecl::Synthesize) {
    ObjCPropertyDecl *property = propertyImpl->getPropertyDecl();
    auto addPropertyMethod = [&](const ObjCMethodDecl *accessor) {
      if (accessor)
        InstanceMethods.push_back(accessor);
    };
    addPropertyMethod(property->getGetterMethodDecl());
    addPropertyMethod(property->getSetterMethodDecl());
  }

llvm::Constant *Properties = GeneratePropertyList(OID, ClassDecl);

// Collect the names of referenced protocols
SmallVector<std::string, 16> Protocols;
for (const auto *I : ClassDecl->protocols())
  Protocols.push_back(I->getNameAsString());

// Get the superclass pointer.
llvm::Constant *SuperClass;
if (!SuperClassName.empty()) {
  SuperClass = MakeConstantString(SuperClassName, ".super_class_name");
} else {
  SuperClass = llvm::ConstantPointerNull::get(PtrToInt8Ty);
}
// Empty vector used to construct empty method lists
SmallVector<llvm::Constant*, 1>  empty;
// Generate the method and instance variable lists
llvm::Constant *MethodList = GenerateMethodList(ClassName, "",
    InstanceMethods, false);
llvm::Constant *ClassMethodList = GenerateMethodList(ClassName, "",
    ClassMethods, true);
llvm::Constant *IvarList = GenerateIvarList(IvarNames, IvarTypes,
    IvarOffsets, IvarAligns, IvarOwnership);
// Irrespective of whether we are compiling for a fragile or non-fragile ABI,
// we emit a symbol containing the offset for each ivar in the class.  This
// allows code compiled for the non-Fragile ABI to inherit from code compiled
// for the legacy ABI, without causing problems.  The converse is also
// possible, but causes all ivar accesses to be fragile.

// Offset pointer for getting at the correct field in the ivar list when
// setting up the alias.  These are: The base address for the global, the
// ivar array (second field), the ivar in this list (set for each ivar), and
// the offset (third field in ivar structure)
llvm::Type *IndexTy = Int32Ty;
llvm::Constant *offsetPointerIndexes[] = {Zeros[0],
    llvm::ConstantInt::get(IndexTy, ClassABIVersion > 1 ? 2 : 1), nullptr,
    llvm::ConstantInt::get(IndexTy, ClassABIVersion > 1 ? 3 : 2) };

unsigned ivarIndex = 0;
for (const ObjCIvarDecl *IVD = ClassDecl->all_declared_ivar_begin(); IVD;
     IVD = IVD->getNextIvar()) {
    const std::string Name = GetIVarOffsetVariableName(ClassDecl, IVD);
    offsetPointerIndexes[2] = llvm::ConstantInt::get(IndexTy, ivarIndex);
    // Get the correct ivar field
    llvm::Constant *offsetValue = llvm::ConstantExpr::getGetElementPtr(
        cast<llvm::GlobalVariable>(IvarList)->getValueType(), IvarList,
        offsetPointerIndexes);
    // Get the existing variable, if one exists.
    llvm::GlobalVariable *offset = TheModule.getNamedGlobal(Name);
    if (offset) {
      offset->setInitializer(offsetValue);
      // If this is the real definition, change its linkage type so that
      // different modules will use this one, rather than their private
      // copy.
      offset->setLinkage(llvm::GlobalValue::ExternalLinkage);
    } else
      // Add a new alias if there isn't one already.
      new llvm::GlobalVariable(TheModule, offsetValue->getType(),
              false, llvm::GlobalValue::ExternalLinkage, offsetValue, Name);
    ++ivarIndex;
}
llvm::Constant *ZeroPtr = llvm::ConstantInt::get(IntPtrTy, 0);

//Generate metaclass for class methods
llvm::Constant *MetaClassStruct = GenerateClassStructure(
    NULLPtr, NULLPtr, 0x12L, ClassName.c_str(), nullptr, Zeros[0],
    NULLPtr, ClassMethodList, NULLPtr, NULLPtr,
    GeneratePropertyList(OID, ClassDecl, true), ZeroPtr, ZeroPtr, true);
CGM.setGVProperties(cast<llvm::GlobalValue>(MetaClassStruct),
                    OID->getClassInterface());

// Generate the class structure
llvm::Constant *ClassStruct = GenerateClassStructure(
    MetaClassStruct, SuperClass, 0x11L, ClassName.c_str(), nullptr,
    llvm::ConstantInt::get(LongTy, instanceSize), IvarList, MethodList,
    GenerateProtocolList(Protocols), IvarOffsetArray, Properties,
    StrongIvarBitmap, WeakIvarBitmap);
CGM.setGVProperties(cast<llvm::GlobalValue>(ClassStruct),
                    OID->getClassInterface());

// Resolve the class aliases, if they exist.
if (ClassPtrAlias) {
  ClassPtrAlias->replaceAllUsesWith(
      llvm::ConstantExpr::getBitCast(ClassStruct, IdTy));
  ClassPtrAlias->eraseFromParent();
  ClassPtrAlias = nullptr;
}
if (MetaClassPtrAlias) {
  MetaClassPtrAlias->replaceAllUsesWith(
      llvm::ConstantExpr::getBitCast(MetaClassStruct, IdTy));
  MetaClassPtrAlias->eraseFromParent();
  MetaClassPtrAlias = nullptr;
}

// Add class structure to list to be added to the symtab later
ClassStruct = llvm::ConstantExpr::getBitCast(ClassStruct, PtrToInt8Ty);
Classes.push_back(ClassStruct);
3602}

3604llvm::Function *CGObjCGNU::ModuleInitFunction() {
// Only emit an ObjC load function if no Objective-C stuff has been called
if (Classes.empty() && Categories.empty() && ConstantStrings.empty() &&
    ExistingProtocols.empty() && SelectorTable.empty())
  return nullptr;

// Add all referenced protocols to a category.
GenerateProtocolHolderCategory();

llvm::StructType *selStructTy =
  dyn_cast<llvm::StructType>(SelectorTy->getElementType());
llvm::Type *selStructPtrTy = SelectorTy;
if (!selStructTy) {
  selStructTy = llvm::StructType::get(CGM.getLLVMContext(),
                                      { PtrToInt8Ty, PtrToInt8Ty });
  selStructPtrTy = llvm::PointerType::getUnqual(selStructTy);
}

// Generate statics list:
llvm::Constant *statics = NULLPtr;
if (!ConstantStrings.empty()) {
  llvm::GlobalVariable *fileStatics = [&] {
    ConstantInitBuilder builder(CGM);
    auto staticsStruct = builder.beginStruct();

    StringRef stringClass = CGM.getLangOpts().ObjCConstantStringClass;
    if (stringClass.empty()) stringClass = "NXConstantString";
    staticsStruct.add(MakeConstantString(stringClass,
                                         ".objc_static_class_name"));

    auto array = staticsStruct.beginArray();
    array.addAll(ConstantStrings);
    array.add(NULLPtr);
    array.finishAndAddTo(staticsStruct);

    return staticsStruct.finishAndCreateGlobal(".objc_statics",
                                               CGM.getPointerAlign());
  }();

  ConstantInitBuilder builder(CGM);
  auto allStaticsArray = builder.beginArray(fileStatics->getType());
  allStaticsArray.add(fileStatics);
  allStaticsArray.addNullPointer(fileStatics->getType());

  statics = allStaticsArray.finishAndCreateGlobal(".objc_statics_ptr",
                                                  CGM.getPointerAlign());
  statics = llvm::ConstantExpr::getBitCast(statics, PtrTy);
}

// Array of classes, categories, and constant objects.

SmallVector<llvm::GlobalAlias*, 16> selectorAliases;
unsigned selectorCount;

// Pointer to an array of selectors used in this module.
llvm::GlobalVariable *selectorList = [&] {
  ConstantInitBuilder builder(CGM);
  auto selectors = builder.beginArray(selStructTy);
  auto &table = SelectorTable; // MSVC workaround
  std::vector<Selector> allSelectors;
  for (auto &entry : table)
    allSelectors.push_back(entry.first);
  llvm::sort(allSelectors);

  for (auto &untypedSel : allSelectors) {
    std::string selNameStr = untypedSel.getAsString();
    llvm::Constant *selName = ExportUniqueString(selNameStr, ".objc_sel_name");

    for (TypedSelector &sel : table[untypedSel]) {
      llvm::Constant *selectorTypeEncoding = NULLPtr;
      if (!sel.first.empty())
        selectorTypeEncoding =
          MakeConstantString(sel.first, ".objc_sel_types");

      auto selStruct = selectors.beginStruct(selStructTy);
      selStruct.add(selName);
      selStruct.add(selectorTypeEncoding);
      selStruct.finishAndAddTo(selectors);

      // Store the selector alias for later replacement
      selectorAliases.push_back(sel.second);
    }
  }

  // Remember the number of entries in the selector table.
  selectorCount = selectors.size();

  // NULL-terminate the selector list.  This should not actually be required,
  // because the selector list has a length field.  Unfortunately, the GCC
  // runtime decides to ignore the length field and expects a NULL terminator,
  // and GCC cooperates with this by always setting the length to 0.
  auto selStruct = selectors.beginStruct(selStructTy);
  selStruct.add(NULLPtr);
  selStruct.add(NULLPtr);
  selStruct.finishAndAddTo(selectors);

  return selectors.finishAndCreateGlobal(".objc_selector_list",
                                         CGM.getPointerAlign());
}();

// Now that all of the static selectors exist, create pointers to them.
for (unsigned i = 0; i < selectorCount; ++i) {
  llvm::Constant *idxs[] = {
    Zeros[0],
    llvm::ConstantInt::get(Int32Ty, i)
  };
  // FIXME: We're generating redundant loads and stores here!
  llvm::Constant *selPtr = llvm::ConstantExpr::getGetElementPtr(
      selectorList->getValueType(), selectorList, idxs);
  // If selectors are defined as an opaque type, cast the pointer to this
  // type.
  selPtr = llvm::ConstantExpr::getBitCast(selPtr, SelectorTy);
  selectorAliases[i]->replaceAllUsesWith(selPtr);
  selectorAliases[i]->eraseFromParent();
}

llvm::GlobalVariable *symtab = [&] {
  ConstantInitBuilder builder(CGM);
  auto symtab = builder.beginStruct();

  // Number of static selectors
  symtab.addInt(LongTy, selectorCount);

  symtab.addBitCast(selectorList, selStructPtrTy);

  // Number of classes defined.
  symtab.addInt(CGM.Int16Ty, Classes.size());
  // Number of categories defined
  symtab.addInt(CGM.Int16Ty, Categories.size());

  // Create an array of classes, then categories, then static object instances
  auto classList = symtab.beginArray(PtrToInt8Ty);
  classList.addAll(Classes);
  classList.addAll(Categories);
  //  NULL-terminated list of static object instances (mainly constant strings)
  classList.add(statics);
  classList.add(NULLPtr);
  classList.finishAndAddTo(symtab);

  // Construct the symbol table.
  return symtab.finishAndCreateGlobal("", CGM.getPointerAlign());
}();

// The symbol table is contained in a module which has some version-checking
// constants
llvm::Constant *module = [&] {
  llvm::Type *moduleEltTys[] = {
    LongTy, LongTy, PtrToInt8Ty, symtab->getType(), IntTy
  };
  llvm::StructType *moduleTy =
    llvm::StructType::get(CGM.getLLVMContext(),
       makeArrayRef(moduleEltTys).drop_back(unsigned(RuntimeVersion < 10)));

  ConstantInitBuilder builder(CGM);
  auto module = builder.beginStruct(moduleTy);
  // Runtime version, used for ABI compatibility checking.
  module.addInt(LongTy, RuntimeVersion);
  // sizeof(ModuleTy)
  module.addInt(LongTy, CGM.getDataLayout().getTypeStoreSize(moduleTy));

  // The path to the source file where this module was declared
  SourceManager &SM = CGM.getContext().getSourceManager();
  const FileEntry *mainFile = SM.getFileEntryForID(SM.getMainFileID());
  std::string path =
    (Twine(mainFile->getDir()->getName()) + "/" + mainFile->getName()).str();
  module.add(MakeConstantString(path, ".objc_source_file_name"));
  module.add(symtab);

  if (RuntimeVersion >= 10) {
    switch (CGM.getLangOpts().getGC()) {
    case LangOptions::GCOnly:
      module.addInt(IntTy, 2);
      break;
    case LangOptions::NonGC:
      if (CGM.getLangOpts().ObjCAutoRefCount)
        module.addInt(IntTy, 1);
      else
        module.addInt(IntTy, 0);
      break;
    case LangOptions::HybridGC:
      module.addInt(IntTy, 1);
      break;
    }
  }

  return module.finishAndCreateGlobal("", CGM.getPointerAlign());
}();

// Create the load function calling the runtime entry point with the module
// structure
llvm::Function * LoadFunction = llvm::Function::Create(
    llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), false),
    llvm::GlobalValue::InternalLinkage, ".objc_load_function",
    &TheModule);
llvm::BasicBlock *EntryBB =
    llvm::BasicBlock::Create(VMContext, "entry", LoadFunction);
CGBuilderTy Builder(CGM, VMContext);
Builder.SetInsertPoint(EntryBB);

llvm::FunctionType *FT =
  llvm::FunctionType::get(Builder.getVoidTy(), module->getType(), true);
llvm::FunctionCallee Register =
    CGM.CreateRuntimeFunction(FT, "__objc_exec_class");
Builder.CreateCall(Register, module);

if (!ClassAliases.empty()) {
  llvm::Type *ArgTypes[2] = {PtrTy, PtrToInt8Ty};
  llvm::FunctionType *RegisterAliasTy =
    llvm::FunctionType::get(Builder.getVoidTy(),
                            ArgTypes, false);
  llvm::Function *RegisterAlias = llvm::Function::Create(
    RegisterAliasTy,
    llvm::GlobalValue::ExternalWeakLinkage, "class_registerAlias_np",
    &TheModule);
  llvm::BasicBlock *AliasBB =
    llvm::BasicBlock::Create(VMContext, "alias", LoadFunction);
  llvm::BasicBlock *NoAliasBB =
    llvm::BasicBlock::Create(VMContext, "no_alias", LoadFunction);

  // Branch based on whether the runtime provided class_registerAlias_np()
  llvm::Value *HasRegisterAlias = Builder.CreateICmpNE(RegisterAlias,
          llvm::Constant::getNullValue(RegisterAlias->getType()));
  Builder.CreateCondBr(HasRegisterAlias, AliasBB, NoAliasBB);

  // The true branch (has alias registration function):
  Builder.SetInsertPoint(AliasBB);
  // Emit alias registration calls:
  for (std::vector<ClassAliasPair>::iterator iter = ClassAliases.begin();
     iter != ClassAliases.end(); ++iter) {
     llvm::Constant *TheClass =
        TheModule.getGlobalVariable("_OBJC_CLASS_" + iter->first, true);
     if (TheClass) {
       TheClass = llvm::ConstantExpr::getBitCast(TheClass, PtrTy);
       Builder.CreateCall(RegisterAlias,
                          {TheClass, MakeConstantString(iter->second)});
     }
  }
  // Jump to end:
  Builder.CreateBr(NoAliasBB);

  // Missing alias registration function, just return from the function:
  Builder.SetInsertPoint(NoAliasBB);
}
Builder.CreateRetVoid();

return LoadFunction;
3850}

3852llvm::Function *CGObjCGNU::GenerateMethod(const ObjCMethodDecl *OMD,
                                        const ObjCContainerDecl *CD) {
const ObjCCategoryImplDecl *OCD =
  dyn_cast<ObjCCategoryImplDecl>(OMD->getDeclContext());
StringRef CategoryName = OCD ? OCD->getName() : "";
StringRef ClassName = CD->getName();
Selector MethodName = OMD->getSelector();
bool isClassMethod = !OMD->isInstanceMethod();

CodeGenTypes &Types = CGM.getTypes();
llvm::FunctionType *MethodTy =
  Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD));
std::string FunctionName = SymbolNameForMethod(ClassName, CategoryName,
    MethodName, isClassMethod);

llvm::Function *Method
  = llvm::Function::Create(MethodTy,
                           llvm::GlobalValue::InternalLinkage,
                           FunctionName,
                           &TheModule);
return Method;
3873}

3875llvm::FunctionCallee CGObjCGNU::GetPropertyGetFunction() {
return GetPropertyFn;
3877}

3879llvm::FunctionCallee CGObjCGNU::GetPropertySetFunction() {
return SetPropertyFn;
3881}

3883llvm::FunctionCallee CGObjCGNU::GetOptimizedPropertySetFunction(bool atomic,
                                                              bool copy) {
return nullptr;
3886}

3888llvm::FunctionCallee CGObjCGNU::GetGetStructFunction() {
return GetStructPropertyFn;
3890}

3892llvm::FunctionCallee CGObjCGNU::GetSetStructFunction() {
return SetStructPropertyFn;
3894}

3896llvm::FunctionCallee CGObjCGNU::GetCppAtomicObjectGetFunction() {
return nullptr;
3898}

3900llvm::FunctionCallee CGObjCGNU::GetCppAtomicObjectSetFunction() {
return nullptr;
3902}

3904llvm::FunctionCallee CGObjCGNU::EnumerationMutationFunction() {
return EnumerationMutationFn;
3906}

3908void CGObjCGNU::EmitSynchronizedStmt(CodeGenFunction &CGF,
                                   const ObjCAtSynchronizedStmt &S) {
EmitAtSynchronizedStmt(CGF, S, SyncEnterFn, SyncExitFn);
3911}


3914void CGObjCGNU::EmitTryStmt(CodeGenFunction &CGF,
                          const ObjCAtTryStmt &S) {
// Unlike the Apple non-fragile runtimes, which also uses
// unwind-based zero cost exceptions, the GNU Objective C runtime's
// EH support isn't a veneer over C++ EH.  Instead, exception
// objects are created by objc_exception_throw and destroyed by
// the personality function; this avoids the need for bracketing
// catch handlers with calls to __blah_begin_catch/__blah_end_catch
// (or even _Unwind_DeleteException), but probably doesn't
// interoperate very well with foreign exceptions.
//
// In Objective-C++ mode, we actually emit something equivalent to the C++
// exception handler.
EmitTryCatchStmt(CGF, S, EnterCatchFn, ExitCatchFn, ExceptionReThrowFn);
3928}

3930void CGObjCGNU::EmitThrowStmt(CodeGenFunction &CGF,
                            const ObjCAtThrowStmt &S,
                            bool ClearInsertionPoint) {
llvm::Value *ExceptionAsObject;
bool isRethrow = false;

if (const Expr *ThrowExpr = S.getThrowExpr()) {
  llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
  ExceptionAsObject = Exception;
} else {
  assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&(((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack
.back()) && "Unexpected rethrow outside @catch block."
) ? static_cast<void> (0) : __assert_fail ("(!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) && \"Unexpected rethrow outside @catch block.\""
, "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 3941, __PRETTY_FUNCTION__))
         "Unexpected rethrow outside @catch block.")(((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack
.back()) && "Unexpected rethrow outside @catch block."
) ? static_cast<void> (0) : __assert_fail ("(!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) && \"Unexpected rethrow outside @catch block.\""
, "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 3941, __PRETTY_FUNCTION__));
  ExceptionAsObject = CGF.ObjCEHValueStack.back();
  isRethrow = true;
}
if (isRethrow && usesSEHExceptions) {
  // For SEH, ExceptionAsObject may be undef, because the catch handler is
  // not passed it for catchalls and so it is not visible to the catch
  // funclet.  The real thrown object will still be live on the stack at this
  // point and will be rethrown.  If we are explicitly rethrowing the object
  // that was passed into the `@catch` block, then this code path is not
  // reached and we will instead call `objc_exception_throw` with an explicit
  // argument.
  llvm::CallBase *Throw = CGF.EmitRuntimeCallOrInvoke(ExceptionReThrowFn);
  Throw->setDoesNotReturn();
}
else {
  ExceptionAsObject = CGF.Builder.CreateBitCast(ExceptionAsObject, IdTy);
  llvm::CallBase *Throw =
      CGF.EmitRuntimeCallOrInvoke(ExceptionThrowFn, ExceptionAsObject);
  Throw->setDoesNotReturn();
}
CGF.Builder.CreateUnreachable();
if (ClearInsertionPoint)
  CGF.Builder.ClearInsertionPoint();
3965}

3967llvm::Value * CGObjCGNU::EmitObjCWeakRead(CodeGenFunction &CGF,
                                        Address AddrWeakObj) {
CGBuilderTy &B = CGF.Builder;
AddrWeakObj = EnforceType(B, AddrWeakObj, PtrToIdTy);
return B.CreateCall(WeakReadFn, AddrWeakObj.getPointer());
3972}

3974void CGObjCGNU::EmitObjCWeakAssign(CodeGenFunction &CGF,
                                 llvm::Value *src, Address dst) {
CGBuilderTy &B = CGF.Builder;
src = EnforceType(B, src, IdTy);
dst = EnforceType(B, dst, PtrToIdTy);
B.CreateCall(WeakAssignFn, {src, dst.getPointer()});
3980}

3982void CGObjCGNU::EmitObjCGlobalAssign(CodeGenFunction &CGF,
                                   llvm::Value *src, Address dst,
                                   bool threadlocal) {
CGBuilderTy &B = CGF.Builder;
src = EnforceType(B, src, IdTy);
dst = EnforceType(B, dst, PtrToIdTy);
// FIXME. Add threadloca assign API
assert(!threadlocal && "EmitObjCGlobalAssign - Threal Local API NYI")((!threadlocal && "EmitObjCGlobalAssign - Threal Local API NYI"
) ? static_cast<void> (0) : __assert_fail ("!threadlocal && \"EmitObjCGlobalAssign - Threal Local API NYI\""
, "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 3989, __PRETTY_FUNCTION__));
B.CreateCall(GlobalAssignFn, {src, dst.getPointer()});
3991}

3993void CGObjCGNU::EmitObjCIvarAssign(CodeGenFunction &CGF,
                                 llvm::Value *src, Address dst,
                                 llvm::Value *ivarOffset) {
CGBuilderTy &B = CGF.Builder;
src = EnforceType(B, src, IdTy);
dst = EnforceType(B, dst, IdTy);
B.CreateCall(IvarAssignFn, {src, dst.getPointer(), ivarOffset});
4000}

4002void CGObjCGNU::EmitObjCStrongCastAssign(CodeGenFunction &CGF,
                                       llvm::Value *src, Address dst) {
CGBuilderTy &B = CGF.Builder;
src = EnforceType(B, src, IdTy);
dst = EnforceType(B, dst, PtrToIdTy);
B.CreateCall(StrongCastAssignFn, {src, dst.getPointer()});
4008}

4010void CGObjCGNU::EmitGCMemmoveCollectable(CodeGenFunction &CGF,
                                       Address DestPtr,
                                       Address SrcPtr,
                                       llvm::Value *Size) {
CGBuilderTy &B = CGF.Builder;
DestPtr = EnforceType(B, DestPtr, PtrTy);
SrcPtr = EnforceType(B, SrcPtr, PtrTy);

B.CreateCall(MemMoveFn, {DestPtr.getPointer(), SrcPtr.getPointer(), Size});
4019}

4021llvm::GlobalVariable *CGObjCGNU::ObjCIvarOffsetVariable(
                            const ObjCInterfaceDecl *ID,
                            const ObjCIvarDecl *Ivar) {
const std::string Name = GetIVarOffsetVariableName(ID, Ivar);
// Emit the variable and initialize it with what we think the correct value
// is.  This allows code compiled with non-fragile ivars to work correctly
// when linked against code which isn't (most of the time).
llvm::GlobalVariable *IvarOffsetPointer = TheModule.getNamedGlobal(Name);
if (!IvarOffsetPointer)
  IvarOffsetPointer = new llvm::GlobalVariable(TheModule,
          llvm::Type::getInt32PtrTy(VMContext), false,
          llvm::GlobalValue::ExternalLinkage, nullptr, Name);
return IvarOffsetPointer;
4034}

4036LValue CGObjCGNU::EmitObjCValueForIvar(CodeGenFunction &CGF,
                                     QualType ObjectTy,
                                     llvm::Value *BaseValue,
                                     const ObjCIvarDecl *Ivar,
                                     unsigned CVRQualifiers) {
const ObjCInterfaceDecl *ID =
  ObjectTy->getAs<ObjCObjectType>()->getInterface();
return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
                                EmitIvarOffset(CGF, ID, Ivar));
4045}

4047static const ObjCInterfaceDecl *FindIvarInterface(ASTContext &Context,
                                                const ObjCInterfaceDecl *OID,
                                                const ObjCIvarDecl *OIVD) {
for (const ObjCIvarDecl *next = OID->all_declared_ivar_begin(); next;
     next = next->getNextIvar()) {
  if (OIVD == next)
    return OID;
}

// Otherwise check in the super class.
if (const ObjCInterfaceDecl *Super = OID->getSuperClass())
  return FindIvarInterface(Context, Super, OIVD);

return nullptr;
4061}

4063llvm::Value *CGObjCGNU::EmitIvarOffset(CodeGenFunction &CGF,
                       const ObjCInterfaceDecl *Interface,
                       const ObjCIvarDecl *Ivar) {
if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
  Interface = FindIvarInterface(CGM.getContext(), Interface, Ivar);

  // The MSVC linker cannot have a single global defined as LinkOnceAnyLinkage
  // and ExternalLinkage, so create a reference to the ivar global and rely on
  // the definition being created as part of GenerateClass.
  if (RuntimeVersion < 10 ||
      CGF.CGM.getTarget().getTriple().isKnownWindowsMSVCEnvironment())
    return CGF.Builder.CreateZExtOrBitCast(
        CGF.Builder.CreateAlignedLoad(
            Int32Ty, CGF.Builder.CreateAlignedLoad(
                         ObjCIvarOffsetVariable(Interface, Ivar),
                         CGF.getPointerAlign(), "ivar"),
            CharUnits::fromQuantity(4)),
        PtrDiffTy);
  std::string name = "__objc_ivar_offset_value_" +
    Interface->getNameAsString() +"." + Ivar->getNameAsString();
  CharUnits Align = CGM.getIntAlign();
  llvm::Value *Offset = TheModule.getGlobalVariable(name);
  if (!Offset) {
    auto GV = new llvm::GlobalVariable(TheModule, IntTy,
        false, llvm::GlobalValue::LinkOnceAnyLinkage,
        llvm::Constant::getNullValue(IntTy), name);
    GV->setAlignment(Align.getQuantity());
    Offset = GV;
  }
  Offset = CGF.Builder.CreateAlignedLoad(Offset, Align);
  if (Offset->getType() != PtrDiffTy)
    Offset = CGF.Builder.CreateZExtOrBitCast(Offset, PtrDiffTy);
  return Offset;
}
uint64_t Offset = ComputeIvarBaseOffset(CGF.CGM, Interface, Ivar);
return llvm::ConstantInt::get(PtrDiffTy, Offset, /*isSigned*/true);
4099}

4101CGObjCRuntime *
4102clang::CodeGen::CreateGNUObjCRuntime(CodeGenModule &CGM) {
auto Runtime = CGM.getLangOpts().ObjCRuntime;
switch (Runtime.getKind()) {
case ObjCRuntime::GNUstep:
  if (Runtime.getVersion() >= VersionTuple(2, 0))
    return new CGObjCGNUstep2(CGM);
  return new CGObjCGNUstep(CGM);

case ObjCRuntime::GCC:
  return new CGObjCGCC(CGM);

case ObjCRuntime::ObjFW:
  return new CGObjCObjFW(CGM);

case ObjCRuntime::FragileMacOSX:
case ObjCRuntime::MacOSX:
case ObjCRuntime::iOS:
case ObjCRuntime::WatchOS:
  llvm_unreachable("these runtimes are not GNU runtimes")::llvm::llvm_unreachable_internal("these runtimes are not GNU runtimes"
, "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 4120);
}
llvm_unreachable("bad runtime")::llvm::llvm_unreachable_internal("bad runtime", "/build/llvm-toolchain-snapshot-10~svn373386/tools/clang/lib/CodeGen/CGObjCGNU.cpp"
, 4122);
4123}

←

/build/llvm-toolchain-snapshot-10~svn373386/include/llvm/Support/MathExtras.h

1//===-- llvm/Support/MathExtras.h - Useful math functions -------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file contains some functions that are useful for math stuff.
10//
11//===----------------------------------------------------------------------===//
12 
13#ifndef LLVM_SUPPORT_MATHEXTRAS_H
14#define LLVM_SUPPORT_MATHEXTRAS_H
15 
16#include "llvm/Support/Compiler.h"
17#include "llvm/Support/SwapByteOrder.h"
18#include <algorithm>
19#include <cassert>
20#include <climits>
21#include <cstring>
22#include <limits>
23#include <type_traits>
24 
25#ifdef __ANDROID_NDK__
26#include <android/api-level.h>
27#endif
28 
29#ifdef _MSC_VER
30// Declare these intrinsics manually rather including intrin.h. It's very
31// expensive, and MathExtras.h is popular.
32// #include <intrin.h>
33extern "C" {
34unsigned char _BitScanForward(unsigned long *_Index, unsigned long _Mask);
35unsigned char _BitScanForward64(unsigned long *_Index, unsigned __int64 _Mask);
36unsigned char _BitScanReverse(unsigned long *_Index, unsigned long _Mask);
37unsigned char _BitScanReverse64(unsigned long *_Index, unsigned __int64 _Mask);
38}
39#endif
40 
41namespace llvm {
42/// The behavior an operation has on an input of 0.
43enum ZeroBehavior {
44  /// The returned value is undefined.
45  ZB_Undefined,
46  /// The returned value is numeric_limits<T>::max()
47  ZB_Max,
48  /// The returned value is numeric_limits<T>::digits
49  ZB_Width
50};
51 
52namespace detail {
53template <typename T, std::size_t SizeOfT> struct TrailingZerosCounter {
54  static unsigned count(T Val, ZeroBehavior) {
55    if (!Val)
56      return std::numeric_limits<T>::digits;
57    if (Val & 0x1)
58      return 0;
59 
60    // Bisection method.
61    unsigned ZeroBits = 0;
62    T Shift = std::numeric_limits<T>::digits >> 1;
63    T Mask = std::numeric_limits<T>::max() >> Shift;
64    while (Shift) {
65      if ((Val & Mask) == 0) {
66        Val >>= Shift;
67        ZeroBits |= Shift;
68      }
69      Shift >>= 1;
70      Mask >>= Shift;
71    }
72    return ZeroBits;
73  }
74};
75 
76#if defined(__GNUC__4) || defined(_MSC_VER)
77template <typename T> struct TrailingZerosCounter<T, 4> {
78  static unsigned count(T Val, ZeroBehavior ZB) {
79    if (ZB != ZB_Undefined && Val == 0)
80      return 32;
81 
82#if __has_builtin(__builtin_ctz)1 || defined(__GNUC__4)
83    return __builtin_ctz(Val);
84#elif defined(_MSC_VER)
85    unsigned long Index;
86    _BitScanForward(&Index, Val);
87    return Index;
88#endif
89  }
90};
91 
92#if !defined(_MSC_VER) || defined(_M_X64)
93template <typename T> struct TrailingZerosCounter<T, 8> {
94  static unsigned count(T Val, ZeroBehavior ZB) {
95    if (ZB != ZB_Undefined && Val == 0)
96      return 64;
97 
98#if __has_builtin(__builtin_ctzll)1 || defined(__GNUC__4)
99    return __builtin_ctzll(Val);
100#elif defined(_MSC_VER)
101    unsigned long Index;
102    _BitScanForward64(&Index, Val);
103    return Index;
104#endif
105  }
106};
107#endif
108#endif
109} // namespace detail
110 
111/// Count number of 0's from the least significant bit to the most
112///   stopping at the first 1.
113///
114/// Only unsigned integral types are allowed.
115///
116/// \param ZB the behavior on an input of 0. Only ZB_Width and ZB_Undefined are
117///   valid arguments.
118template <typename T>
119unsigned countTrailingZeros(T Val, ZeroBehavior ZB = ZB_Width) {
120  static_assert(std::numeric_limits<T>::is_integer &&
121                    !std::numeric_limits<T>::is_signed,
122                "Only unsigned integral types are allowed.");
123  return llvm::detail::TrailingZerosCounter<T, sizeof(T)>::count(Val, ZB);
124}
125 
126namespace detail {
127template <typename T, std::size_t SizeOfT> struct LeadingZerosCounter {
128  static unsigned count(T Val, ZeroBehavior) {
129    if (!Val)
130      return std::numeric_limits<T>::digits;
131 
132    // Bisection method.
133    unsigned ZeroBits = 0;
134    for (T Shift = std::numeric_limits<T>::digits >> 1; Shift; Shift >>= 1) {
135      T Tmp = Val >> Shift;
136      if (Tmp)
137        Val = Tmp;
138      else
139        ZeroBits |= Shift;
140    }
141    return ZeroBits;
142  }
143};
144 
145#if defined(__GNUC__4) || defined(_MSC_VER)
146template <typename T> struct LeadingZerosCounter<T, 4> {
147  static unsigned count(T Val, ZeroBehavior ZB) {
148    if (ZB != ZB_Undefined && Val == 0)
149      return 32;
150 
151#if __has_builtin(__builtin_clz)1 || defined(__GNUC__4)
152    return __builtin_clz(Val);
153#elif defined(_MSC_VER)
154    unsigned long Index;
155    _BitScanReverse(&Index, Val);
156    return Index ^ 31;
157#endif
158  }
159};
160 
161#if !defined(_MSC_VER) || defined(_M_X64)
162template <typename T> struct LeadingZerosCounter<T, 8> {
163  static unsigned count(T Val, ZeroBehavior ZB) {
164    if (ZB != ZB_Undefined && Val == 0)
165      return 64;
166 
167#if __has_builtin(__builtin_clzll)1 || defined(__GNUC__4)
168    return __builtin_clzll(Val);
169#elif defined(_MSC_VER)
170    unsigned long Index;
171    _BitScanReverse64(&Index, Val);
172    return Index ^ 63;
173#endif
174  }
175};
176#endif
177#endif
178} // namespace detail
179 
180/// Count number of 0's from the most significant bit to the least
181///   stopping at the first 1.
182///
183/// Only unsigned integral types are allowed.
184///
185/// \param ZB the behavior on an input of 0. Only ZB_Width and ZB_Undefined are
186///   valid arguments.
187template <typename T>
188unsigned countLeadingZeros(T Val, ZeroBehavior ZB = ZB_Width) {
189  static_assert(std::numeric_limits<T>::is_integer &&
190                    !std::numeric_limits<T>::is_signed,
191                "Only unsigned integral types are allowed.");
192  return llvm::detail::LeadingZerosCounter<T, sizeof(T)>::count(Val, ZB);
193}
194 
195/// Get the index of the first set bit starting from the least
196///   significant bit.
197///
198/// Only unsigned integral types are allowed.
199///
200/// \param ZB the behavior on an input of 0. Only ZB_Max and ZB_Undefined are
201///   valid arguments.
202template <typename T> T findFirstSet(T Val, ZeroBehavior ZB = ZB_Max) {
203  if (ZB == ZB_Max && Val == 0)
204    return std::numeric_limits<T>::max();
205 
206  return countTrailingZeros(Val, ZB_Undefined);
207}
208 
209/// Create a bitmask with the N right-most bits set to 1, and all other
210/// bits set to 0.  Only unsigned types are allowed.
211template <typename T> T maskTrailingOnes(unsigned N) {
212  static_assert(std::is_unsigned<T>::value, "Invalid type!");
213  const unsigned Bits = CHAR_BIT8 * sizeof(T);
214  assert(N <= Bits && "Invalid bit index")((N <= Bits && "Invalid bit index") ? static_cast<
void> (0) : __assert_fail ("N <= Bits && \"Invalid bit index\""
, "/build/llvm-toolchain-snapshot-10~svn373386/include/llvm/Support/MathExtras.h"
, 214, __PRETTY_FUNCTION__));
215  return N == 0 ? 0 : (T(-1) >> (Bits - N));
216}
217 
218/// Create a bitmask with the N left-most bits set to 1, and all other
219/// bits set to 0.  Only unsigned types are allowed.
220template <typename T> T maskLeadingOnes(unsigned N) {
221  return ~maskTrailingOnes<T>(CHAR_BIT8 * sizeof(T) - N);
222}
223 
224/// Create a bitmask with the N right-most bits set to 0, and all other
225/// bits set to 1.  Only unsigned types are allowed.
226template <typename T> T maskTrailingZeros(unsigned N) {
227  return maskLeadingOnes<T>(CHAR_BIT8 * sizeof(T) - N);
228}
229 
230/// Create a bitmask with the N left-most bits set to 0, and all other
231/// bits set to 1.  Only unsigned types are allowed.
232template <typename T> T maskLeadingZeros(unsigned N) {
233  return maskTrailingOnes<T>(CHAR_BIT8 * sizeof(T) - N);
234}
235 
236/// Get the index of the last set bit starting from the least
237///   significant bit.
238///
239/// Only unsigned integral types are allowed.
240///
241/// \param ZB the behavior on an input of 0. Only ZB_Max and ZB_Undefined are
242///   valid arguments.
243template <typename T> T findLastSet(T Val, ZeroBehavior ZB = ZB_Max) {
244  if (ZB == ZB_Max && Val == 0)
245    return std::numeric_limits<T>::max();
246 
247  // Use ^ instead of - because both gcc and llvm can remove the associated ^
248  // in the __builtin_clz intrinsic on x86.
249  return countLeadingZeros(Val, ZB_Undefined) ^
250         (std::numeric_limits<T>::digits - 1);
251}
252 
253/// Macro compressed bit reversal table for 256 bits.
254///
255/// http://graphics.stanford.edu/~seander/bithacks.html#BitReverseTable
256static const unsigned char BitReverseTable256[256] = {
257#define R2(n) n, n + 2 * 64, n + 1 * 64, n + 3 * 64
258#define R4(n) R2(n), R2(n + 2 * 16), R2(n + 1 * 16), R2(n + 3 * 16)
259#define R6(n) R4(n), R4(n + 2 * 4), R4(n + 1 * 4), R4(n + 3 * 4)
260  R6(0), R6(2), R6(1), R6(3)
261#undef R2
262#undef R4
263#undef R6
264};
265 
266/// Reverse the bits in \p Val.
267template <typename T>
268T reverseBits(T Val) {
269  unsigned char in[sizeof(Val)];
270  unsigned char out[sizeof(Val)];
271  std::memcpy(in, &Val, sizeof(Val));
272  for (unsigned i = 0; i < sizeof(Val); ++i)
273    out[(sizeof(Val) - i) - 1] = BitReverseTable256[in[i]];
274  std::memcpy(&Val, out, sizeof(Val));
275  return Val;
276}
277 
278// NOTE: The following support functions use the _32/_64 extensions instead of
279// type overloading so that signed and unsigned integers can be used without
280// ambiguity.
281 
282/// Return the high 32 bits of a 64 bit value.
283constexpr inline uint32_t Hi_32(uint64_t Value) {
284  return static_cast<uint32_t>(Value >> 32);
285}
286 
287/// Return the low 32 bits of a 64 bit value.
288constexpr inline uint32_t Lo_32(uint64_t Value) {
289  return static_cast<uint32_t>(Value);
290}
291 
292/// Make a 64-bit integer from a high / low pair of 32-bit integers.
293constexpr inline uint64_t Make_64(uint32_t High, uint32_t Low) {
294  return ((uint64_t)High << 32) | (uint64_t)Low;
295}
296 
297/// Checks if an integer fits into the given bit width.
298template <unsigned N> constexpr inline bool isInt(int64_t x) {
299  return N >= 64 || (-(INT64_C(1)1L<<(N-1)) <= x && x < (INT64_C(1)1L<<(N-1)));
300}
301// Template specializations to get better code for common cases.
302template <> constexpr inline bool isInt<8>(int64_t x) {
303  return static_cast<int8_t>(x) == x;
304}
305template <> constexpr inline bool isInt<16>(int64_t x) {
306  return static_cast<int16_t>(x) == x;
307}
308template <> constexpr inline bool isInt<32>(int64_t x) {
309  return static_cast<int32_t>(x) == x;
310}
311 
312/// Checks if a signed integer is an N bit number shifted left by S.
313template <unsigned N, unsigned S>
314constexpr inline bool isShiftedInt(int64_t x) {
315  static_assert(
316      N > 0, "isShiftedInt<0> doesn't make sense (refers to a 0-bit number.");
317  static_assert(N + S <= 64, "isShiftedInt<N, S> with N + S > 64 is too wide.");
318  return isInt<N + S>(x) && (x % (UINT64_C(1)1UL << S) == 0);
319}
320 
321/// Checks if an unsigned integer fits into the given bit width.
322///
323/// This is written as two functions rather than as simply
324///
325///   return N >= 64 || X < (UINT64_C(1) << N);
326///
327/// to keep MSVC from (incorrectly) warning on isUInt<64> that we're shifting
328/// left too many places.
329template <unsigned N>
330constexpr inline typename std::enable_if<(N < 64), bool>::type
331isUInt(uint64_t X) {
332  static_assert(N > 0, "isUInt<0> doesn't make sense");
333  return X < (UINT64_C(1)1UL << (N));
334}
335template <unsigned N>
336constexpr inline typename std::enable_if<N >= 64, bool>::type
337isUInt(uint64_t X) {
338  return true;
339}
340 
341// Template specializations to get better code for common cases.
342template <> constexpr inline bool isUInt<8>(uint64_t x) {
343  return static_cast<uint8_t>(x) == x;
344}
345template <> constexpr inline bool isUInt<16>(uint64_t x) {
346  return static_cast<uint16_t>(x) == x;
347}
348template <> constexpr inline bool isUInt<32>(uint64_t x) {
349  return static_cast<uint32_t>(x) == x;
350}
351 
352/// Checks if a unsigned integer is an N bit number shifted left by S.
353template <unsigned N, unsigned S>
354constexpr inline bool isShiftedUInt(uint64_t x) {
355  static_assert(
356      N > 0, "isShiftedUInt<0> doesn't make sense (refers to a 0-bit number)");
357  static_assert(N + S <= 64,
358                "isShiftedUInt<N, S> with N + S > 64 is too wide.");
359  // Per the two static_asserts above, S must be strictly less than 64.  So
360  // 1 << S is not undefined behavior.
361  return isUInt<N + S>(x) && (x % (UINT64_C(1)1UL << S) == 0);
362}
363 
364/// Gets the maximum value for a N-bit unsigned integer.
365inline uint64_t maxUIntN(uint64_t N) {
366  assert(N > 0 && N <= 64 && "integer width out of range")((N > 0 && N <= 64 && "integer width out of range"
) ? static_cast<void> (0) : __assert_fail ("N > 0 && N <= 64 && \"integer width out of range\""
, "/build/llvm-toolchain-snapshot-10~svn373386/include/llvm/Support/MathExtras.h"
, 366, __PRETTY_FUNCTION__));
367 
368  // uint64_t(1) << 64 is undefined behavior, so we can't do
369  //   (uint64_t(1) << N) - 1
370  // without checking first that N != 64.  But this works and doesn't have a
371  // branch.
372  return UINT64_MAX(18446744073709551615UL) >> (64 - N);
373}
374 
375/// Gets the minimum value for a N-bit signed integer.
376inline int64_t minIntN(int64_t N) {
377  assert(N > 0 && N <= 64 && "integer width out of range")((N > 0 && N <= 64 && "integer width out of range"
) ? static_cast<void> (0) : __assert_fail ("N > 0 && N <= 64 && \"integer width out of range\""
, "/build/llvm-toolchain-snapshot-10~svn373386/include/llvm/Support/MathExtras.h"
, 377, __PRETTY_FUNCTION__));
378 
379  return -(UINT64_C(1)1UL<<(N-1));
380}
381 
382/// Gets the maximum value for a N-bit signed integer.
383inline int64_t maxIntN(int64_t N) {
384  assert(N > 0 && N <= 64 && "integer width out of range")((N > 0 && N <= 64 && "integer width out of range"
) ? static_cast<void> (0) : __assert_fail ("N > 0 && N <= 64 && \"integer width out of range\""
, "/build/llvm-toolchain-snapshot-10~svn373386/include/llvm/Support/MathExtras.h"
, 384, __PRETTY_FUNCTION__));
385 
386  // This relies on two's complement wraparound when N == 64, so we convert to
387  // int64_t only at the very end to avoid UB.
388  return (UINT64_C(1)1UL << (N - 1)) - 1;
389}
390 
391/// Checks if an unsigned integer fits into the given (dynamic) bit width.
392inline bool isUIntN(unsigned N, uint64_t x) {
393  return N >= 64 || x <= maxUIntN(N);
394}
395 
396/// Checks if an signed integer fits into the given (dynamic) bit width.
397inline bool isIntN(unsigned N, int64_t x) {
398  return N >= 64 || (minIntN(N) <= x && x <= maxIntN(N));
399}
400 
401/// Return true if the argument is a non-empty sequence of ones starting at the
402/// least significant bit with the remainder zero (32 bit version).
403/// Ex. isMask_32(0x0000FFFFU) == true.
404constexpr inline bool isMask_32(uint32_t Value) {
405  return Value && ((Value + 1) & Value) == 0;
406}
407 
408/// Return true if the argument is a non-empty sequence of ones starting at the
409/// least significant bit with the remainder zero (64 bit version).
410constexpr inline bool isMask_64(uint64_t Value) {
411  return Value && ((Value + 1) & Value) == 0;
412}
413 
414/// Return true if the argument contains a non-empty sequence of ones with the
415/// remainder zero (32 bit version.) Ex. isShiftedMask_32(0x0000FF00U) == true.
416constexpr inline bool isShiftedMask_32(uint32_t Value) {
417  return Value && isMask_32((Value - 1) | Value);
418}
419 
420/// Return true if the argument contains a non-empty sequence of ones with the
421/// remainder zero (64 bit version.)
422constexpr inline bool isShiftedMask_64(uint64_t Value) {
423  return Value && isMask_64((Value - 1) | Value);
424}
425 
426/// Return true if the argument is a power of two > 0.
427/// Ex. isPowerOf2_32(0x00100000U) == true (32 bit edition.)
428constexpr inline bool isPowerOf2_32(uint32_t Value) {
429  return Value && !(Value & (Value - 1));
430}
431 
432/// Return true if the argument is a power of two > 0 (64 bit edition.)
433constexpr inline bool isPowerOf2_64(uint64_t Value) {
434  return Value && !(Value & (Value - 1));
435}
436 
437/// Return a byte-swapped representation of the 16-bit argument.
438inline uint16_t ByteSwap_16(uint16_t Value) {
439  return sys::SwapByteOrder_16(Value);
440}
441 
442/// Return a byte-swapped representation of the 32-bit argument.
443inline uint32_t ByteSwap_32(uint32_t Value) {
444  return sys::SwapByteOrder_32(Value);
445}
446 
447/// Return a byte-swapped representation of the 64-bit argument.
448inline uint64_t ByteSwap_64(uint64_t Value) {
449  return sys::SwapByteOrder_64(Value);
450}
451 
452/// Count the number of ones from the most significant bit to the first
453/// zero bit.
454///
455/// Ex. countLeadingOnes(0xFF0FFF00) == 8.
456/// Only unsigned integral types are allowed.
457///
458/// \param ZB the behavior on an input of all ones. Only ZB_Width and
459/// ZB_Undefined are valid arguments.
460template <typename T>
461unsigned countLeadingOnes(T Value, ZeroBehavior ZB = ZB_Width) {
462  static_assert(std::numeric_limits<T>::is_integer &&
463                    !std::numeric_limits<T>::is_signed,
464                "Only unsigned integral types are allowed.");
465  return countLeadingZeros<T>(~Value, ZB);
466}
467 
468/// Count the number of ones from the least significant bit to the first
469/// zero bit.
470///
471/// Ex. countTrailingOnes(0x00FF00FF) == 8.
472/// Only unsigned integral types are allowed.
473///
474/// \param ZB the behavior on an input of all ones. Only ZB_Width and
475/// ZB_Undefined are valid arguments.
476template <typename T>
477unsigned countTrailingOnes(T Value, ZeroBehavior ZB = ZB_Width) {
478  static_assert(std::numeric_limits<T>::is_integer &&
479                    !std::numeric_limits<T>::is_signed,
480                "Only unsigned integral types are allowed.");
481  return countTrailingZeros<T>(~Value, ZB);
482}
483 
484namespace detail {
485template <typename T, std::size_t SizeOfT> struct PopulationCounter {
486  static unsigned count(T Value) {
487    // Generic version, forward to 32 bits.
488    static_assert(SizeOfT <= 4, "Not implemented!");
489#if defined(__GNUC__4)
490    return __builtin_popcount(Value);
491#else
492    uint32_t v = Value;
493    v = v - ((v >> 1) & 0x55555555);
494    v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
495    return ((v + (v >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
496#endif
497  }
498};
499 
500template <typename T> struct PopulationCounter<T, 8> {
501  static unsigned count(T Value) {
502#if defined(__GNUC__4)
503    return __builtin_popcountll(Value);
504#else
505    uint64_t v = Value;
506    v = v - ((v >> 1) & 0x5555555555555555ULL);
507    v = (v & 0x3333333333333333ULL) + ((v >> 2) & 0x3333333333333333ULL);
508    v = (v + (v >> 4)) & 0x0F0F0F0F0F0F0F0FULL;
509    return unsigned((uint64_t)(v * 0x0101010101010101ULL) >> 56);
510#endif
511  }
512};
513} // namespace detail
514 
515/// Count the number of set bits in a value.
516/// Ex. countPopulation(0xF000F000) = 8
517/// Returns 0 if the word is zero.
518template <typename T>
519inline unsigned countPopulation(T Value) {
520  static_assert(std::numeric_limits<T>::is_integer &&
521                    !std::numeric_limits<T>::is_signed,
522                "Only unsigned integral types are allowed.");
523  return detail::PopulationCounter<T, sizeof(T)>::count(Value);
524}
525 
526/// Return the log base 2 of the specified value.
527inline double Log2(double Value) {
528#if defined(__ANDROID_API__) && __ANDROID_API__ < 18
529  return __builtin_log(Value) / __builtin_log(2.0);
530#else
531  return log2(Value);
532#endif
533}
534 
535/// Return the floor log base 2 of the specified value, -1 if the value is zero.
536/// (32 bit edition.)
537/// Ex. Log2_32(32) == 5, Log2_32(1) == 0, Log2_32(0) == -1, Log2_32(6) == 2
538inline unsigned Log2_32(uint32_t Value) {
539  return 31 - countLeadingZeros(Value);
16
←
Returning the value 4294967295→
540}
541 
542/// Return the floor log base 2 of the specified value, -1 if the value is zero.
543/// (64 bit edition.)
544inline unsigned Log2_64(uint64_t Value) {
545  return 63 - countLeadingZeros(Value);
546}
547 
548/// Return the ceil log base 2 of the specified value, 32 if the value is zero.
549/// (32 bit edition).
550/// Ex. Log2_32_Ceil(32) == 5, Log2_32_Ceil(1) == 0, Log2_32_Ceil(6) == 3
551inline unsigned Log2_32_Ceil(uint32_t Value) {
552  return 32 - countLeadingZeros(Value - 1);
553}
554 
555/// Return the ceil log base 2 of the specified value, 64 if the value is zero.
556/// (64 bit edition.)
557inline unsigned Log2_64_Ceil(uint64_t Value) {
558  return 64 - countLeadingZeros(Value - 1);
559}
560 
561/// Return the greatest common divisor of the values using Euclid's algorithm.
562template <typename T>
563inline T greatestCommonDivisor(T A, T B) {
564  while (B) {
565    T Tmp = B;
566    B = A % B;
567    A = Tmp;
568  }
569  return A;
570}
571 
572inline uint64_t GreatestCommonDivisor64(uint64_t A, uint64_t B) {
573  return greatestCommonDivisor<uint64_t>(A, B);
574}
575 
576/// This function takes a 64-bit integer and returns the bit equivalent double.
577inline double BitsToDouble(uint64_t Bits) {
578  double D;
579  static_assert(sizeof(uint64_t) == sizeof(double), "Unexpected type sizes");
580  memcpy(&D, &Bits, sizeof(Bits));
581  return D;
582}
583 
584/// This function takes a 32-bit integer and returns the bit equivalent float.
585inline float BitsToFloat(uint32_t Bits) {
586  float F;
587  static_assert(sizeof(uint32_t) == sizeof(float), "Unexpected type sizes");
588  memcpy(&F, &Bits, sizeof(Bits));
589  return F;
590}
591 
592/// This function takes a double and returns the bit equivalent 64-bit integer.
593/// Note that copying doubles around changes the bits of NaNs on some hosts,
594/// notably x86, so this routine cannot be used if these bits are needed.
595inline uint64_t DoubleToBits(double Double) {
596  uint64_t Bits;
597  static_assert(sizeof(uint64_t) == sizeof(double), "Unexpected type sizes");
598  memcpy(&Bits, &Double, sizeof(Double));
599  return Bits;
600}
601 
602/// This function takes a float and returns the bit equivalent 32-bit integer.
603/// Note that copying floats around changes the bits of NaNs on some hosts,
604/// notably x86, so this routine cannot be used if these bits are needed.
605inline uint32_t FloatToBits(float Float) {
606  uint32_t Bits;
607  static_assert(sizeof(uint32_t) == sizeof(float), "Unexpected type sizes");
608  memcpy(&Bits, &Float, sizeof(Float));
609  return Bits;
610}
611 
612/// A and B are either alignments or offsets. Return the minimum alignment that
613/// may be assumed after adding the two together.
614constexpr inline uint64_t MinAlign(uint64_t A, uint64_t B) {
615  // The largest power of 2 that divides both A and B.
616  //
617  // Replace "-Value" by "1+~Value" in the following commented code to avoid
618  // MSVC warning C4146
619  //    return (A | B) & -(A | B);
620  return (A | B) & (1 + ~(A | B));
621}
622 
623/// Aligns \c Addr to \c Alignment bytes, rounding up.
624///
625/// Alignment should be a power of two.  This method rounds up, so
626/// alignAddr(7, 4) == 8 and alignAddr(8, 4) == 8.
627inline uintptr_t alignAddr(const void *Addr, size_t Alignment) {
628  assert(Alignment && isPowerOf2_64((uint64_t)Alignment) &&((Alignment && isPowerOf2_64((uint64_t)Alignment) &&
 "Alignment is not a power of two!") ? static_cast<void>
 (0) : __assert_fail ("Alignment && isPowerOf2_64((uint64_t)Alignment) && \"Alignment is not a power of two!\""
, "/build/llvm-toolchain-snapshot-10~svn373386/include/llvm/Support/MathExtras.h"
, 629, __PRETTY_FUNCTION__))
629         "Alignment is not a power of two!")((Alignment && isPowerOf2_64((uint64_t)Alignment) &&
 "Alignment is not a power of two!") ? static_cast<void>
 (0) : __assert_fail ("Alignment && isPowerOf2_64((uint64_t)Alignment) && \"Alignment is not a power of two!\""
, "/build/llvm-toolchain-snapshot-10~svn373386/include/llvm/Support/MathExtras.h"
, 629, __PRETTY_FUNCTION__));
630 
631  assert((uintptr_t)Addr + Alignment - 1 >= (uintptr_t)Addr)(((uintptr_t)Addr + Alignment - 1 >= (uintptr_t)Addr) ? static_cast
<void> (0) : __assert_fail ("(uintptr_t)Addr + Alignment - 1 >= (uintptr_t)Addr"
, "/build/llvm-toolchain-snapshot-10~svn373386/include/llvm/Support/MathExtras.h"
, 631, __PRETTY_FUNCTION__));
632 
633  return (((uintptr_t)Addr + Alignment - 1) & ~(uintptr_t)(Alignment - 1));
634}
635 
636/// Returns the necessary adjustment for aligning \c Ptr to \c Alignment
637/// bytes, rounding up.
638inline size_t alignmentAdjustment(const void *Ptr, size_t Alignment) {
639  return alignAddr(Ptr, Alignment) - (uintptr_t)Ptr;
640}
641 
642/// Returns the next power of two (in 64-bits) that is strictly greater than A.
643/// Returns zero on overflow.
644inline uint64_t NextPowerOf2(uint64_t A) {
645  A |= (A >> 1);
646  A |= (A >> 2);
647  A |= (A >> 4);
648  A |= (A >> 8);
649  A |= (A >> 16);
650  A |= (A >> 32);
651  return A + 1;
652}
653 
654/// Returns the power of two which is less than or equal to the given value.
655/// Essentially, it is a floor operation across the domain of powers of two.
656inline uint64_t PowerOf2Floor(uint64_t A) {
657  if (!A) return 0;
658  return 1ull << (63 - countLeadingZeros(A, ZB_Undefined));
659}
660 
661/// Returns the power of two which is greater than or equal to the given value.
662/// Essentially, it is a ceil operation across the domain of powers of two.
663inline uint64_t PowerOf2Ceil(uint64_t A) {
664  if (!A)
665    return 0;
666  return NextPowerOf2(A - 1);
667}
668 
669/// Returns the next integer (mod 2**64) that is greater than or equal to
670/// \p Value and is a multiple of \p Align. \p Align must be non-zero.
671///
672/// If non-zero \p Skew is specified, the return value will be a minimal
673/// integer that is greater than or equal to \p Value and equal to
674/// \p Align * N + \p Skew for some integer N. If \p Skew is larger than
675/// \p Align, its value is adjusted to '\p Skew mod \p Align'.
676///
677/// Examples:
678/// \code
679///   alignTo(5, 8) = 8
680///   alignTo(17, 8) = 24
681///   alignTo(~0LL, 8) = 0
682///   alignTo(321, 255) = 510
683///
684///   alignTo(5, 8, 7) = 7
685///   alignTo(17, 8, 1) = 17
686///   alignTo(~0LL, 8, 3) = 3
687///   alignTo(321, 255, 42) = 552
688/// \endcode
689inline uint64_t alignTo(uint64_t Value, uint64_t Align, uint64_t Skew = 0) {
690  assert(Align != 0u && "Align can't be 0.")((Align != 0u && "Align can't be 0.") ? static_cast<
void> (0) : __assert_fail ("Align != 0u && \"Align can't be 0.\""
, "/build/llvm-toolchain-snapshot-10~svn373386/include/llvm/Support/MathExtras.h"
, 690, __PRETTY_FUNCTION__));
691  Skew %= Align;
692  return (Value + Align - 1 - Skew) / Align * Align + Skew;
693}
694 
695/// Returns the next integer (mod 2**64) that is greater than or equal to
696/// \p Value and is a multiple of \c Align. \c Align must be non-zero.
697template <uint64_t Align> constexpr inline uint64_t alignTo(uint64_t Value) {
698  static_assert(Align != 0u, "Align must be non-zero");
699  return (Value + Align - 1) / Align * Align;
700}
701 
702/// Returns the integer ceil(Numerator / Denominator).
703inline uint64_t divideCeil(uint64_t Numerator, uint64_t Denominator) {
704  return alignTo(Numerator, Denominator) / Denominator;
705}
706 
707/// Returns the largest uint64_t less than or equal to \p Value and is
708/// \p Skew mod \p Align. \p Align must be non-zero
709inline uint64_t alignDown(uint64_t Value, uint64_t Align, uint64_t Skew = 0) {
710  assert(Align != 0u && "Align can't be 0.")((Align != 0u && "Align can't be 0.") ? static_cast<
void> (0) : __assert_fail ("Align != 0u && \"Align can't be 0.\""
, "/build/llvm-toolchain-snapshot-10~svn373386/include/llvm/Support/MathExtras.h"
, 710, __PRETTY_FUNCTION__));
711  Skew %= Align;
712  return (Value - Skew) / Align * Align + Skew;
713}
714 
715/// Sign-extend the number in the bottom B bits of X to a 32-bit integer.
716/// Requires 0 < B <= 32.
717template <unsigned B> constexpr inline int32_t SignExtend32(uint32_t X) {
718  static_assert(B > 0, "Bit width can't be 0.");
719  static_assert(B <= 32, "Bit width out of range.");
720  return int32_t(X << (32 - B)) >> (32 - B);
721}
722 
723/// Sign-extend the number in the bottom B bits of X to a 32-bit integer.
724/// Requires 0 < B < 32.
725inline int32_t SignExtend32(uint32_t X, unsigned B) {
726  assert(B > 0 && "Bit width can't be 0.")((B > 0 && "Bit width can't be 0.") ? static_cast<
void> (0) : __assert_fail ("B > 0 && \"Bit width can't be 0.\""
, "/build/llvm-toolchain-snapshot-10~svn373386/include/llvm/Support/MathExtras.h"
, 726, __PRETTY_FUNCTION__));
727  assert(B <= 32 && "Bit width out of range.")((B <= 32 && "Bit width out of range.") ? static_cast
<void> (0) : __assert_fail ("B <= 32 && \"Bit width out of range.\""
, "/build/llvm-toolchain-snapshot-10~svn373386/include/llvm/Support/MathExtras.h"
, 727, __PRETTY_FUNCTION__));
728  return int32_t(X << (32 - B)) >> (32 - B);
729}
730 
731/// Sign-extend the number in the bottom B bits of X to a 64-bit integer.
732/// Requires 0 < B < 64.
733template <unsigned B> constexpr inline int64_t SignExtend64(uint64_t x) {
734  static_assert(B > 0, "Bit width can't be 0.");
735  static_assert(B <= 64, "Bit width out of range.");
736  return int64_t(x << (64 - B)) >> (64 - B);
737}
738 
739/// Sign-extend the number in the bottom B bits of X to a 64-bit integer.
740/// Requires 0 < B < 64.
741inline int64_t SignExtend64(uint64_t X, unsigned B) {
742  assert(B > 0 && "Bit width can't be 0.")((B > 0 && "Bit width can't be 0.") ? static_cast<
void> (0) : __assert_fail ("B > 0 && \"Bit width can't be 0.\""
, "/build/llvm-toolchain-snapshot-10~svn373386/include/llvm/Support/MathExtras.h"
, 742, __PRETTY_FUNCTION__));
743  assert(B <= 64 && "Bit width out of range.")((B <= 64 && "Bit width out of range.") ? static_cast
<void> (0) : __assert_fail ("B <= 64 && \"Bit width out of range.\""
, "/build/llvm-toolchain-snapshot-10~svn373386/include/llvm/Support/MathExtras.h"
, 743, __PRETTY_FUNCTION__));
744  return int64_t(X << (64 - B)) >> (64 - B);
745}
746 
747/// Subtract two unsigned integers, X and Y, of type T and return the absolute
748/// value of the result.
749template <typename T>
750typename std::enable_if<std::is_unsigned<T>::value, T>::type
751AbsoluteDifference(T X, T Y) {
752  return std::max(X, Y) - std::min(X, Y);
753}
754 
755/// Add two unsigned integers, X and Y, of type T.  Clamp the result to the
756/// maximum representable value of T on overflow.  ResultOverflowed indicates if
757/// the result is larger than the maximum representable value of type T.
758template <typename T>
759typename std::enable_if<std::is_unsigned<T>::value, T>::type
760SaturatingAdd(T X, T Y, bool *ResultOverflowed = nullptr) {
761  bool Dummy;
762  bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
763  // Hacker's Delight, p. 29
764  T Z = X + Y;
765  Overflowed = (Z < X || Z < Y);
766  if (Overflowed)
767    return std::numeric_limits<T>::max();
768  else
769    return Z;
770}
771 
772/// Multiply two unsigned integers, X and Y, of type T.  Clamp the result to the
773/// maximum representable value of T on overflow.  ResultOverflowed indicates if
774/// the result is larger than the maximum representable value of type T.
775template <typename T>
776typename std::enable_if<std::is_unsigned<T>::value, T>::type
777SaturatingMultiply(T X, T Y, bool *ResultOverflowed = nullptr) {
778  bool Dummy;
779  bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
780 
781  // Hacker's Delight, p. 30 has a different algorithm, but we don't use that
782  // because it fails for uint16_t (where multiplication can have undefined
783  // behavior due to promotion to int), and requires a division in addition
784  // to the multiplication.
785 
786  Overflowed = false;
787 
788  // Log2(Z) would be either Log2Z or Log2Z + 1.
789  // Special case: if X or Y is 0, Log2_64 gives -1, and Log2Z
790  // will necessarily be less than Log2Max as desired.
791  int Log2Z = Log2_64(X) + Log2_64(Y);
792  const T Max = std::numeric_limits<T>::max();
793  int Log2Max = Log2_64(Max);
794  if (Log2Z < Log2Max) {
795    return X * Y;
796  }
797  if (Log2Z > Log2Max) {
798    Overflowed = true;
799    return Max;
800  }
801 
802  // We're going to use the top bit, and maybe overflow one
803  // bit past it. Multiply all but the bottom bit then add
804  // that on at the end.
805  T Z = (X >> 1) * Y;
806  if (Z & ~(Max >> 1)) {
807    Overflowed = true;
808    return Max;
809  }
810  Z <<= 1;
811  if (X & 1)
812    return SaturatingAdd(Z, Y, ResultOverflowed);
813 
814  return Z;
815}
816 
817/// Multiply two unsigned integers, X and Y, and add the unsigned integer, A to
818/// the product. Clamp the result to the maximum representable value of T on
819/// overflow. ResultOverflowed indicates if the result is larger than the
820/// maximum representable value of type T.
821template <typename T>
822typename std::enable_if<std::is_unsigned<T>::value, T>::type
823SaturatingMultiplyAdd(T X, T Y, T A, bool *ResultOverflowed = nullptr) {
824  bool Dummy;
825  bool &Overflowed = ResultOverflowed ? *ResultOverflowed : Dummy;
826 
827  T Product = SaturatingMultiply(X, Y, &Overflowed);
828  if (Overflowed)
829    return Product;
830 
831  return SaturatingAdd(A, Product, &Overflowed);
832}
833 
834/// Use this rather than HUGE_VALF; the latter causes warnings on MSVC.
835extern const float huge_valf;
836 
837 
838/// Add two signed integers, computing the two's complement truncated result,
839/// returning true if overflow occured.
840template <typename T>
841typename std::enable_if<std::is_signed<T>::value, T>::type
842AddOverflow(T X, T Y, T &Result) {
843#if __has_builtin(__builtin_add_overflow)1
844  return __builtin_add_overflow(X, Y, &Result);
845#else
846  // Perform the unsigned addition.
847  using U = typename std::make_unsigned<T>::type;
848  const U UX = static_cast<U>(X);
849  const U UY = static_cast<U>(Y);
850  const U UResult = UX + UY;
851 
852  // Convert to signed.
853  Result = static_cast<T>(UResult);
854 
855  // Adding two positive numbers should result in a positive number.
856  if (X > 0 && Y > 0)
857    return Result <= 0;
858  // Adding two negatives should result in a negative number.
859  if (X < 0 && Y < 0)
860    return Result >= 0;
861  return false;
862#endif
863}
864 
865/// Subtract two signed integers, computing the two's complement truncated
866/// result, returning true if an overflow ocurred.
867template <typename T>
868typename std::enable_if<std::is_signed<T>::value, T>::type
869SubOverflow(T X, T Y, T &Result) {
870#if __has_builtin(__builtin_sub_overflow)1
871  return __builtin_sub_overflow(X, Y, &Result);
872#else
873  // Perform the unsigned addition.
874  using U = typename std::make_unsigned<T>::type;
875  const U UX = static_cast<U>(X);
876  const U UY = static_cast<U>(Y);
877  const U UResult = UX - UY;
878 
879  // Convert to signed.
880  Result = static_cast<T>(UResult);
881 
882  // Subtracting a positive number from a negative results in a negative number.
883  if (X <= 0 && Y > 0)
884    return Result >= 0;
885  // Subtracting a negative number from a positive results in a positive number.
886  if (X >= 0 && Y < 0)
887    return Result <= 0;
888  return false;
889#endif
890}
891 
892 
893/// Multiply two signed integers, computing the two's complement truncated
894/// result, returning true if an overflow ocurred.
895template <typename T>
896typename std::enable_if<std::is_signed<T>::value, T>::type
897MulOverflow(T X, T Y, T &Result) {
898  // Perform the unsigned multiplication on absolute values.
899  using U = typename std::make_unsigned<T>::type;
900  const U UX = X < 0 ? (0 - static_cast<U>(X)) : static_cast<U>(X);
901  const U UY = Y < 0 ? (0 - static_cast<U>(Y)) : static_cast<U>(Y);
902  const U UResult = UX * UY;
903 
904  // Convert to signed.
905  const bool IsNegative = (X < 0) ^ (Y < 0);
906  Result = IsNegative ? (0 - UResult) : UResult;
907 
908  // If any of the args was 0, result is 0 and no overflow occurs.
909  if (UX == 0 || UY == 0)
910    return false;
911 
912  // UX and UY are in [1, 2^n], where n is the number of digits.
913  // Check how the max allowed absolute value (2^n for negative, 2^(n-1) for
914  // positive) divided by an argument compares to the other.
915  if (IsNegative)
916    return UX > (static_cast<U>(std::numeric_limits<T>::max()) + U(1)) / UY;
917  else
918    return UX > (static_cast<U>(std::numeric_limits<T>::max())) / UY;
919}
920 
921} // End llvm namespace
922 
923#endif