Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://clang.llvm.org/doxygen/CGObjCGNU_8cpp_source.html below:

clang: lib/CodeGen/CGObjCGNU.cpp Source File

;

CodeGen;

LazyRuntimeFunction {

llvm::FunctionType *FTy =

;

*FunctionName =

;

llvm::FunctionCallee

=

;

LazyRuntimeFunction() =

;

<

... Tys>

init(

*Mod,

*name, llvm::Type *RetTy,

(

...(Tys)) {

FTy = llvm::FunctionType::get(RetTy, ArgTys,

);

FTy = llvm::FunctionType::get(RetTy, {},

);

llvm::FunctionType *getType() {

FTy; }

llvm::FunctionCallee() {

llvm::Module &TheModule;

llvm::StructType *ObjCSuperTy;

llvm::PointerType *PtrToObjCSuperTy;

llvm::PointerType *SelectorTy;

llvm::Type *SelectorElemTy;

llvm::IntegerType *Int8Ty;

llvm::PointerType *PtrToInt8Ty;

llvm::StructType *ProtocolTy;

llvm::PointerType *ProtocolPtrTy;

llvm::PointerType *IMPTy;

llvm::PointerType *IdTy;

llvm::Type *IdElemTy;

llvm::PointerType *PtrToIdTy;

llvm::IntegerType *IntTy;

llvm::PointerType *PtrTy;

llvm::IntegerType *LongTy;

llvm::IntegerType *SizeTy;

llvm::IntegerType *IntPtrTy;

llvm::IntegerType *PtrDiffTy;

llvm::PointerType *PtrToIntTy;

llvm::IntegerType *Int32Ty;

llvm::IntegerType *Int64Ty;

llvm::StructType *PropertyMetadataTy;

msgSendMDKind;

usesSEHExceptions;

usesCxxExceptions;

(R.

() == kind) &&

(R.

() >= VersionTuple(major, minor));

std::string ManglePublicSymbol(StringRef Name) {

(StringRef(CGM.

().isOSBinFormatCOFF() ?

:

) + Name).str();

std::string SymbolForProtocol(Twine Name) {

(ManglePublicSymbol(

) + Name).str();

std::string SymbolForProtocolRef(StringRef Name) {

(ManglePublicSymbol(

) + Name).str();

llvm::Constant *MakeConstantString(StringRef Str,

*Name =

) {

Array.getPointer();

llvm::Constant *ExportUniqueString(

std::string &Str,

std::string &prefix,

Private=

) {

std::string

= prefix + Str;

*ConstStr = TheModule.getGlobalVariable(name);

llvm::Constant *value = llvm::ConstantDataArray::getString(VMContext,Str);

*GV =

llvm::GlobalVariable(TheModule, value->getType(),

,

llvm::GlobalValue::LinkOnceODRLinkage, value, name);

GV->setComdat(TheModule.getOrInsertComdat(name));

GV->setVisibility(llvm::GlobalValue::HiddenVisibility);

*Container) {

std::string NameAndAttributes;

std::string TypeStr =

NameAndAttributes +=

;

NameAndAttributes += TypeStr.length() + 3;

NameAndAttributes += TypeStr;

NameAndAttributes +=

;

MakeConstantString(NameAndAttributes);

attrs =

->getPropertyAttributes();

attrs &= ~ObjCPropertyAttribute::kind_copy;

attrs &= ~ObjCPropertyAttribute::kind_retain;

attrs &= ~ObjCPropertyAttribute::kind_weak;

attrs &= ~ObjCPropertyAttribute::kind_strong;

Fields.addInt(Int8Ty, attrs & 0xff);

attrs |= isSynthesized ? (1<<0) : 0;

attrs |= isDynamic ? (1<<1) : 0;

Fields.addInt(Int8Ty, attrs & 0xff);

Fields.addInt(Int8Ty, 0);

Fields.addInt(Int8Ty, 0);

llvm::Constant *GenerateCategoryProtocolList(

Fields.addInt(IntTy, count);

llvm::DataLayout &DL = TheModule.getDataLayout();

Fields.addInt(IntTy, DL.getTypeSizeInBits(PropertyMetadataTy) /

Fields.

(PropertyMetadataTy);

isSynthesized=

,

Fields = PropertiesArray.

(PropertyMetadataTy);

Fields.add(MakePropertyEncodingString(property, OCD));

PushPropertyAttributes(Fields, property, isSynthesized, isDynamic);

llvm::Constant *TypeEncoding = MakeConstantString(TypeStr);

Fields.add(MakeConstantString(accessor->getSelector().getAsString()));

Fields.add(TypeEncoding);

llvm::Value *EnforceType(

&B, llvm::Value *

, llvm::Type *Ty) {

(

->getType() == Ty)

B.CreateBitCast(

, Ty);

llvm::Constant *Zeros[2];

llvm::Constant *NULLPtr;

llvm::LLVMContext &VMContext;

llvm::GlobalAlias *ClassPtrAlias;

llvm::GlobalAlias *MetaClassPtrAlias;

std::vector<llvm::Constant*> Classes;

std::vector<llvm::Constant*> Categories;

std::vector<llvm::Constant*> ConstantStrings;

llvm::StringMap<llvm::Constant*> ObjCStrings;

llvm::StringMap<llvm::Constant*> ExistingProtocols;

std::pair<std::string, llvm::GlobalAlias*> TypedSelector;

llvm::DenseMap<Selector, SmallVector<TypedSelector, 2> >

RetainSel, ReleaseSel, AutoreleaseSel;

LazyRuntimeFunction IvarAssignFn, StrongCastAssignFn, MemMoveFn, WeakReadFn,

WeakAssignFn, GlobalAssignFn;

std::pair<std::string, std::string> ClassAliasPair;

std::vector<ClassAliasPair> ClassAliases;

LazyRuntimeFunction ExceptionThrowFn;

LazyRuntimeFunction ExceptionReThrowFn;

LazyRuntimeFunction EnterCatchFn;

LazyRuntimeFunction ExitCatchFn;

LazyRuntimeFunction SyncEnterFn;

LazyRuntimeFunction SyncExitFn;

LazyRuntimeFunction EnumerationMutationFn;

LazyRuntimeFunction GetPropertyFn;

LazyRuntimeFunction SetPropertyFn;

LazyRuntimeFunction GetStructPropertyFn;

LazyRuntimeFunction SetStructPropertyFn;

ProtocolVersion;

ClassABIVersion;

llvm::Constant *GenerateMethodList(StringRef ClassName,

StringRef CategoryName,

isClassMethodList);

llvm::Constant *GenerateEmptyProtocol(StringRef ProtocolName);

llvm::Constant *GeneratePropertyList(

*Container,

isClassProperty=

,

protocolOptionalProperties=

);

GenerateProtocolHolderCategory();

llvm::Constant *GenerateClassStructure(

llvm::Constant *MetaClass,

llvm::Constant *SuperClass,

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,

isMeta=

);

llvm::Constant *GenerateProtocolMethodList(

EmitProtocolMethodList(

&&Methods, llvm::Constant *&

,

(

*I : Methods)

OptionalMethods.push_back(I);

RequiredMethods.push_back(I);

= GenerateProtocolMethodList(RequiredMethods);

= GenerateProtocolMethodList(OptionalMethods);

std::string &TypeEncoding);

std::string Name =

+

->getNameAsString()

EmitClassRef(

std::string &className);

std::string &Name,

isWeak);

llvm::Value *&Receiver,

MessageSendInfo &MSI) = 0;

MessageSendInfo &MSI) = 0;

protocolClassVersion,

classABI=1);

llvm::Value *Receiver,

&CallArgs,

isCategoryImpl, llvm::Value *Receiver,

llvm::Constant *GetConstantSelector(

Sel,

std::string &TypeEncoding) {

llvm_unreachable(

);

llvm::DenseMap<const ObjCMethodDecl *, llvm::Function *>

DirectMethodDefinitions;

copy)

;

ClearInsertionPoint=

)

;

AddrWeakObj)

;

llvm::Value *src,

dst)

;

llvm::Value *src,

dest,

threadlocal=

)

;

dest, llvm::Value *ivarOffset)

;

llvm::Value *src,

dest)

;

llvm::Value *Size)

;

CVRQualifiers)

;

CGObjCGCC :

CGObjCGNU {

LazyRuntimeFunction MsgLookupFn;

LazyRuntimeFunction MsgLookupSuperFn;

llvm::Value *cmd, llvm::MDNode *node,

MessageSendInfo &MSI)

{

llvm::Value *args[] = {

EnforceType(Builder, Receiver, IdTy),

EnforceType(Builder, cmd, SelectorTy) };

imp->setMetadata(msgSendMDKind, node);

llvm::Value *cmd, MessageSendInfo &MSI)

{

llvm::Value *lookupArgs[] = {

EnforceType(Builder, ObjCSuper.

(CGF), PtrToObjCSuperTy),

MsgLookupFn.init(&CGM,

, IMPTy, IdTy, SelectorTy);

MsgLookupSuperFn.init(&CGM,

, IMPTy,

PtrToObjCSuperTy, SelectorTy);

CGObjCGNUstep :

CGObjCGNU {

LazyRuntimeFunction SlotLookupFn;

LazyRuntimeFunction SlotLookupSuperFn;

LazyRuntimeFunction SetPropertyAtomic;

LazyRuntimeFunction SetPropertyAtomicCopy;

LazyRuntimeFunction SetPropertyNonAtomic;

LazyRuntimeFunction SetPropertyNonAtomicCopy;

LazyRuntimeFunction CxxAtomicObjectGetFn;

LazyRuntimeFunction CxxAtomicObjectSetFn;

llvm::Type *SlotStructTy;

llvm::Constant *GetEHType(

)

;

llvm::Value *cmd, llvm::MDNode *node,

MessageSendInfo &MSI)

{

llvm::FunctionCallee LookupFn = SlotLookupFn;

Builder.CreateStore(Receiver, ReceiverPtr);

self = llvm::ConstantPointerNull::get(IdTy);

(

*LookupFn2 = dyn_cast<llvm::Function>(LookupFn.getCallee()))

LookupFn2->addParamAttr(

llvm::CaptureInfo::none()));

llvm::Value *args[] = {

EnforceType(Builder, ReceiverPtr.

(), PtrToIdTy),

EnforceType(Builder, cmd, SelectorTy),

EnforceType(Builder, self, IdTy)};

slot->setOnlyReadsMemory();

slot->setMetadata(msgSendMDKind, node);

llvm::Value *imp = Builder.CreateAlignedLoad(

IMPTy, Builder.CreateStructGEP(SlotStructTy, slot, 4),

Receiver = Builder.CreateLoad(ReceiverPtr,

);

MessageSendInfo &MSI)

{

llvm::Value *lookupArgs[] = {ObjCSuper.

(CGF), cmd};

llvm::CallInst *slot =

slot->setOnlyReadsMemory();

Builder.CreateAlignedLoad(

IMPTy, Builder.CreateStructGEP(SlotStructTy, slot, 4),

CGObjCGNUstep(

&Mod) : CGObjCGNUstep(Mod, 9, 3, 1) {}

CGObjCGNUstep(

&Mod,

ABI,

ProtocolABI,

CGObjCGNU(Mod, ABI, ProtocolABI, ClassABI) {

SlotStructTy = llvm::StructType::get(PtrTy, PtrTy, PtrTy, IntTy, IMPTy);

SlotTy = llvm::PointerType::getUnqual(SlotStructTy);

SlotLookupFn.init(&CGM,

, SlotTy, PtrToIdTy,

SlotLookupSuperFn.init(&CGM,

, SlotTy,

PtrToObjCSuperTy, SelectorTy);

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

(usesCxxExceptions) {

EnterCatchFn.init(&CGM,

, PtrTy, PtrTy);

ExitCatchFn.init(&CGM,

, VoidTy);

ExceptionReThrowFn.init(&CGM,

, PtrTy);

}

(usesSEHExceptions) {

ExceptionReThrowFn.init(&CGM,

, VoidTy);

EnterCatchFn.init(&CGM,

, PtrTy, PtrTy);

ExitCatchFn.init(&CGM,

, VoidTy);

ExceptionReThrowFn.init(&CGM,

, VoidTy,

}

(R.

() >= VersionTuple(1, 7)) {

EnterCatchFn.init(&CGM,

, IdTy, PtrTy);

ExitCatchFn.init(&CGM,

, VoidTy);

ExceptionReThrowFn.init(&CGM,

, VoidTy, PtrTy);

SetPropertyAtomic.init(&CGM,

, VoidTy, IdTy,

SelectorTy, IdTy, PtrDiffTy);

SetPropertyAtomicCopy.init(&CGM,

, VoidTy,

IdTy, SelectorTy, IdTy, PtrDiffTy);

SetPropertyNonAtomic.init(&CGM,

, VoidTy,

IdTy, SelectorTy, IdTy, PtrDiffTy);

SetPropertyNonAtomicCopy.init(&CGM,

,

VoidTy, IdTy, SelectorTy, IdTy, PtrDiffTy);

CxxAtomicObjectSetFn.init(&CGM,

, VoidTy, PtrTy,

CxxAtomicObjectGetFn.init(&CGM,

, VoidTy, PtrTy,

llvm::FunctionCallee GetCppAtomicObjectGetFunction()

{

CxxAtomicObjectGetFn;

llvm::FunctionCallee GetCppAtomicObjectSetFunction()

{

CxxAtomicObjectSetFn;

llvm::FunctionCallee GetOptimizedPropertySetFunction(

atomic,

copy)

{

assert ((CGM.

().getGC() == LangOptions::NonGC));

(copy)

SetPropertyAtomicCopy;

SetPropertyAtomic;

copy ? SetPropertyNonAtomicCopy : SetPropertyNonAtomic;

CGObjCGNUstep2 :

CGObjCGNUstep {

ClassReferenceSection,

ProtocolReferenceSection,

ConstantStringSection

ClassFlagMeta = (1 << 0),

ClassFlagInitialized = (1 << 8),

*

SectionsBaseNames[8];

*

PECOFFSectionsBaseNames[8];

<SectionKind K>

std::string sectionName() {

(CGM.

().isOSBinFormatCOFF()) {

std::string

(PECOFFSectionsBaseNames[K]);

SectionsBaseNames[K];

LazyRuntimeFunction MsgLookupSuperFn;

LazyRuntimeFunction SentInitializeFn;

EmittedProtocol =

;

EmittedProtocolRef =

;

EmittedClass =

;

std::pair<std::string, std::pair<llvm::GlobalVariable*, int>>

std::vector<EarlyInitPair> EarlyInitList;

std::string SymbolForClassRef(StringRef Name,

isWeak) {

(ManglePublicSymbol(

) + Name).str();

(ManglePublicSymbol(

) + Name).str();

std::string SymbolForClass(StringRef Name) {

(ManglePublicSymbol(

) + Name).str();

CallRuntimeFunction(

&B, StringRef FunctionName,

(

*Arg : Args)

Types.push_back(Arg->getType());

llvm::FunctionType *FT = llvm::FunctionType::get(B.getVoidTy(), Types,

B.CreateCall(Fn, Args);

llvm::StringMap<llvm::Constant*>::iterator old = ObjCStrings.find(Str);

(old != ObjCStrings.end())

(LiteralLength < 9) && !isNonASCII) {

(

i=0 ; i<LiteralLength ; i++)

str |= ((uint64_t)SL->

(i)) << ((64 - 4 - 3) - (i*7));

str |= LiteralLength << 3;

*ObjCStr = llvm::ConstantExpr::getIntToPtr(

llvm::ConstantInt::get(Int64Ty, str), IdTy);

ObjCStrings[Str] = ObjCStr;

(StringClass.empty()) StringClass =

;

std::string Sym = SymbolForClass(StringClass);

llvm::Constant *

= TheModule.getNamedGlobal(Sym);

=

llvm::GlobalVariable(TheModule, IdTy,

,

llvm::GlobalValue::ExternalLinkage,

, Sym);

(CGM.

().isOSBinFormatCOFF()) {

cast<llvm::GlobalValue>(isa)->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);

Fields = Builder.beginStruct();

(!CGM.

().isOSBinFormatCOFF()) {

Fields.addNullPointer(PtrTy);

NumU8CodeUnits = Str.size();

llvm::UTF8 *FromPtr = (

llvm::UTF8 *)Str.data();

llvm::UTF16 *ToPtr = &ToBuf[0];

(void)llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumU8CodeUnits,

&ToPtr, ToPtr + NumU8CodeUnits, llvm::strictConversion);

StringLength = ToPtr - &ToBuf[0];

Fields.addInt(Int32Ty, 2);

Fields.addInt(Int32Ty, StringLength);

Fields.addInt(Int32Ty, StringLength * 2);

Fields.addInt(Int32Ty, 0);

*

= llvm::ConstantDataArray::get(VMContext, Arr);

*Buffer =

llvm::GlobalVariable(TheModule,

->getType(),

, llvm::GlobalValue::PrivateLinkage,

,

);

Buffer->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);

Fields.addInt(Int32Ty, 0);

Fields.addInt(Int32Ty, Str.size());

Fields.addInt(Int32Ty, Str.size());

Fields.addInt(Int32Ty, 0);

Fields.add(MakeConstantString(Str));

std::string StringName;

StringName =

;

(

i=0,e=Str.size() ; i<e ; ++i) {

= Str[i];

(

==

)

llvm::GlobalVariable *ObjCStrGV =

? StringRef(StringName) :

,

Align,

,

? llvm::GlobalValue::LinkOnceODRLinkage

: llvm::GlobalValue::PrivateLinkage);

ObjCStrGV->setSection(sectionName<ConstantStringSection>());

ObjCStrGV->setComdat(TheModule.getOrInsertComdat(StringName));

ObjCStrGV->setVisibility(llvm::GlobalValue::HiddenVisibility);

(CGM.

().isOSBinFormatCOFF()) {

std::pair<llvm::GlobalVariable*, int>

{ObjCStrGV, 0};

EarlyInitList.emplace_back(Sym,

);

ObjCStrings[Str] = ObjCStrGV;

ConstantStrings.push_back(ObjCStrGV);

isSynthesized=

,

isDynamic=

)

{

Fields = PropertiesArray.

(PropertyMetadataTy);

std::string TypeStr =

Fields.add(MakeConstantString(TypeStr));

std::string typeStr;

Fields.add(MakeConstantString(typeStr));

Fields.add(GetConstantSelector(accessor->getSelector(), TypeStr));

Fields.add(NULLPtr);

llvm::StructType *ObjCMethodDescTy =

{ PtrToInt8Ty, PtrToInt8Ty });

MethodList = Builder.beginStruct();

MethodList.addInt(IntTy, Methods.size());

llvm::DataLayout &DL = TheModule.getDataLayout();

MethodList.addInt(IntTy, DL.getTypeSizeInBits(ObjCMethodDescTy) /

MethodArray = MethodList.beginArray(ObjCMethodDescTy);

(

*M : Methods) {

Method = MethodArray.beginStruct(ObjCMethodDescTy);

Method.add(CGObjCGNU::GetConstantSelector(M));

Method.finishAndAddTo(MethodArray);

MethodArray.finishAndAddTo(MethodList);

MethodList.finishAndCreateGlobal(

,

RuntimeProtocols = GetRuntimeProtocolList(ReferencedProtocols.begin(),

ReferencedProtocols.end());

(

*PI : RuntimeProtocols)

Protocols.push_back(GenerateProtocolRef(PI));

GenerateProtocolList(Protocols);

llvm::Value *cmd, MessageSendInfo &MSI)

{

llvm::Value *lookupArgs[] = {

llvm::GlobalVariable *GetClassVar(StringRef Name,

isWeak=

) {

std::string SymbolName = SymbolForClassRef(Name, isWeak);

*ClassSymbol = TheModule.getNamedGlobal(SymbolName);

ClassSymbol =

llvm::GlobalVariable(TheModule,

IdTy,

, llvm::GlobalValue::ExternalLinkage,

, SymbolName);

ClassSymbol->setInitializer(

llvm::GlobalVariable(TheModule,

Int8Ty,

, llvm::GlobalValue::ExternalWeakLinkage,

, SymbolForClass(Name)));

(CGM.

().isOSBinFormatCOFF()) {

(

*Result : DC->

(&II))

((OID = dyn_cast<ObjCInterfaceDecl>(Result)))

assert(OID &&

);

(OIDDef !=

)

= llvm::GlobalValue::DefaultStorageClass;

(OID->

<DLLImportAttr>())

= llvm::GlobalValue::DLLImportStorageClass;

(OID->

<DLLExportAttr>())

= llvm::GlobalValue::DLLExportStorageClass;

cast<llvm::GlobalValue>(ClassSymbol)->setDLLStorageClass(Storage);

assert(ClassSymbol->getName() == SymbolName);

std::string &Name,

isWeak)

{

(Ownership) {

llvm_unreachable(

);

llvm::Constant *GenerateEmptyProtocol(StringRef ProtocolName)

{

std::string Name = SymbolForProtocol(ProtocolName);

*GV = TheModule.getGlobalVariable(Name);

GV =

llvm::GlobalVariable(TheModule, ProtocolTy,

,

llvm::GlobalValue::ExternalLinkage,

, Name);

llvm::StringMap<llvm::Constant*> ExistingProtocolRefs;

*&Ref = ExistingProtocolRefs[Name];

*&

= ExistingProtocols[Name];

= GenerateProtocolRef(PD);

std::string RefName = SymbolForProtocolRef(Name);

assert(!TheModule.getGlobalVariable(RefName));

GV =

llvm::GlobalVariable(TheModule, ProtocolPtrTy,

,

llvm::GlobalValue::LinkOnceODRLinkage,

GV->setComdat(TheModule.getOrInsertComdat(RefName));

GV->setSection(sectionName<ProtocolReferenceSection>());

EmittedProtocolRef =

;

llvm::ArrayType *ProtocolArrayTy = llvm::ArrayType::get(ProtocolPtrTy,

llvm::Constant * ProtocolArray = llvm::ConstantArray::get(ProtocolArrayTy,

ProtocolBuilder = builder.beginStruct();

ProtocolBuilder.addNullPointer(PtrTy);

ProtocolBuilder.addInt(SizeTy, Protocols.size());

ProtocolBuilder.add(ProtocolArray);

ProtocolBuilder.finishAndCreateGlobal(

,

llvm::Constant *GenerateProtocolRef(

*PD)

{

*&

= ExistingProtocols[ProtocolName];

EmittedProtocol =

;

SymName = SymbolForProtocol(ProtocolName);

*OldGV = TheModule.getGlobalVariable(SymName);

=

llvm::GlobalVariable(TheModule, ProtocolTy,

llvm::GlobalValue::ExternalLinkage,

, SymName);

RuntimeProtocols =

(

*PI : RuntimeProtocols)

Protocols.push_back(GenerateProtocolRef(PI));

llvm::Constant *ProtocolList = GenerateProtocolList(Protocols);

llvm::Constant *InstanceMethodList, *OptionalInstanceMethodList;

llvm::Constant *ClassMethodList, *OptionalClassMethodList;

OptionalInstanceMethodList);

EmitProtocolMethodList(PD->

(), ClassMethodList,

OptionalClassMethodList);

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);

ProtocolBuilder.add(GeneratePropertyList(

, PD,

,

));

ProtocolBuilder.add(GeneratePropertyList(

, PD,

,

));

ProtocolBuilder.add(GeneratePropertyList(

, PD,

,

));

ProtocolBuilder.add(GeneratePropertyList(

, PD,

,

));

*GV = ProtocolBuilder.finishAndCreateGlobal(SymName,

GV->setSection(sectionName<ProtocolSection>());

GV->setComdat(TheModule.getOrInsertComdat(SymName));

OldGV->replaceAllUsesWith(GV);

OldGV->removeFromParent();

GV->setName(SymName);

std::string &TypeEncoding)

{

GetConstantSelector(Sel, TypeEncoding);

std::string GetSymbolNameForTypeEncoding(

std::string &TypeEncoding) {

std::string MangledTypes = std::string(TypeEncoding);

(CGM.

().isOSBinFormatELF())

std::replace(MangledTypes.begin(), MangledTypes.end(),

,

);

std::replace(MangledTypes.begin(), MangledTypes.end(),

,

);

MangledTypes;

llvm::Constant *GetTypeString(llvm::StringRef TypeEncoding) {

(TypeEncoding.empty())

std::string MangledTypes =

GetSymbolNameForTypeEncoding(std::string(TypeEncoding));

std::string TypesVarName =

+ MangledTypes;

*TypesGlobal = TheModule.getGlobalVariable(TypesVarName);

llvm::Constant *

= llvm::ConstantDataArray::getString(VMContext,

*GV =

llvm::GlobalVariable(TheModule,

->getType(),

, llvm::GlobalValue::LinkOnceODRLinkage,

, TypesVarName);

GV->setComdat(TheModule.getOrInsertComdat(TypesVarName));

GV->setVisibility(llvm::GlobalValue::HiddenVisibility);

llvm::Constant *GetConstantSelector(

Sel,

std::string &TypeEncoding)

{

std::string MangledTypes = GetSymbolNameForTypeEncoding(TypeEncoding);

SelVarName = (StringRef(

) + Sel.

() +

+

MangledTypes).str();

(

*GV = TheModule.getNamedGlobal(SelVarName))

SelBuilder = builder.beginStruct();

SelBuilder.add(ExportUniqueString(Sel.

(),

,

SelBuilder.add(GetTypeString(TypeEncoding));

*GV = SelBuilder.finishAndCreateGlobal(SelVarName,

CGM.

(),

, llvm::GlobalValue::LinkOnceODRLinkage);

GV->setComdat(TheModule.getOrInsertComdat(SelVarName));

GV->setVisibility(llvm::GlobalValue::HiddenVisibility);

GV->setSection(sectionName<SelectorSection>());

llvm::StructType *emptyStruct =

;

std::pair<llvm::Constant*,llvm::Constant*>

GetSectionBounds(StringRef Section) {

(CGM.

().isOSBinFormatCOFF()) {

(emptyStruct ==

) {

emptyStruct = llvm::StructType::create(

VMContext, {},

,

);

ZeroInit = llvm::Constant::getNullValue(emptyStruct);

Sym = [&](StringRef Prefix, StringRef SecSuffix) {

*Sym =

llvm::GlobalVariable(TheModule, emptyStruct,

llvm::GlobalValue::LinkOnceODRLinkage, ZeroInit, Prefix +

Sym->setVisibility(llvm::GlobalValue::HiddenVisibility);

Sym->setSection((Section + SecSuffix).str());

Sym->setComdat(TheModule.getOrInsertComdat((Prefix +

{ Sym(

,

), Sym(

,

) };

*Start =

llvm::GlobalVariable(TheModule, PtrTy,

llvm::GlobalValue::ExternalLinkage,

, StringRef(

) +

Start->setVisibility(llvm::GlobalValue::HiddenVisibility);

*Stop =

llvm::GlobalVariable(TheModule, PtrTy,

llvm::GlobalValue::ExternalLinkage,

, StringRef(

) +

Stop->setVisibility(llvm::GlobalValue::HiddenVisibility);

{ Start, Stop };

llvm::Function *ModuleInitFunction()

{

llvm::Function *LoadFunction = llvm::Function::Create(

llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),

),

llvm::GlobalValue::LinkOnceODRLinkage,

,

LoadFunction->setVisibility(llvm::GlobalValue::HiddenVisibility);

LoadFunction->setComdat(TheModule.getOrInsertComdat(

));

llvm::BasicBlock *EntryBB =

llvm::BasicBlock::Create(VMContext,

, LoadFunction);

B.SetInsertPoint(EntryBB);

InitStructBuilder = builder.beginStruct();

InitStructBuilder.addInt(Int64Ty, 0);

&sectionVec = CGM.

().isOSBinFormatCOFF() ? PECOFFSectionsBaseNames : SectionsBaseNames;

(

*

: sectionVec) {

bounds = GetSectionBounds(

);

InitStructBuilder.add(bounds.first);

InitStructBuilder.add(bounds.second);

*InitStruct = InitStructBuilder.finishAndCreateGlobal(

,

CGM.

(),

, llvm::GlobalValue::LinkOnceODRLinkage);

InitStruct->setVisibility(llvm::GlobalValue::HiddenVisibility);

InitStruct->setComdat(TheModule.getOrInsertComdat(

));

CallRuntimeFunction(B,

, {InitStruct});;

*InitVar =

llvm::GlobalVariable(TheModule, LoadFunction->getType(),

, llvm::GlobalValue::LinkOnceAnyLinkage,

LoadFunction,

);

assert(InitVar->getName() ==

);

(CGM.

().isOSBinFormatCOFF())

InitVar->setSection(

);

InitVar->setSection(

);

InitVar->setSection(

);

InitVar->setVisibility(llvm::GlobalValue::HiddenVisibility);

InitVar->setComdat(TheModule.getOrInsertComdat(

));

(

*

: Categories) {

*Cat = cast<llvm::GlobalVariable>(

->stripPointerCasts());

Cat->setSection(sectionName<CategorySection>());

StringRef Section) {

nullBuilder = builder.beginStruct();

(

*F :

)

GV = nullBuilder.finishAndCreateGlobal(Name, CGM.

(),

, llvm::GlobalValue::LinkOnceODRLinkage);

GV->setSection(Section);

GV->setComdat(TheModule.getOrInsertComdat(Name));

GV->setVisibility(llvm::GlobalValue::HiddenVisibility);

(

clsAlias : ClassAliases)

createNullGlobal(std::string(

) +

clsAlias.second, { MakeConstantString(clsAlias.second),

GetClassVar(clsAlias.first) }, sectionName<ClassAliasSection>());

(!CGM.

().isOSBinFormatCOFF()) {

createNullGlobal(

, {NULLPtr, NULLPtr},

sectionName<SelectorSection>());

(Categories.empty())

createNullGlobal(

, {NULLPtr, NULLPtr,

NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr},

sectionName<CategorySection>());

(!EmittedClass) {

createNullGlobal(

, NULLPtr,

sectionName<ClassSection>());

createNullGlobal(

, { NULLPtr, NULLPtr },

sectionName<ClassReferenceSection>());

(!EmittedProtocol)

createNullGlobal(

, {NULLPtr, NULLPtr, NULLPtr,

NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr,

NULLPtr}, sectionName<ProtocolSection>());

(!EmittedProtocolRef)

createNullGlobal(

, {NULLPtr},

sectionName<ProtocolReferenceSection>());

(ClassAliases.empty())

createNullGlobal(

, { NULLPtr, NULLPtr },

sectionName<ClassAliasSection>());

(ConstantStrings.empty()) {

i32Zero = llvm::ConstantInt::get(Int32Ty, 0);

createNullGlobal(

, { NULLPtr, i32Zero,

i32Zero, i32Zero, i32Zero, NULLPtr },

sectionName<ConstantStringSection>());

ConstantStrings.clear();

(EarlyInitList.size() > 0) {

*

= llvm::Function::Create(llvm::FunctionType::get(CGM.

,

{}), llvm::GlobalValue::InternalLinkage,

,

llvm::IRBuilder<>

(llvm::BasicBlock::Create(CGM.

(),

,

(

&lateInit : EarlyInitList) {

*global = TheModule.getGlobalVariable(lateInit.first);

llvm::GlobalVariable *GV = lateInit.second.first;

.CreateAlignedStore(

.CreateStructGEP(GV->getValueType(), GV, lateInit.second.second),

*InitVar =

llvm::GlobalVariable(CGM.

(),

->getType(),

, llvm::GlobalValue::InternalLinkage,

,

);

InitVar->setSection(

);

std::string TypeEncoding;

TypeEncoding = GetSymbolNameForTypeEncoding(TypeEncoding);

std::string Name =

+

->getNameAsString()

std::string Name =

GetIVarOffsetVariableName(ContainingInterface, Ivar);

llvm::GlobalVariable *IvarOffsetPointer = TheModule.getNamedGlobal(Name);

(!IvarOffsetPointer) {

IvarOffsetPointer =

llvm::GlobalVariable(TheModule, IntTy,

,

llvm::GlobalValue::ExternalLinkage,

, Name);

llvm::Value *Offset =

(Offset->getType() != PtrDiffTy)

Offset = CGF.

.CreateZExtOrBitCast(Offset, PtrDiffTy);

IsCOFF = CGM.

().isOSBinFormatCOFF();

*classNameConstant = MakeConstantString(className);

metaclassFields = builder.beginStruct();

metaclassFields.addNullPointer(PtrTy);

metaclassFields.addNullPointer(PtrTy);

metaclassFields.add(classNameConstant);

metaclassFields.addInt(LongTy, 0);

metaclassFields.addInt(LongTy, ClassFlags::ClassFlagMeta);

metaclassFields.addInt(LongTy, 0);

metaclassFields.addNullPointer(PtrTy);

metaclassFields.addNullPointer(PtrTy);

metaclassFields.add(

GenerateMethodList(className,

, ClassMethods,

));

metaclassFields.addNullPointer(PtrTy);

metaclassFields.addNullPointer(PtrTy);

metaclassFields.addNullPointer(PtrTy);

metaclassFields.addNullPointer(PtrTy);

metaclassFields.addNullPointer(PtrTy);

metaclassFields.addNullPointer(PtrTy);

metaclassFields.addNullPointer(PtrTy);

metaclassFields.addInt(LongTy, 0);

metaclassFields.add(GeneratePropertyList(OID, classDecl,

));

*metaclass = metaclassFields.finishAndCreateGlobal(

ManglePublicSymbol(

) + className,

classFields = builder.beginStruct();

classFields.add(metaclass);

llvm::Constant *SuperClass =

;

(SuperClassDecl) {

SuperClassName = SymbolForClass(SuperClassDecl->

());

SuperClass = TheModule.getNamedGlobal(SuperClassName);

SuperClass =

llvm::GlobalVariable(TheModule, PtrTy,

,

llvm::GlobalValue::ExternalLinkage,

, SuperClassName);

= llvm::GlobalValue::DefaultStorageClass;

(SuperClassDecl->

<DLLImportAttr>())

= llvm::GlobalValue::DLLImportStorageClass;

(SuperClassDecl->

<DLLExportAttr>())

= llvm::GlobalValue::DLLExportStorageClass;

cast<llvm::GlobalValue>(SuperClass)->setDLLStorageClass(Storage);

classFields.add(SuperClass);

classFields.addNullPointer(PtrTy);

classFields.addNullPointer(PtrTy);

classFields.add(classNameConstant);

classFields.addInt(LongTy, 0);

classFields.addInt(LongTy, 0);

superInstanceSize = !SuperClassDecl ? 0 :

classFields.addInt(LongTy,

superInstanceSize));

classFields.addNullPointer(PtrTy);

llvm::DataLayout &DL = TheModule.getDataLayout();

ivarListBuilder =

.beginStruct();

ivarListBuilder.addInt(IntTy, ivar_count);

llvm::StructType *ObjCIvarTy = llvm::StructType::get(

ivarListBuilder.addInt(SizeTy, DL.getTypeSizeInBits(ObjCIvarTy) /

ivarArrayBuilder = ivarListBuilder.beginArray();

ivarTy = IVD->getType();

ivarBuilder = ivarArrayBuilder.beginStruct();

ivarBuilder.add(MakeConstantString(IVD->getNameAsString()));

std::string TypeStr;

ivarBuilder.add(MakeConstantString(TypeStr));

BaseOffset = ComputeIvarBaseOffset(CGM, OID, IVD);

Offset = BaseOffset - superInstanceSize;

llvm::Constant *OffsetValue = llvm::ConstantInt::get(IntTy, Offset);

std::string OffsetName = GetIVarOffsetVariableName(classDecl, IVD);

llvm::GlobalVariable *OffsetVar = TheModule.getGlobalVariable(OffsetName);

OffsetVar->setInitializer(OffsetValue);

OffsetVar =

llvm::GlobalVariable(TheModule, IntTy,

, llvm::GlobalValue::ExternalLinkage,

OffsetValue, OffsetName);

ivarVisibility =

llvm::GlobalValue::HiddenVisibility :

llvm::GlobalValue::DefaultVisibility;

OffsetVar->setVisibility(ivarVisibility);

(ivarVisibility != llvm::GlobalValue::HiddenVisibility)

ivarBuilder.add(OffsetVar);

ivarBuilder.addInt(Int32Ty,

ivarBuilder.addInt(Int32Ty,

(align << 3) | (1<<2) |

FlagsForOwnership(ivarTy.getQualifiers().getObjCLifetime()));

ivarBuilder.finishAndAddTo(ivarArrayBuilder);

ivarArrayBuilder.finishAndAddTo(ivarListBuilder);

ivarList = ivarListBuilder.finishAndCreateGlobal(

,

llvm::GlobalValue::PrivateLinkage);

classFields.add(ivarList);

InstanceMethods.insert(InstanceMethods.begin(), OID->

(),

(propImpl->getPropertyImplementation() ==

(OMD && OMD->hasBody())

InstanceMethods.push_back(OMD);

addIfExists(propImpl->getGetterMethodDecl());

addIfExists(propImpl->getSetterMethodDecl());

(InstanceMethods.size() == 0)

classFields.addNullPointer(PtrTy);

GenerateMethodList(className,

, InstanceMethods,

));

classFields.addNullPointer(PtrTy);

classFields.addNullPointer(PtrTy);

classFields.addNullPointer(PtrTy);

classFields.addNullPointer(PtrTy);

classFields.addNullPointer(PtrTy);

RuntimeProtocols = GetRuntimeProtocolList(classDecl->

(),

(

*I : RuntimeProtocols)

Protocols.push_back(GenerateProtocolRef(I));

(Protocols.empty())

classFields.addNullPointer(PtrTy);

classFields.add(GenerateProtocolList(Protocols));

classFields.addNullPointer(PtrTy);

classFields.addInt(LongTy, 0);

classFields.add(GeneratePropertyList(OID, classDecl));

llvm::GlobalVariable *classStruct =

classFields.finishAndCreateGlobal(SymbolForClass(className),

*classRefSymbol = GetClassVar(className);

classRefSymbol->setSection(sectionName<ClassReferenceSection>());

classRefSymbol->setInitializer(classStruct);

classStruct->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);

cast<llvm::GlobalValue>(classRefSymbol)->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);

std::pair<llvm::GlobalVariable*, int>

{classStruct, 1};

EarlyInitList.emplace_back(std::string(SuperClass->getName()),

(ClassPtrAlias) {

ClassPtrAlias->replaceAllUsesWith(classStruct);

ClassPtrAlias->eraseFromParent();

ClassPtrAlias =

;

(

Placeholder =

TheModule.getNamedGlobal(SymbolForClass(className)))

(Placeholder != classStruct) {

Placeholder->replaceAllUsesWith(classStruct);

Placeholder->eraseFromParent();

classStruct->setName(SymbolForClass(className));

(MetaClassPtrAlias) {

MetaClassPtrAlias->replaceAllUsesWith(metaclass);

MetaClassPtrAlias->eraseFromParent();

MetaClassPtrAlias =

;

assert(classStruct->getName() == SymbolForClass(className));

classInitRef =

llvm::GlobalVariable(TheModule,

classStruct->getType(),

, llvm::GlobalValue::ExternalLinkage,

classStruct, ManglePublicSymbol(

) + className);

classInitRef->setSection(sectionName<ClassSection>());

EmittedClass =

;

CGObjCGNUstep2(

&Mod) : CGObjCGNUstep(Mod, 10, 4, 2) {

MsgLookupSuperFn.init(&CGM,

, IMPTy,

PtrToObjCSuperTy, SelectorTy);

SentInitializeFn.init(&CGM,

,

llvm::Type::getVoidTy(VMContext), IdTy);

PropertyMetadataTy =

{ PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty });

GenerateDirectMethodPrologue(

&CGF, llvm::Function *Fn,

&Builder = CGF.

;

ReceiverCanBeNull =

;

selfValue = Builder.CreateLoad(selfAddr);

ReceiverCanBeNull = isWeakLinkedClass(OID);

(ReceiverCanBeNull) {

llvm::BasicBlock *SelfIsNilBlock =

llvm::BasicBlock *ContBlock =

selfTy = cast<llvm::PointerType>(selfValue->getType());

= llvm::ConstantPointerNull::get(selfTy);

Builder.CreateCondBr(Builder.CreateICmpEQ(selfValue, Zero),

SelfIsNilBlock, ContBlock,

MDHelper.createUnlikelyBranchWeights());

Builder.SetInsertPoint(SelfIsNilBlock);

(!retTy->isVoidType()) {

Builder.SetInsertPoint(ContBlock);

llvm::StructType::get(PtrTy, PtrTy, PtrTy, LongTy, LongTy);

llvm::Value *Val = Builder.CreateStructGEP(classStart, selfValue, 4);

astContext.getTypeAlign(astContext.UnsignedLongTy));

flags = Builder.CreateLoad(

{Val, LongTy, Align});

isInitialized =

Builder.CreateAnd(flags, ClassFlags::ClassFlagInitialized);

llvm::BasicBlock *notInitializedBlock =

llvm::BasicBlock *initializedBlock =

Builder.CreateCondBr(Builder.CreateICmpEQ(isInitialized, Zeros[0]),

notInitializedBlock, initializedBlock,

MDHelper.createUnlikelyBranchWeights());

Builder.SetInsertPoint(notInitializedBlock);

Builder.CreateBr(initializedBlock);

Builder.SetInsertPoint(initializedBlock);

Builder.CreateStore(GetSelector(CGF, OMD),

*

CGObjCGNUstep2::SectionsBaseNames[8] =

,

,

,

*

CGObjCGNUstep2::PECOFFSectionsBaseNames[8] =

CGObjCObjFW:

CGObjCGNU {

LazyRuntimeFunction MsgLookupFn;

LazyRuntimeFunction MsgLookupFnSRet;

LazyRuntimeFunction MsgLookupSuperFn, MsgLookupSuperFnSRet;

llvm::Value *cmd, llvm::MDNode *node,

MessageSendInfo &MSI)

{

llvm::Value *args[] = {

EnforceType(Builder, Receiver, IdTy),

EnforceType(Builder, cmd, SelectorTy) };

llvm::CallBase *imp;

imp->setMetadata(msgSendMDKind, node);

llvm::Value *cmd, MessageSendInfo &MSI)

{

llvm::Value *lookupArgs[] = {

EnforceType(Builder, ObjCSuper.

(CGF), PtrToObjCSuperTy),

llvm::Value *GetClassNamed(

&CGF,

std::string &Name,

isWeak)

{

CGObjCGNU::GetClassNamed(CGF, Name, isWeak);

std::string SymbolName =

+ Name;

llvm::GlobalVariable *ClassSymbol = TheModule.getGlobalVariable(SymbolName);

ClassSymbol =

llvm::GlobalVariable(TheModule, LongTy,

,

llvm::GlobalValue::ExternalLinkage,

, SymbolName);

MsgLookupFn.init(&CGM,

, IMPTy, IdTy, SelectorTy);

MsgLookupFnSRet.init(&CGM,

, IMPTy, IdTy,

MsgLookupSuperFn.init(&CGM,

, IMPTy,

PtrToObjCSuperTy, SelectorTy);

MsgLookupSuperFnSRet.init(&CGM,

, IMPTy,

PtrToObjCSuperTy, SelectorTy);

CGObjCGNU::EmitClassRef(

std::string &className) {

std::string symbolRef =

+ className;

(TheModule.getGlobalVariable(symbolRef))

std::string symbolName =

+ className;

llvm::GlobalVariable *ClassSymbol = TheModule.getGlobalVariable(symbolName);

ClassSymbol =

llvm::GlobalVariable(TheModule, LongTy,

,

llvm::GlobalValue::ExternalLinkage,

, symbolName);

llvm::GlobalVariable(TheModule, ClassSymbol->getType(),

,

llvm::GlobalValue::WeakAnyLinkage, ClassSymbol, symbolRef);

CGObjCGNU::CGObjCGNU(

&cgm,

runtimeABIVersion,

protocolClassVersion,

classABI)

VMContext(cgm.getLLVMContext()), ClassPtrAlias(nullptr),

MetaClassPtrAlias(nullptr), RuntimeVersion(runtimeABIVersion),

ProtocolVersion(protocolClassVersion), ClassABIVersion(classABI) {

msgSendMDKind = VMContext.getMDKindID(

);

IntTy = cast<llvm::IntegerType>(

LongTy = cast<llvm::IntegerType>(

SizeTy = cast<llvm::IntegerType>(

PtrDiffTy = cast<llvm::IntegerType>(

Int8Ty = llvm::Type::getInt8Ty(VMContext);

PtrToInt8Ty = llvm::PointerType::getUnqual(Int8Ty);

ProtocolPtrTy = llvm::PointerType::getUnqual(

Zeros[0] = llvm::ConstantInt::get(LongTy, 0);

Zeros[1] = Zeros[0];

NULLPtr = llvm::ConstantPointerNull::get(PtrToInt8Ty);

SelectorTy = PtrToInt8Ty;

SelectorElemTy = Int8Ty;

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

PtrTy = PtrToInt8Ty;

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

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

CGM.

().getPointerSizeInBits() == 32 ? Int32Ty : Int64Ty;

PtrToIdTy = llvm::PointerType::getUnqual(IdTy);

ProtocolTy = llvm::StructType::get(IdTy,

PropertyMetadataTy = llvm::StructType::get(CGM.

(), {

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);

ExceptionThrowFn.init(&CGM,

, VoidTy, IdTy);

ExceptionReThrowFn.init(&CGM,

usesCxxExceptions ?

:

,

SyncEnterFn.init(&CGM,

, IntTy, IdTy);

SyncExitFn.init(&CGM,

, IntTy, IdTy);

EnumerationMutationFn.init(&CGM,

, VoidTy, IdTy);

GetPropertyFn.init(&CGM,

, IdTy, IdTy, SelectorTy,

SetPropertyFn.init(&CGM,

, VoidTy, IdTy, SelectorTy,

PtrDiffTy, IdTy, BoolTy, BoolTy);

GetStructPropertyFn.init(&CGM,

, VoidTy, PtrTy, PtrTy,

PtrDiffTy, BoolTy, BoolTy);

SetStructPropertyFn.init(&CGM,

, VoidTy, PtrTy, PtrTy,

PtrDiffTy, BoolTy, BoolTy);

llvm::Type *IMPArgs[] = { IdTy, SelectorTy };

IMPTy = llvm::PointerType::getUnqual(llvm::FunctionType::get(IdTy, IMPArgs,

((Opts.getGC() != LangOptions::NonGC) || Opts.ObjCAutoRefCount)

RuntimeVersion = 10;

(Opts.getGC() != LangOptions::NonGC) {

IvarAssignFn.init(&CGM,

, IdTy, IdTy, IdTy, PtrDiffTy);

StrongCastAssignFn.init(&CGM,

, IdTy, IdTy,

GlobalAssignFn.init(&CGM,

, IdTy, IdTy, PtrToIdTy);

WeakAssignFn.init(&CGM,

, IdTy, IdTy, PtrToIdTy);

WeakReadFn.init(&CGM,

, IdTy, PtrToIdTy);

MemMoveFn.init(&CGM,

, PtrTy, PtrTy, PtrTy,

std::string &Name,

isWeak) {

llvm::Constant *ClassName = MakeConstantString(Name);

llvm::FunctionType::get(IdTy, PtrToInt8Ty,

),

);

(

*ClassSymbol = dyn_cast<llvm::GlobalVariable>(

))

llvm::Value *CGObjCGNU::EmitNSAutoreleasePoolClassRef(

&CGF) {

*

= GetClassNamed(CGF,

,

);

(CGM.

().isOSBinFormatCOFF()) {

(

*ClassSymbol = dyn_cast<llvm::GlobalVariable>(

)) {

(

*Result : DC->

(&II))

((VD = dyn_cast<VarDecl>(Result)))

std::string &TypeEncoding) {

llvm::GlobalAlias *SelValue =

;

e = Types.end() ; i!=e ; i++) {

(i->first == TypeEncoding) {

SelValue = i->second;

SelValue = llvm::GlobalAlias::create(SelectorElemTy, 0,

llvm::GlobalValue::PrivateLinkage,

Types.emplace_back(TypeEncoding, SelValue);

llvm::Value *SelValue = GetSelector(CGF, Sel);

GetTypedSelector(CGF, Sel, std::string());

GetTypedSelector(CGF, Method->

(), SelTypes);

llvm::Constant *CGObjCGNU::GetEHType(

) {

MakeConstantString(

);

assert(OPT &&

);

assert(IDecl &&

);

llvm::Constant *CGObjCGNUstep::GetEHType(

) {

(usesSEHExceptions)

(!CGM.

().CPlusPlus && !usesCxxExceptions)

CGObjCGNU::GetEHType(

);

llvm::Constant *IDEHType =

CGM.

().getGlobalVariable(

);

llvm::GlobalVariable(CGM.

(), PtrToInt8Ty,

llvm::GlobalValue::ExternalLinkage,

,

);

assert(PT &&

);

assert(IT &&

);

std::string className =

std::string typeinfoName =

+ className;

(llvm::Constant *typeinfo = TheModule.getGlobalVariable(typeinfoName))

*vtableName =

;

*Vtable = TheModule.getGlobalVariable(vtableName);

Vtable =

llvm::GlobalVariable(TheModule, PtrToInt8Ty,

,

llvm::GlobalValue::ExternalLinkage,

, vtableName);

llvm::Constant *Two = llvm::ConstantInt::get(IntTy, 2);

llvm::ConstantExpr::getGetElementPtr(Vtable->getValueType(), Vtable, Two);

llvm::Constant *typeName =

ExportUniqueString(className,

);

fields = builder.beginStruct();

fields.add(BVtable);

fields.add(typeName);

llvm::Constant *TI =

fields.finishAndCreateGlobal(

+ className,

llvm::GlobalValue::LinkOnceODRLinkage);

std::string Str = SL->

().str();

llvm::StringMap<llvm::Constant*>::iterator old = ObjCStrings.find(Str);

(old != ObjCStrings.end())

(StringClass.empty()) StringClass =

;

std::string Sym =

;

llvm::Constant *

= TheModule.getNamedGlobal(Sym);

=

llvm::GlobalVariable(TheModule, IdTy,

,

llvm::GlobalValue::ExternalWeakLinkage,

Fields = Builder.beginStruct();

Fields.add(MakeConstantString(Str));

Fields.addInt(IntTy, Str.size());

ObjCStrings[Str] = ObjCStr;

ConstantStrings.push_back(ObjCStr);

isCategoryImpl,

llvm::Value *Receiver,

IsClassMessage,

(CGM.

().getGC() == LangOptions::GCOnly) {

(Sel == RetainSel || Sel == AutoreleaseSel) {

(EnforceType(Builder, Receiver,

(Sel == ReleaseSel) {

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

ActualArgs.

(

(EnforceType(Builder, Receiver, IdTy)), ASTIdTy);

ActualArgs.

(CallArgs);

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

llvm::Value *ReceiverClass =

;

ReceiverClass = GetClassNamed(CGF,

->getSuperClass()->getNameAsString(),

);

(IsClassMessage) {

ReceiverClass = Builder.CreateBitCast(ReceiverClass,

llvm::PointerType::getUnqual(IdTy));

Builder.CreateAlignedLoad(IdTy, ReceiverClass, CGF.

());

ReceiverClass = EnforceType(Builder, ReceiverClass, IdTy);

(isCategoryImpl) {

llvm::FunctionCallee classLookupFunction =

;

(IsClassMessage) {

IdTy, PtrTy,

),

);

IdTy, PtrTy,

),

);

ReceiverClass = Builder.CreateCall(classLookupFunction,

MakeConstantString(

->getNameAsString()));

(IsClassMessage) {

(!MetaClassPtrAlias) {

MetaClassPtrAlias = llvm::GlobalAlias::create(

IdElemTy, 0, llvm::GlobalValue::InternalLinkage,

+

->getNameAsString(), &TheModule);

ReceiverClass = MetaClassPtrAlias;

(!ClassPtrAlias) {

ClassPtrAlias = llvm::GlobalAlias::create(

IdElemTy, 0, llvm::GlobalValue::InternalLinkage,

+

->getNameAsString(), &TheModule);

ReceiverClass = ClassPtrAlias;

llvm::Type *CastTy = llvm::StructType::get(IdTy, IdTy);

ReceiverClass = Builder.CreateBitCast(ReceiverClass,

llvm::PointerType::getUnqual(CastTy));

ReceiverClass = Builder.CreateStructGEP(CastTy, ReceiverClass, 1);

Builder.CreateAlignedLoad(IdTy, ReceiverClass, CGF.

());

llvm::StructType *ObjCSuperTy =

llvm::StructType::get(Receiver->getType(), IdTy);

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

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

llvm::Value *imp = LookupIMPSuper(CGF, ObjCSuper, cmd, MSI);

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

llvm::Metadata *impMD[] = {

llvm::MDString::get(VMContext, Sel.

()),

llvm::MDString::get(VMContext,

->getSuperClass()->getNameAsString()),

llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(

llvm::Type::getInt1Ty(VMContext), IsClassMessage))};

llvm::MDNode *

= llvm::MDNode::get(VMContext, impMD);

llvm::CallBase *call;

msgRet = CGF.

(MSI.CallInfo, callee, Return, ActualArgs, &call);

call->setMetadata(msgSendMDKind, node);

llvm::Value *Receiver,

(CGM.

().getGC() == LangOptions::GCOnly) {

(Sel == RetainSel || Sel == AutoreleaseSel) {

(EnforceType(Builder, Receiver,

(Sel == ReleaseSel) {

cmd = GetSelector(CGF, Method);

cmd = GetSelector(CGF, Sel);

cmd = EnforceType(Builder, cmd, SelectorTy);

Receiver = EnforceType(Builder, Receiver, IdTy);

llvm::Metadata *impMD[] = {

llvm::MDString::get(VMContext, Sel.

()),

llvm::MDString::get(VMContext, Class ?

->getNameAsString() :

),

llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(

llvm::Type::getInt1Ty(VMContext), Class !=

))};

llvm::MDNode *

= llvm::MDNode::get(VMContext, impMD);

ActualArgs.

(CallArgs);

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

hasParamDestroyedInCallee =

;

requiresExplicitZeroResult =

;

requiresNilReceiverCheck = [&] {

(!canMessageReceiverBeNull(CGF, Method,

,

hasParamDestroyedInCallee =

;

requiresExplicitZeroResult = !isDirect;

hasParamDestroyedInCallee || requiresExplicitZeroResult;

requiresExplicitAggZeroing =

llvm::BasicBlock *continueBB =

;

llvm::BasicBlock *nilPathBB =

;

llvm::BasicBlock *nilCleanupBB =

;

(requiresNilReceiverCheck) {

(requiresExplicitAggZeroing || hasParamDestroyedInCallee) {

nilPathBB = Builder.GetInsertBlock();

llvm::Value *isNil = Builder.CreateICmpEQ(Receiver,

llvm::Constant::getNullValue(Receiver->getType()));

Builder.CreateCondBr(isNil, nilCleanupBB ? nilCleanupBB : continueBB,

imp = LookupIMP(CGF, Receiver, cmd, node, MSI);

StringRef

=

;

=

;

=

;

shouldCheckForInReg =

.isWindowsMSVCEnvironment() &&

=

;

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

llvm::CallBase *call;

msgRet = CGF.

(MSI.CallInfo, callee, Return, ActualArgs, &call);

call->setMetadata(msgSendMDKind, node);

(requiresNilReceiverCheck) {

llvm::BasicBlock *nonNilPathBB = CGF.

.GetInsertBlock();

CGF.

.CreateBr(continueBB);

(hasParamDestroyedInCallee) {

destroyCalleeDestroyedArguments(CGF, Method, CallArgs);

(requiresExplicitAggZeroing) {

nilPathBB = CGF.

.GetInsertBlock();

CGF.

.CreateBr(continueBB);

llvm::PHINode *phi = Builder.CreatePHI(

->getType(), 2);

phi->addIncoming(

, nonNilPathBB);

std::pair<llvm::Value*,llvm::Value*>

= msgRet.

();

llvm::PHINode *phi = Builder.CreatePHI(

.first->getType(), 2);

phi->addIncoming(

.first, nonNilPathBB);

phi->addIncoming(llvm::Constant::getNullValue(

.first->getType()),

llvm::PHINode *phi2 = Builder.CreatePHI(

.second->getType(), 2);

phi2->addIncoming(

.second, nonNilPathBB);

phi2->addIncoming(llvm::Constant::getNullValue(

.second->getType()),

llvm::Constant *CGObjCGNU::

GenerateMethodList(StringRef ClassName,

StringRef CategoryName,

isClassMethodList) {

(Methods.empty())

MethodList = Builder.beginStruct();

MethodList.addNullPointer(CGM.

);

MethodList.addInt(Int32Ty, Methods.size());

llvm::StructType *ObjCMethodTy =

llvm::DataLayout &DL = TheModule.getDataLayout();

MethodList.addInt(SizeTy, DL.getTypeSizeInBits(ObjCMethodTy) /

MethodArray = MethodList.beginArray();

(

*OMD : Methods) {

llvm::Constant *FnPtr =

TheModule.getFunction(getSymbolNameForMethod(OMD));

assert(FnPtr &&

);

Method = MethodArray.beginStruct(ObjCMethodTy);

Method.

(FnPtr);

Method.

(FnPtr);

Method.finishAndAddTo(MethodArray);

MethodArray.finishAndAddTo(MethodList);

MethodList.finishAndCreateGlobal(

,

llvm::Constant *CGObjCGNU::

(IvarNames.empty())

IvarList = Builder.beginStruct();

IvarList.addInt(IntTy, (

)IvarNames.size());

llvm::StructType *ObjCIvarTy =

llvm::StructType::get(PtrToInt8Ty, PtrToInt8Ty, IntTy);

Ivars = IvarList.beginArray(ObjCIvarTy);

(

i = 0, e = IvarNames.size() ; i < e ; i++) {

Ivar = Ivars.beginStruct(ObjCIvarTy);

Ivar.

(IvarNames[i]);

Ivar.

(IvarTypes[i]);

Ivar.

(IvarOffsets[i]);

Ivar.finishAndAddTo(Ivars);

Ivars.finishAndAddTo(IvarList);

IvarList.finishAndCreateGlobal(

,

llvm::Constant *CGObjCGNU::GenerateClassStructure(

llvm::Constant *MetaClass,

llvm::Constant *SuperClass,

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,

llvm::StructType *ClassTy = llvm::StructType::get(

IvarOffsets->getType(),

Properties->getType(),

Elements = Builder.beginStruct(ClassTy);

Elements.add(MetaClass);

Elements.add(SuperClass);

Elements.add(MakeConstantString(Name,

));

Elements.addInt(LongTy, 0);

Elements.addInt(LongTy, info);

llvm::DataLayout &DL = TheModule.getDataLayout();

Elements.addInt(LongTy, DL.getTypeSizeInBits(ClassTy) /

Elements.add(InstanceSize);

Elements.add(IVars);

Elements.add(Methods);

Elements.add(NULLPtr);

Elements.add(NULLPtr);

Elements.add(NULLPtr);

Elements.add(Protocols);

Elements.add(NULLPtr);

Elements.addInt(LongTy, ClassABIVersion);

Elements.add(IvarOffsets);

Elements.add(Properties);

Elements.add(StrongIvarBitmap);

Elements.add(WeakIvarBitmap);

std::string ClassSym((isMeta ?

:

) +

llvm::GlobalVariable *ClassRef = TheModule.getNamedGlobal(ClassSym);

llvm::Constant *

=

Elements.finishAndCreateGlobal(ClassSym, CGM.

(),

,

llvm::GlobalValue::ExternalLinkage);

ClassRef->replaceAllUsesWith(Class);

ClassRef->removeFromParent();

->setName(ClassSym);

llvm::Constant *CGObjCGNU::

llvm::StructType *ObjCMethodDescTy =

llvm::StructType::get(CGM.

(), { PtrToInt8Ty, PtrToInt8Ty });

MethodList = Builder.beginStruct();

MethodList.addInt(IntTy, Methods.size());

MethodArray = MethodList.beginArray(ObjCMethodDescTy);

(

*M : Methods) {

Method = MethodArray.beginStruct(ObjCMethodDescTy);

Method.

(MakeConstantString(M->getSelector().getAsString()));

Method.finishAndAddTo(MethodArray);

MethodArray.finishAndAddTo(MethodList);

MethodList.finishAndCreateGlobal(

,

ProtocolList = Builder.beginStruct();

ProtocolList.add(NULLPtr);

ProtocolList.addInt(LongTy, Protocols.size());

Elements = ProtocolList.beginArray(PtrToInt8Ty);

(

std::string *iter = Protocols.begin(), *endIter = Protocols.end();

iter != endIter ; iter++) {

llvm::Constant *protocol =

;

llvm::StringMap<llvm::Constant*>::iterator value =

ExistingProtocols.find(*iter);

(value == ExistingProtocols.end()) {

protocol = GenerateEmptyProtocol(*iter);

protocol = value->getValue();

Elements.add(protocol);

Elements.finishAndAddTo(ProtocolList);

ProtocolList.finishAndCreateGlobal(

,

protocol = GenerateProtocolRef(PD);

CGF.

.CreateBitCast(protocol, llvm::PointerType::getUnqual(

));

llvm::Constant *CGObjCGNU::GenerateProtocolRef(

*PD) {

llvm::Constant *&protocol = ExistingProtocols[PD->

()];

GenerateProtocol(PD);

assert(protocol &&

);

CGObjCGNU::GenerateEmptyProtocol(StringRef ProtocolName) {

llvm::Constant *ProtocolList = GenerateProtocolList({});

llvm::Constant *MethodList = GenerateProtocolMethodList({});

Elements = Builder.beginStruct();

Elements.add(llvm::ConstantExpr::getIntToPtr(

llvm::ConstantInt::get(Int32Ty, ProtocolVersion), IdTy));

Elements.add(MakeConstantString(ProtocolName,

));

Elements.add(ProtocolList);

Elements.add(MethodList);

Elements.add(MethodList);

Elements.add(MethodList);

Elements.add(MethodList);

Elements.add(NULLPtr);

Elements.add(NULLPtr);

Elements.finishAndCreateGlobal(SymbolForProtocol(ProtocolName),

(

*PI : PD->

())

Protocols.push_back(PI->getNameAsString());

(I->isOptional())

OptionalInstanceMethods.push_back(I);

InstanceMethods.push_back(I);

(I->isOptional())

OptionalClassMethods.push_back(I);

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);

llvm::Constant *PropertyList =

GeneratePropertyList(

, PD,

,

);

llvm::Constant *OptionalPropertyList =

GeneratePropertyList(

, PD,

,

);

Elements = Builder.beginStruct();

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] =

Elements.finishAndCreateGlobal(

, CGM.

());

CGObjCGNU::GenerateProtocolHolderCategory() {

Elements = Builder.beginStruct();

std::string ClassName =

;

std::string CategoryName =

;

Elements.add(MakeConstantString(CategoryName));

Elements.add(MakeConstantString(ClassName));

Elements.add(GenerateMethodList(ClassName, CategoryName, {},

));

Elements.add(GenerateMethodList(ClassName, CategoryName, {},

));

ProtocolList = ProtocolListBuilder.beginStruct();

ProtocolList.add(NULLPtr);

ProtocolList.addInt(LongTy, ExistingProtocols.size());

ProtocolElements = ProtocolList.beginArray(PtrTy);

(

iter = ExistingProtocols.begin(), endIter = ExistingProtocols.end();

iter != endIter ; iter++) {

ProtocolElements.add(iter->getValue());

ProtocolElements.finishAndAddTo(ProtocolList);

Elements.add(ProtocolList.finishAndCreateGlobal(

,

Categories.push_back(

bitCount = bits.size();

(bitCount < ptrBits) {

(

i=0 ; i<bitCount ; ++i) {

(bits[i]) val |= 1ULL<<(i+1);

llvm::ConstantInt::get(IntPtrTy, val);

(

< bitCount) {

(

i=0 ; (i<32) && (

<bitCount) ; ++i) {

(bits[

]) word |= 1<<i;

values.push_back(llvm::ConstantInt::get(Int32Ty, word));

fields = builder.beginStruct();

fields.addInt(Int32Ty, values.size());

array = fields.beginArray();

(

*

: values) array.add(

);

array.finishAndAddTo(fields);

llvm::Constant *GS =

llvm::Constant *ptr = llvm::ConstantExpr::getPtrToInt(GS, IntPtrTy);

llvm::Constant *CGObjCGNU::GenerateCategoryProtocolList(

RuntimeProtos =

GetRuntimeProtocolList(RefPro.begin(), RefPro.end());

(

*PD : RuntimeProtos)

GenerateProtocolList(Protocols);

std::string ClassName =

->getNameAsString();

Elements = Builder.beginStruct();

Elements.add(MakeConstantString(CategoryName));

Elements.add(MakeConstantString(ClassName));

InstanceMethods.insert(InstanceMethods.begin(), OCD->

(),

GenerateMethodList(ClassName, CategoryName, InstanceMethods,

));

Elements.add(GenerateMethodList(ClassName, CategoryName, ClassMethods,

));

Elements.add(GenerateCategoryProtocolList(CatDecl));

Elements.add(GeneratePropertyList(OCD,

,

));

Elements.add(GeneratePropertyList(OCD,

,

));

Elements.addNullPointer(PtrTy);

Elements.addNullPointer(PtrTy);

Categories.push_back(Elements.finishAndCreateGlobal(

std::string(

) + ClassName + CategoryName,

llvm::Constant *CGObjCGNU::GeneratePropertyList(

*Container,

isClassProperty,

protocolOptionalProperties) {

isProtocol = isa<ObjCProtocolDecl>(OCD);

std::function<void(

*Proto)> collectProtocolProperties

(

*

: Proto->protocols())

collectProtocolProperties(

);

(

*PD : Proto->properties()) {

(isClassProperty != PD->isClassProperty())

Properties.push_back(PD);

(

*PD : ClassExt->properties()) {

(isClassProperty != PD->isClassProperty())

Properties.push_back(PD);

(

*PD : OCD->

()) {

(isClassProperty != PD->isClassProperty())

(isProtocol && (protocolOptionalProperties != PD->isOptional()))

Properties.push_back(PD);

collectProtocolProperties(

);

(

*

: CD->protocols())

collectProtocolProperties(

);

numProperties = Properties.size();

(numProperties == 0)

propertyList = builder.beginStruct();

properties = PushPropertyListHeader(propertyList, numProperties);

(

*property : Properties) {

isSynthesized =

;

isDynamic =

;

isSynthesized = (propertyImpl->getPropertyImplementation() ==

isDynamic = (propertyImpl->getPropertyImplementation() ==

PushProperty(properties, property, Container, isSynthesized, isDynamic);

properties.finishAndAddTo(propertyList);

propertyList.finishAndCreateGlobal(

,

std::string SuperClassName;

(SuperClassDecl) {

EmitClassRef(SuperClassName);

std::string classSymbolName =

+ ClassName;

(

*symbol = TheModule.getGlobalVariable(classSymbolName)) {

symbol->setInitializer(llvm::ConstantInt::get(LongTy, 0));

llvm::GlobalVariable(TheModule, LongTy,

,

llvm::GlobalValue::ExternalLinkage,

llvm::ConstantInt::get(LongTy, 0),

IvarOffsetValues = IvarOffsetBuilder.beginArray(PtrToIntTy);

superInstanceSize = !SuperClassDecl ? 0 :

instanceSize = 0 - (instanceSize - superInstanceSize);

IvarNames.push_back(MakeConstantString(IVD->getNameAsString()));

std::string TypeStr;

IvarTypes.push_back(MakeConstantString(TypeStr));

IvarAligns.push_back(llvm::ConstantInt::get(IntTy,

BaseOffset = ComputeIvarBaseOffset(CGM, OID, IVD);

Offset = BaseOffset - superInstanceSize;

llvm::Constant *OffsetValue = llvm::ConstantInt::get(IntTy, Offset);

std::string OffsetName =

+ ClassName +

+

IVD->getNameAsString();

llvm::GlobalVariable *OffsetVar = TheModule.getGlobalVariable(OffsetName);

OffsetVar->setInitializer(OffsetValue);

OffsetVar->setLinkage(llvm::GlobalValue::ExternalLinkage);

OffsetVar =

llvm::GlobalVariable(TheModule, Int32Ty,

, llvm::GlobalValue::ExternalLinkage,

OffsetValue, OffsetName);

IvarOffsets.push_back(OffsetValue);

IvarOffsetValues.add(OffsetVar);

IvarOwnership.push_back(lt);

StrongIvars.push_back(

);

WeakIvars.push_back(

);

StrongIvars.push_back(

);

WeakIvars.push_back(

);

StrongIvars.push_back(

);

WeakIvars.push_back(

);

llvm::Constant *StrongIvarBitmap = MakeBitField(StrongIvars);

llvm::Constant *WeakIvarBitmap = MakeBitField(WeakIvars);

llvm::GlobalVariable *IvarOffsetArray =

IvarOffsetValues.finishAndCreateGlobal(

,

InstanceMethods.insert(InstanceMethods.begin(), OID->

(),

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

RefProtocols = ClassDecl->

();

RuntimeProtocols =

GetRuntimeProtocolList(RefProtocols.begin(), RefProtocols.end());

(

*I : RuntimeProtocols)

Protocols.push_back(I->getNameAsString());

llvm::Constant *SuperClass;

(!SuperClassName.empty()) {

SuperClass = MakeConstantString(SuperClassName,

);

SuperClass = llvm::ConstantPointerNull::get(PtrToInt8Ty);

llvm::Constant *MethodList = GenerateMethodList(ClassName,

,

InstanceMethods,

);

llvm::Constant *ClassMethodList = GenerateMethodList(ClassName,

,

ClassMethods,

);

llvm::Constant *IvarList = GenerateIvarList(IvarNames, IvarTypes,

IvarOffsets, IvarAligns, IvarOwnership);

llvm::Type *IndexTy = Int32Ty;

llvm::Constant *offsetPointerIndexes[] = {Zeros[0],

llvm::ConstantInt::get(IndexTy, ClassABIVersion > 1 ? 2 : 1),

,

llvm::ConstantInt::get(IndexTy, ClassABIVersion > 1 ? 3 : 2) };

ivarIndex = 0;

std::string Name = GetIVarOffsetVariableName(ClassDecl, IVD);

offsetPointerIndexes[2] = llvm::ConstantInt::get(IndexTy, ivarIndex);

llvm::Constant *offsetValue = llvm::ConstantExpr::getGetElementPtr(

cast<llvm::GlobalVariable>(IvarList)->getValueType(), IvarList,

offsetPointerIndexes);

llvm::GlobalVariable *offset = TheModule.getNamedGlobal(Name);

offset->setInitializer(offsetValue);

offset->setLinkage(llvm::GlobalValue::ExternalLinkage);

llvm::GlobalVariable(TheModule, offsetValue->getType(),

, llvm::GlobalValue::ExternalLinkage, offsetValue, Name);

llvm::Constant *ZeroPtr = llvm::ConstantInt::get(IntPtrTy, 0);

llvm::Constant *MetaClassStruct = GenerateClassStructure(

NULLPtr, NULLPtr, 0x12L, ClassName.c_str(),

, Zeros[0],

NULLPtr, ClassMethodList, NULLPtr, NULLPtr,

GeneratePropertyList(OID, ClassDecl,

), ZeroPtr, ZeroPtr,

);

llvm::Constant *ClassStruct = GenerateClassStructure(

MetaClassStruct, SuperClass, 0x11L, ClassName.c_str(),

,

llvm::ConstantInt::get(LongTy, instanceSize), IvarList, MethodList,

GenerateProtocolList(Protocols), IvarOffsetArray, Properties,

StrongIvarBitmap, WeakIvarBitmap);

(ClassPtrAlias) {

ClassPtrAlias->replaceAllUsesWith(ClassStruct);

ClassPtrAlias->eraseFromParent();

ClassPtrAlias =

;

(MetaClassPtrAlias) {

MetaClassPtrAlias->replaceAllUsesWith(MetaClassStruct);

MetaClassPtrAlias->eraseFromParent();

MetaClassPtrAlias =

;

Classes.push_back(ClassStruct);

llvm::Function *CGObjCGNU::ModuleInitFunction() {

(Classes.empty() && Categories.empty() && ConstantStrings.empty() &&

GenerateProtocolHolderCategory();

llvm::StructType *selStructTy = dyn_cast<llvm::StructType>(SelectorElemTy);

{ PtrToInt8Ty, PtrToInt8Ty });

llvm::Constant *statics = NULLPtr;

(!ConstantStrings.empty()) {

llvm::GlobalVariable *fileStatics = [&] {

staticsStruct = builder.beginStruct();

(stringClass.empty()) stringClass =

;

staticsStruct.add(MakeConstantString(stringClass,

));

array = staticsStruct.beginArray();

array.addAll(ConstantStrings);

array.finishAndAddTo(staticsStruct);

staticsStruct.finishAndCreateGlobal(

,

allStaticsArray = builder.beginArray(fileStatics->getType());

allStaticsArray.add(fileStatics);

allStaticsArray.addNullPointer(fileStatics->getType());

statics = allStaticsArray.finishAndCreateGlobal(

,

selectorCount;

llvm::GlobalVariable *selectorList = [&] {

selectors = builder.beginArray(selStructTy);

std::vector<Selector> allSelectors;

(

&entry : table)

allSelectors.push_back(entry.first);

llvm::sort(allSelectors);

(

&untypedSel : allSelectors) {

std::string selNameStr = untypedSel.getAsString();

llvm::Constant *selName = ExportUniqueString(selNameStr,

);

(TypedSelector &sel : table[untypedSel]) {

llvm::Constant *selectorTypeEncoding = NULLPtr;

(!sel.first.empty())

selectorTypeEncoding =

MakeConstantString(sel.first,

);

selStruct = selectors.beginStruct(selStructTy);

selStruct.add(selName);

selStruct.add(selectorTypeEncoding);

selStruct.finishAndAddTo(selectors);

selectorAliases.push_back(sel.second);

selectorCount = selectors.size();

selStruct = selectors.beginStruct(selStructTy);

selStruct.add(NULLPtr);

selStruct.add(NULLPtr);

selStruct.finishAndAddTo(selectors);

selectors.finishAndCreateGlobal(

,

(

i = 0; i < selectorCount; ++i) {

llvm::Constant *idxs[] = {

llvm::ConstantInt::get(Int32Ty, i)

llvm::Constant *selPtr = llvm::ConstantExpr::getGetElementPtr(

selectorList->getValueType(), selectorList, idxs);

selectorAliases[i]->replaceAllUsesWith(selPtr);

selectorAliases[i]->eraseFromParent();

llvm::GlobalVariable *symtab = [&] {

symtab = builder.beginStruct();

symtab.addInt(LongTy, selectorCount);

symtab.add(selectorList);

symtab.addInt(CGM.

, Classes.size());

symtab.addInt(CGM.

, Categories.size());

classList = symtab.beginArray(PtrToInt8Ty);

classList.addAll(Classes);

classList.addAll(Categories);

classList.add(statics);

classList.add(NULLPtr);

classList.finishAndAddTo(symtab);

llvm::Constant *module = [&] {

llvm::Type *moduleEltTys[] = {

LongTy, LongTy, PtrToInt8Ty, symtab->getType(), IntTy

llvm::StructType *moduleTy = llvm::StructType::get(

(moduleEltTys).drop_back(

(RuntimeVersion < 10)));

module = builder.beginStruct(moduleTy);

module.addInt(LongTy, RuntimeVersion);

module.addInt(LongTy, CGM.

().getTypeStoreSize(moduleTy));

module.add(MakeConstantString(path,

));

(RuntimeVersion >= 10) {

LangOptions::GCOnly:

module.addInt(IntTy, 2);

LangOptions::NonGC:

module.addInt(IntTy, 1);

module.addInt(IntTy, 0);

LangOptions::HybridGC:

module.addInt(IntTy, 1);

llvm::Function * LoadFunction = llvm::Function::Create(

llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext),

),

llvm::GlobalValue::InternalLinkage,

,

llvm::BasicBlock *EntryBB =

llvm::BasicBlock::Create(VMContext,

, LoadFunction);

Builder.SetInsertPoint(EntryBB);

llvm::FunctionType *FT =

llvm::FunctionType::get(Builder.getVoidTy(), module->getType(),

);

llvm::FunctionCallee Register =

Builder.CreateCall(Register, module);

(!ClassAliases.empty()) {

llvm::Type *ArgTypes[2] = {PtrTy, PtrToInt8Ty};

llvm::FunctionType *RegisterAliasTy =

llvm::FunctionType::get(Builder.getVoidTy(),

llvm::Function *RegisterAlias = llvm::Function::Create(

llvm::GlobalValue::ExternalWeakLinkage,

,

llvm::BasicBlock *AliasBB =

llvm::BasicBlock::Create(VMContext,

, LoadFunction);

llvm::BasicBlock *NoAliasBB =

llvm::BasicBlock::Create(VMContext,

, LoadFunction);

llvm::Value *HasRegisterAlias = Builder.CreateICmpNE(RegisterAlias,

llvm::Constant::getNullValue(RegisterAlias->getType()));

Builder.CreateCondBr(HasRegisterAlias, AliasBB, NoAliasBB);

Builder.SetInsertPoint(AliasBB);

(std::vector<ClassAliasPair>::iterator iter = ClassAliases.begin();

iter != ClassAliases.end(); ++iter) {

llvm::Constant *TheClass =

TheModule.getGlobalVariable(

+ iter->first,

);

Builder.CreateCall(RegisterAlias,

{TheClass, MakeConstantString(iter->second)});

Builder.CreateBr(NoAliasBB);

Builder.SetInsertPoint(NoAliasBB);

Builder.CreateRetVoid();

LoadFunction;

llvm::Function *CGObjCGNU::GenerateMethod(

*OMD,

llvm::FunctionType *MethodTy =

Types.GetFunctionType(Types.arrangeObjCMethodDeclaration(OMD));

std::string FunctionName =

getSymbolNameForMethod(OMD,

!isDirect);

llvm::Function::Create(MethodTy,

llvm::GlobalVariable::InternalLinkage,

FunctionName, &TheModule);

I = DirectMethodDefinitions.find(COMD);

llvm::Function *OldFn =

, *

=

;

(I == DirectMethodDefinitions.end()) {

llvm::Function::Create(MethodTy, llvm::GlobalVariable::ExternalLinkage,

FunctionName, &TheModule);

DirectMethodDefinitions.insert(std::make_pair(COMD, F));

= llvm::Function::Create(MethodTy, llvm::GlobalValue::ExternalLinkage,

,

->takeName(OldFn);

OldFn->replaceAllUsesWith(Fn);

OldFn->eraseFromParent();

llvm::FunctionCallee CGObjCGNU::GetPropertyGetFunction() {

GetPropertyFn;

llvm::FunctionCallee CGObjCGNU::GetPropertySetFunction() {

SetPropertyFn;

llvm::FunctionCallee CGObjCGNU::GetOptimizedPropertySetFunction(

atomic,

llvm::FunctionCallee CGObjCGNU::GetGetStructFunction() {

GetStructPropertyFn;

llvm::FunctionCallee CGObjCGNU::GetSetStructFunction() {

SetStructPropertyFn;

llvm::FunctionCallee CGObjCGNU::GetCppAtomicObjectGetFunction() {

llvm::FunctionCallee CGObjCGNU::GetCppAtomicObjectSetFunction() {

llvm::FunctionCallee CGObjCGNU::EnumerationMutationFunction() {

EnumerationMutationFn;

EmitAtSynchronizedStmt(CGF, S, SyncEnterFn, SyncExitFn);

EmitTryCatchStmt(CGF, S, EnterCatchFn, ExitCatchFn, ExceptionReThrowFn);

ClearInsertionPoint) {

llvm::Value *ExceptionAsObject;

isRethrow =

;

(

*ThrowExpr = S.getThrowExpr()) {

ExceptionAsObject = Exception;

);

(isRethrow && (usesSEHExceptions || usesCxxExceptions)) {

Throw->setDoesNotReturn();

ExceptionAsObject = CGF.

.CreateBitCast(ExceptionAsObject, IdTy);

llvm::CallBase *Throw =

Throw->setDoesNotReturn();

CGF.

.CreateUnreachable();

(ClearInsertionPoint)

CGF.

.ClearInsertionPoint();

B.CreateCall(

WeakReadFn, EnforceType(B, AddrWeakObj.

(CGF), PtrToIdTy));

llvm::Value *src,

dst) {

src = EnforceType(B, src, IdTy);

llvm::Value *dstVal = EnforceType(B, dst.

(CGF), PtrToIdTy);

B.CreateCall(WeakAssignFn, {src, dstVal});

llvm::Value *src,

dst,

src = EnforceType(B, src, IdTy);

llvm::Value *dstVal = EnforceType(B, dst.

(CGF), PtrToIdTy);

assert(!threadlocal &&

);

B.CreateCall(GlobalAssignFn, {src, dstVal});

llvm::Value *src,

dst,

llvm::Value *ivarOffset) {

src = EnforceType(B, src, IdTy);

llvm::Value *dstVal = EnforceType(B, dst.

(CGF), IdTy);

B.CreateCall(IvarAssignFn, {src, dstVal, ivarOffset});

llvm::Value *src,

dst) {

src = EnforceType(B, src, IdTy);

llvm::Value *dstVal = EnforceType(B, dst.

(CGF), PtrToIdTy);

B.CreateCall(StrongCastAssignFn, {src, dstVal});

llvm::Value *Size) {

llvm::Value *DestPtrVal = EnforceType(B, DestPtr.

(CGF), PtrTy);

llvm::Value *SrcPtrVal = EnforceType(B, SrcPtr.

(CGF), PtrTy);

B.CreateCall(MemMoveFn, {DestPtrVal, SrcPtrVal,

});

llvm::GlobalVariable *CGObjCGNU::ObjCIvarOffsetVariable(

std::string Name = GetIVarOffsetVariableName(ID, Ivar);

llvm::GlobalVariable *IvarOffsetPointer = TheModule.getNamedGlobal(Name);

(!IvarOffsetPointer)

IvarOffsetPointer =

llvm::GlobalVariable(

TheModule, llvm::PointerType::getUnqual(VMContext),

,

llvm::GlobalValue::ExternalLinkage,

, Name);

IvarOffsetPointer;

llvm::Value *BaseValue,

CVRQualifiers) {

EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,

EmitIvarOffset(CGF, ID, Ivar));

(RuntimeVersion < 10 ||

CGF.

.CreateZExtOrBitCast(

llvm::PointerType::getUnqual(VMContext),

ObjCIvarOffsetVariable(

, Ivar),

std::string

=

+

llvm::Value *Offset = TheModule.getGlobalVariable(name);

GV =

llvm::GlobalVariable(TheModule, IntTy,

, llvm::GlobalValue::LinkOnceAnyLinkage,

llvm::Constant::getNullValue(IntTy), name);

(Offset->getType() != PtrDiffTy)

Offset = CGF.

.CreateZExtOrBitCast(Offset, PtrDiffTy);

llvm::ConstantInt::get(PtrDiffTy, Offset,

);

(Runtime.getKind()) {

(Runtime.getVersion() >= VersionTuple(2, 0))

CGObjCGNUstep2(CGM);

CGObjCGNUstep(CGM);

CGObjCGCC(CGM);

CGObjCObjFW(CGM);

llvm_unreachable(

);

llvm_unreachable(

);

Defines the clang::ASTContext interface.

static const ObjCInterfaceDecl * FindIvarInterface(ASTContext &Context, const ObjCInterfaceDecl *OID, const ObjCIvarDecl *OIVD)

static bool isNamed(const NamedDecl *ND, const char(&Str)[Len])

Defines the SourceManager interface.

Defines the Objective-C statement AST node classes.

__device__ __2f16 float __ockl_bool s

__device__ __2f16 float c

Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...

SourceManager & getSourceManager()

TranslationUnitDecl * getTranslationUnitDecl() const

CharUnits getTypeAlignInChars(QualType T) const

Return the ABI-specified alignment of a (complete) type T, in characters.

void getObjCEncodingForType(QualType T, std::string &S, const FieldDecl *Field=nullptr, QualType *NotEncodedT=nullptr) const

Emit the Objective-CC type encoding for the given type T into S.

CanQualType getCanonicalType(QualType T) const

Return the canonical (structural) type corresponding to the specified potentially non-canonical type ...

std::string getObjCEncodingForMethodDecl(const ObjCMethodDecl *Decl, bool Extended=false) const

Emit the encoded type for the method declaration Decl into S.

std::string getObjCEncodingForPropertyDecl(const ObjCPropertyDecl *PD, const Decl *Container) const

getObjCEncodingForPropertyDecl - Return the encoded type for this method declaration.

const ASTRecordLayout & getASTObjCImplementationLayout(const ObjCImplementationDecl *D) const

Get or compute information about the layout of the specified Objective-C implementation.

const ASTRecordLayout & getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) const

Get or compute information about the layout of the specified Objective-C interface.

QualType getObjCProtoType() const

Retrieve the type of the Objective-C Protocol class.

QualType getPointerDiffType() const

Return the unique type for "ptrdiff_t" (C99 7.17) defined in <stddef.h>.

ObjCPropertyImplDecl * getObjCPropertyImplDeclForPropertyDecl(const ObjCPropertyDecl *PD, const Decl *Container) const

QualType getObjCSelType() const

Retrieve the type that corresponds to the predefined Objective-C 'SEL' type.

CanQualType getSizeType() const

Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.

QualType getObjCIdType() const

Represents the Objective-CC id type.

uint64_t getTypeSize(QualType T) const

Return the size of the specified (complete) type T, in bits.

CharUnits getTypeSizeInChars(QualType T) const

Return the size of the specified (complete) type T, in characters.

void getObjCEncodingForMethodParameter(Decl::ObjCDeclQualifier QT, QualType T, std::string &S, bool Extended) const

getObjCEncodingForMethodParameter - Return the encoded type for a single method parameter or return t...

const TargetInfo & getTargetInfo() const

uint64_t getCharWidth() const

Return the size of the character type, in bits.

CharUnits getSize() const

getSize - Get the record size in characters.

const T * getTypePtr() const

Retrieve the underlying type pointer, which refers to a canonical type.

CharUnits - This is an opaque type for sizes expressed in character units.

llvm::Align getAsAlign() const

getAsAlign - Returns Quantity as a valid llvm::Align, Beware llvm::Align assumes power of two 8-bit b...

QuantityType getQuantity() const

getQuantity - Get the raw integer representation of this quantity.

static CharUnits fromQuantity(QuantityType Quantity)

fromQuantity - Construct a CharUnits quantity from a raw integer type.

Like RawAddress, an abstract representation of an aligned address, but the pointer contained in this ...

llvm::Value * emitRawPointer(CodeGenFunction &CGF) const

Return the pointer contained in this class after authenticating it and adding offset to it if necessa...

CGBlockInfo - Information to generate a block literal.

llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)

llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")

llvm::LoadInst * CreateAlignedLoad(llvm::Type *Ty, llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")

virtual llvm::Constant * getAddrOfRTTIDescriptor(QualType Ty)=0

virtual CatchTypeInfo getCatchAllTypeInfo()

Abstract information about a function or function prototype.

All available information about a concrete callee.

Implements runtime-specific code generation functions.

virtual llvm::Constant * GetEHType(QualType T)=0

Get the type constant to catch for the given ObjC pointer type.

virtual void EmitObjCIvarAssign(CodeGen::CodeGenFunction &CGF, llvm::Value *src, Address dest, llvm::Value *ivarOffset)=0

virtual llvm::FunctionCallee GetCppAtomicObjectGetFunction()=0

API for atomic copying of qualified aggregates with non-trivial copy assignment (c++) in getter.

virtual void EmitObjCWeakAssign(CodeGen::CodeGenFunction &CGF, llvm::Value *src, Address dest)=0

virtual llvm::Constant * BuildByrefLayout(CodeGen::CodeGenModule &CGM, QualType T)=0

Returns an i8* which points to the byref layout information.

virtual void EmitGCMemmoveCollectable(CodeGen::CodeGenFunction &CGF, Address DestPtr, Address SrcPtr, llvm::Value *Size)=0

virtual llvm::FunctionCallee GetPropertySetFunction()=0

Return the runtime function for setting properties.

virtual llvm::FunctionCallee GetCppAtomicObjectSetFunction()=0

API for atomic copying of qualified aggregates with non-trivial copy assignment (c++) in setter.

virtual void EmitTryStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtTryStmt &S)=0

virtual CodeGen::RValue GenerateMessageSend(CodeGen::CodeGenFunction &CGF, ReturnValueSlot ReturnSlot, QualType ResultType, Selector Sel, llvm::Value *Receiver, const CallArgList &CallArgs, const ObjCInterfaceDecl *Class=nullptr, const ObjCMethodDecl *Method=nullptr)=0

Generate an Objective-C message send operation.

virtual LValue EmitObjCValueForIvar(CodeGen::CodeGenFunction &CGF, QualType ObjectTy, llvm::Value *BaseValue, const ObjCIvarDecl *Ivar, unsigned CVRQualifiers)=0

virtual void RegisterAlias(const ObjCCompatibleAliasDecl *OAD)=0

Register an class alias.

virtual void GenerateCategory(const ObjCCategoryImplDecl *OCD)=0

Generate a category.

virtual void EmitThrowStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtThrowStmt &S, bool ClearInsertionPoint=true)=0

virtual llvm::Value * EmitIvarOffset(CodeGen::CodeGenFunction &CGF, const ObjCInterfaceDecl *Interface, const ObjCIvarDecl *Ivar)=0

virtual llvm::Function * GenerateMethod(const ObjCMethodDecl *OMD, const ObjCContainerDecl *CD)=0

Generate a function preamble for a method with the specified types.

virtual llvm::Value * GenerateProtocolRef(CodeGenFunction &CGF, const ObjCProtocolDecl *OPD)=0

Emit the code to return the named protocol as an object, as in a @protocol expression.

virtual llvm::Value * EmitObjCWeakRead(CodeGen::CodeGenFunction &CGF, Address AddrWeakObj)=0

virtual llvm::Function * ModuleInitFunction()=0

Generate the function required to register all Objective-C components in this compilation unit with t...

virtual CodeGen::RValue GenerateMessageSendSuper(CodeGen::CodeGenFunction &CGF, ReturnValueSlot ReturnSlot, QualType ResultType, Selector Sel, const ObjCInterfaceDecl *Class, bool isCategoryImpl, llvm::Value *Self, bool IsClassMessage, const CallArgList &CallArgs, const ObjCMethodDecl *Method=nullptr)=0

Generate an Objective-C message send operation to the super class initiated in a method for Class and...

virtual void GenerateClass(const ObjCImplementationDecl *OID)=0

Generate a class structure for this class.

virtual llvm::FunctionCallee EnumerationMutationFunction()=0

EnumerationMutationFunction - Return the function that's called by the compiler when a mutation is de...

virtual llvm::Constant * BuildGCBlockLayout(CodeGen::CodeGenModule &CGM, const CodeGen::CGBlockInfo &blockInfo)=0

virtual llvm::FunctionCallee GetGetStructFunction()=0

virtual llvm::Constant * GetOrEmitProtocol(const ObjCProtocolDecl *PD)=0

GetOrEmitProtocol - Get the protocol object for the given declaration, emitting it if necessary.

virtual ConstantAddress GenerateConstantString(const StringLiteral *)=0

Generate a constant string object.

virtual llvm::Value * GetClass(CodeGenFunction &CGF, const ObjCInterfaceDecl *OID)=0

GetClass - Return a reference to the class for the given interface decl.

virtual void GenerateProtocol(const ObjCProtocolDecl *OPD)=0

Generate the named protocol.

virtual llvm::Constant * BuildRCBlockLayout(CodeGen::CodeGenModule &CGM, const CodeGen::CGBlockInfo &blockInfo)=0

virtual llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic, bool copy)=0

Return the runtime function for optimized setting properties.

virtual llvm::Value * GetSelector(CodeGenFunction &CGF, Selector Sel)=0

Get a selector for the specified name and type values.

virtual void GenerateDirectMethodPrologue(CodeGenFunction &CGF, llvm::Function *Fn, const ObjCMethodDecl *OMD, const ObjCContainerDecl *CD)=0

Generates prologue for direct Objective-C Methods.

virtual Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel)=0

Get the address of a selector for the specified name and type values.

virtual void EmitObjCStrongCastAssign(CodeGen::CodeGenFunction &CGF, llvm::Value *src, Address dest)=0

virtual llvm::Value * EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF)

virtual void EmitObjCGlobalAssign(CodeGen::CodeGenFunction &CGF, llvm::Value *src, Address dest, bool threadlocal=false)=0

virtual llvm::FunctionCallee GetPropertyGetFunction()=0

Return the runtime function for getting properties.

virtual llvm::FunctionCallee GetSetStructFunction()=0

virtual void EmitSynchronizedStmt(CodeGen::CodeGenFunction &CGF, const ObjCAtSynchronizedStmt &S)=0

CallArgList - Type for representing both the value and type of arguments in a call.

void add(RValue rvalue, QualType type)

void addFrom(const CallArgList &other)

Add all the arguments from another CallArgList to this one.

CodeGenFunction - This class organizes the per-function state that is used while generating LLVM code...

void EmitNullInitialization(Address DestPtr, QualType Ty)

EmitNullInitialization - Generate code to set a value of the given type to null, If the type contains...

llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)

createBasicBlock - Create an LLVM basic block.

void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)

EmitBlock - Emit the given block.

SmallVector< llvm::Value *, 8 > ObjCEHValueStack

ObjCEHValueStack - Stack of Objective-C exception values, used for rethrows.

llvm::AllocaInst * CreateTempAlloca(llvm::Type *Ty, const Twine &Name="tmp", llvm::Value *ArraySize=nullptr)

CreateTempAlloca - This creates an alloca and inserts it into the entry block if ArraySize is nullptr...

const Decl * CurCodeDecl

CurCodeDecl - This is the inner-most code context, which includes blocks.

JumpDest ReturnBlock

ReturnBlock - Unified return block.

llvm::Value * EmitObjCThrowOperand(const Expr *expr)

llvm::Value * LoadObjCSelf()

LoadObjCSelf - Load the value of self.

RValue EmitCall(const CGFunctionInfo &CallInfo, const CGCallee &Callee, ReturnValueSlot ReturnValue, const CallArgList &Args, llvm::CallBase **CallOrInvoke, bool IsMustTail, SourceLocation Loc, bool IsVirtualFunctionPointerThunk=false)

EmitCall - Generate a call of the given function, expecting the given result type,...

void EmitVarDecl(const VarDecl &D)

EmitVarDecl - Emit a local variable declaration.

llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")

ASTContext & getContext() const

void EmitBranchThroughCleanup(JumpDest Dest)

EmitBranchThroughCleanup - Emit a branch from the current insert block through the normal cleanup han...

llvm::CallInst * EmitRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")

llvm::CallBase * EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee, ArrayRef< llvm::Value * > args, const Twine &name="")

static bool hasAggregateEvaluationKind(QualType T)

Address GetAddrOfLocalVar(const VarDecl *VD)

GetAddrOfLocalVar - Return the address of a local variable.

Address ReturnValue

ReturnValue - The temporary alloca to hold the return value.

llvm::LLVMContext & getLLVMContext()

This class organizes the cross-function state that is used while generating LLVM code.

void setGVProperties(llvm::GlobalValue *GV, GlobalDecl GD) const

Set visibility, dllimport/dllexport and dso_local.

llvm::Module & getModule() const

llvm::FunctionCallee CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name, llvm::AttributeList ExtraAttrs=llvm::AttributeList(), bool Local=false, bool AssumeConvergent=false)

Create or return a runtime function declaration with the specified type and name.

void addCompilerUsedGlobal(llvm::GlobalValue *GV)

Add a global to a list to be added to the llvm.compiler.used metadata.

bool ReturnTypeUsesFPRet(QualType ResultType)

Return true iff the given type uses 'fpret' when used as a return type.

const LangOptions & getLangOpts() const

CodeGenTypes & getTypes()

const TargetInfo & getTarget() const

void addUsedGlobal(llvm::GlobalValue *GV)

Add a global to a list to be added to the llvm.used metadata.

const llvm::DataLayout & getDataLayout() const

CGCXXABI & getCXXABI() const

const llvm::Triple & getTriple() const

bool ReturnTypeHasInReg(const CGFunctionInfo &FI)

Return true iff the given type has inreg set.

ASTContext & getContext() const

bool ReturnTypeUsesSRet(const CGFunctionInfo &FI)

Return true iff the given type uses 'sret' when used as a return type.

const CodeGenOptions & getCodeGenOpts() const

llvm::LLVMContext & getLLVMContext()

llvm::Constant * EmitNullConstant(QualType T)

Return the result of value-initializing the given type, i.e.

ConstantAddress GetAddrOfConstantCString(const std::string &Str, const char *GlobalName=nullptr)

Returns a pointer to a character array containing the literal and a terminating '\0' character.

This class organizes the cross-module state that is used while lowering AST types to LLVM types.

llvm::Type * ConvertType(QualType T)

ConvertType - Convert type T into a llvm::Type.

llvm::Type * ConvertTypeForMem(QualType T)

ConvertTypeForMem - Convert type T into a llvm::Type.

bool isZeroInitializable(QualType T)

IsZeroInitializable - Return whether a type can be zero-initialized (in the C++ sense) with an LLVM z...

A specialization of Address that requires the address to be an LLVM Constant.

ArrayBuilder beginArray(llvm::Type *eltTy=nullptr)

llvm::GlobalVariable * finishAndCreateGlobal(As &&...args)

Given that this builder was created by beginning an array or struct directly on a ConstantInitBuilder...

StructBuilder beginStruct(llvm::StructType *ty=nullptr)

void finishAndAddTo(AggregateBuilderBase &parent)

Given that this builder was created by beginning an array or struct component on the given parent bui...

A helper class of ConstantInitBuilder, used for building constant array initializers.

The standard implementation of ConstantInitBuilder used in Clang.

A helper class of ConstantInitBuilder, used for building constant struct initializers.

LValue - This represents an lvalue references.

RValue - This trivial value class is used to represent the result of an expression that is evaluated.

static RValue get(llvm::Value *V)

static RValue getComplex(llvm::Value *V1, llvm::Value *V2)

Address getAggregateAddress() const

getAggregateAddr() - Return the Value* of the address of the aggregate.

llvm::Value * getScalarVal() const

getScalarVal() - Return the Value* of this scalar value.

std::pair< llvm::Value *, llvm::Value * > getComplexVal() const

getComplexVal - Return the real/imag components of this complex value.

An abstract representation of an aligned address.

llvm::Value * getPointer() const

ReturnValueSlot - Contains the address where the return value of a function can be stored,...

DeclContext - This is used only as base class of specific decl types that can act as declaration cont...

lookup_result lookup(DeclarationName Name) const

lookup - Find the declarations (if any) with the given Name in this context.

Decl - This represents one declaration (or definition), e.g.

bool isWeakImported() const

Determine whether this is a weak-imported symbol.

bool isUsed(bool CheckUsedAttr=true) const

Whether any (re-)declaration of the entity was used, meaning that a definition is required.

StringRef getName() const

This represents one expression.

StringRef getName() const

The name of this FileEntry.

DirectoryEntryRef getDir() const

One of these records is kept for each identifier that is lexed.

StringRef getName() const

Return the actual identifier string.

IdentifierInfo & get(StringRef Name)

Return the identifier token info for the specified named identifier.

Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...

clang::ObjCRuntime ObjCRuntime

std::string ObjCConstantStringClass

IdentifierInfo * getIdentifier() const

Get the identifier that names this declaration, if there is one.

Visibility getVisibility() const

Determines the visibility of this entity.

std::string getNameAsString() const

Get a human-readable name for the declaration, even if it is one of the special kinds of names (C++ c...

Represents Objective-C's @synchronized statement.

Represents Objective-C's @throw statement.

Represents Objective-C's @try ... @catch ... @finally statement.

ObjCCategoryDecl - Represents a category declaration.

const ObjCProtocolList & getReferencedProtocols() const

ObjCCategoryImplDecl - An object of this class encapsulates a category @implementation declaration.

ObjCCategoryDecl * getCategoryDecl() const

ObjCCompatibleAliasDecl - Represents alias of a class.

const ObjCInterfaceDecl * getClassInterface() const

ObjCContainerDecl - Represents a container for method declarations.

classmeth_iterator classmeth_end() const

classmeth_iterator classmeth_begin() const

instmeth_range instance_methods() const

instmeth_iterator instmeth_end() const

instmeth_iterator instmeth_begin() const

prop_range properties() const

classmeth_range class_methods() const

propimpl_range property_impls() const

const ObjCInterfaceDecl * getClassInterface() const

ObjCImplementationDecl - Represents a class definition - this is where method definitions are specifi...

Represents an ObjC class declaration.

all_protocol_range all_referenced_protocols() const

ObjCIvarDecl * all_declared_ivar_begin()

all_declared_ivar_begin - return first ivar declared in this class, its extensions and its implementa...

protocol_range protocols() const

protocol_iterator protocol_end() const

protocol_iterator protocol_begin() const

ObjCInterfaceDecl * getSuperClass() const

ObjCInterfaceDecl * getDefinition()

Retrieve the definition of this class, or NULL if this class has been forward-declared (with @class) ...

known_extensions_range known_extensions() const

Interfaces are the core concept in Objective-C for object oriented design.

ObjCInterfaceDecl * getDecl() const

Get the declaration of this interface.

ObjCIvarDecl - Represents an ObjC instance variable.

AccessControl getAccessControl() const

ObjCInterfaceDecl * getContainingInterface()

Return the class interface that this ivar is logically contained in; this is either the interface whe...

ObjCIvarDecl * getNextIvar()

ObjCMethodDecl - Represents an instance or class method declaration.

ImplicitParamDecl * getSelfDecl() const

bool hasParamDestroyedInCallee() const

True if the method has a parameter that's destroyed in the callee.

Stmt * getBody() const override

Retrieve the body of this method, if it has one.

ObjCMethodDecl * getCanonicalDecl() override

Retrieves the "canonical" declaration of the given declaration.

bool isDirectMethod() const

True if the method is tagged as objc_direct.

Selector getSelector() const

ImplicitParamDecl * getCmdDecl() const

QualType getReturnType() const

bool isClassMethod() const

ObjCInterfaceDecl * getClassInterface()

Represents a pointer to an Objective C object.

const ObjCObjectType * getObjectType() const

Gets the type pointed to by this ObjC pointer.

const ObjCInterfaceType * getInterfaceType() const

If this pointer points to an Objective C @interface type, gets the type for that interface.

Represents a class type in Objective C.

ObjCInterfaceDecl * getInterface() const

Gets the interface declaration for this object type, if the base type really is an interface.

Represents one property declaration in an Objective-C interface.

ObjCMethodDecl * getGetterMethodDecl() const

ObjCMethodDecl * getSetterMethodDecl() const

Represents an Objective-C protocol declaration.

ObjCProtocolDecl * getDefinition()

Retrieve the definition of this protocol, if any.

bool isNonRuntimeProtocol() const

This is true iff the protocol is tagged with the objc_non_runtime_protocol attribute.

protocol_iterator protocol_begin() const

protocol_range protocols() const

protocol_iterator protocol_end() const

The basic abstraction for the target Objective-C runtime.

const VersionTuple & getVersion() const

bool isNonFragile() const

Does this runtime follow the set of implied behaviors for a "non-fragile" ABI?

Kind

The basic Objective-C runtimes that we know about.

@ MacOSX

'macosx' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the non-fragile AB...

@ FragileMacOSX

'macosx-fragile' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...

@ GNUstep

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

@ ObjFW

'objfw' is the Objective-C runtime included in ObjFW

@ iOS

'ios' is the Apple-provided NeXT-derived runtime on iOS or the iOS simulator; it is always non-fragil...

@ GCC

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

@ WatchOS

'watchos' is a variant of iOS for Apple's watchOS.

A (possibly-)qualified type.

@ OCL_Strong

Assigning into this object requires the old value to be released and the new value to be retained.

@ OCL_ExplicitNone

This object can be modified without requiring retains or releases.

@ OCL_None

There is no lifetime qualification on this type.

@ OCL_Weak

Reading or writing from this object requires a barrier call.

@ OCL_Autoreleasing

Assigning into this object requires a lifetime extension.

This table allows us to fully hide how we implement multi-keyword caching.

Smart pointer class that efficiently represents Objective-C method names.

std::string getAsString() const

Derive the full selector name (e.g.

This class handles loading and caching of source files into memory.

StringLiteral - This represents a string literal expression, e.g.

bool containsNonAscii() const

unsigned getLength() const

uint32_t getCodeUnit(size_t i) const

StringRef getString() const

const llvm::Triple & getTriple() const

Returns the target triple of the primary target.

uint64_t getPointerWidth(LangAS AddrSpace) const

Return the width of pointers on this target, for the specified address space.

The top declaration context.

static DeclContext * castToDeclContext(const TranslationUnitDecl *D)

const T * castAs() const

Member-template castAs<specific type>.

bool isObjCQualifiedIdType() const

QualType getPointeeType() const

If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.

bool isIntegralOrEnumerationType() const

Determine whether this type is an integral or enumeration type.

bool isObjCIdType() const

const T * getAs() const

Member-template getAs<specific type>'.

bool hasPointerRepresentation() const

Whether this type is represented natively as a pointer.

Represents a variable declaration or definition.

CGObjCRuntime * CreateGNUObjCRuntime(CodeGenModule &CGM)

Creates an instance of an Objective-C runtime class.

constexpr size_t align(size_t Size)

Aligns a size to the pointer alignment.

bool Zero(InterpState &S, CodePtr OpPC)

RangeSelector node(std::string ID)

Selects a node, including trailing semicolon, if any (for declarations and non-expression statements)...

RangeSelector name(std::string ID)

Given a node with a "name", (like NamedDecl, DeclRefExpr, CxxCtorInitializer, and TypeLoc) selects th...

The JSON file list parser is used to communicate input to InstallAPI.

bool isa(CodeGen::Address addr)

CanQual< Type > CanQualType

Represents a canonical, potentially-qualified type.

Selector GetNullarySelector(StringRef name, ASTContext &Ctx)

Utility function for constructing a nullary selector.

const FunctionProtoType * T

@ Interface

The "__interface" keyword introduces the elaborated-type-specifier.

@ Class

The "class" keyword introduces the elaborated-type-specifier.

@ HiddenVisibility

Objects with "hidden" visibility are not seen by the dynamic linker.

The MS C++ ABI needs a pointer to RTTI data plus some flags to describe the type of a catch handler,...

CharUnits getIntAlign() const

llvm::IntegerType * Int16Ty

llvm::PointerType * Int8PtrTy

CharUnits getPointerAlign() const

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4