clang 22.0.0git
CGObjCGNU.cpp
Go to the documentation of this file.
1//===------- CGObjCGNU.cpp - Emit LLVM Code from ASTs for a Module --------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This provides Objective-C code generation targeting the GNU runtime. The
10// class in this file generates structures used by the GNU Objective-C runtime
11// library. These structures are defined in objc/objc.h and objc/objc-api.h in
12// the GNU runtime distribution.
13//
14//===----------------------------------------------------------------------===//
15
16#include "CGCXXABI.h"
17#include "CGCleanup.h"
18#include "CGObjCRuntime.h"
19#include "CodeGenFunction.h"
20#include "CodeGenModule.h"
21#include "CodeGenTypes.h"
22#include "SanitizerMetadata.h"
24#include "clang/AST/Attr.h"
25#include "clang/AST/Decl.h"
26#include "clang/AST/DeclObjC.h"
28#include "clang/AST/StmtObjC.h"
31#include "llvm/ADT/SmallVector.h"
32#include "llvm/ADT/StringMap.h"
33#include "llvm/IR/DataLayout.h"
34#include "llvm/IR/Intrinsics.h"
35#include "llvm/IR/LLVMContext.h"
36#include "llvm/IR/Module.h"
37#include "llvm/Support/Compiler.h"
38#include "llvm/Support/ConvertUTF.h"
39#include <cctype>
40
41using namespace clang;
42using namespace CodeGen;
43
44namespace {
45
46/// Class that lazily initialises the runtime function. Avoids inserting the
47/// types and the function declaration into a module if they're not used, and
48/// avoids constructing the type more than once if it's used more than once.
49class LazyRuntimeFunction {
50 CodeGenModule *CGM = nullptr;
51 llvm::FunctionType *FTy = nullptr;
52 const char *FunctionName = nullptr;
53 llvm::FunctionCallee Function = nullptr;
54
55public:
56 LazyRuntimeFunction() = default;
57
58 /// Initialises the lazy function with the name, return type, and the types
59 /// of the arguments.
60 template <typename... Tys>
61 void init(CodeGenModule *Mod, const char *name, llvm::Type *RetTy,
62 Tys *... Types) {
63 CGM = Mod;
64 FunctionName = name;
65 Function = nullptr;
66 if(sizeof...(Tys)) {
67 SmallVector<llvm::Type *, 8> ArgTys({Types...});
68 FTy = llvm::FunctionType::get(RetTy, ArgTys, false);
69 }
70 else {
71 FTy = llvm::FunctionType::get(RetTy, {}, false);
72 }
73 }
74
75 llvm::FunctionType *getType() { return FTy; }
76
77 /// Overloaded cast operator, allows the class to be implicitly cast to an
78 /// LLVM constant.
79 operator llvm::FunctionCallee() {
80 if (!Function) {
81 if (!FunctionName)
82 return nullptr;
83 Function = CGM->CreateRuntimeFunction(FTy, FunctionName);
84 }
85 return Function;
86 }
87};
88
89
90/// GNU Objective-C runtime code generation. This class implements the parts of
91/// Objective-C support that are specific to the GNU family of runtimes (GCC,
92/// GNUstep and ObjFW).
93class CGObjCGNU : public CGObjCRuntime {
94protected:
95 /// The LLVM module into which output is inserted
96 llvm::Module &TheModule;
97 /// strut objc_super. Used for sending messages to super. This structure
98 /// contains the receiver (object) and the expected class.
99 llvm::StructType *ObjCSuperTy;
100 /// struct objc_super*. The type of the argument to the superclass message
101 /// lookup functions.
102 llvm::PointerType *PtrToObjCSuperTy;
103 /// LLVM type for selectors. Opaque pointer (i8*) unless a header declaring
104 /// SEL is included in a header somewhere, in which case it will be whatever
105 /// type is declared in that header, most likely {i8*, i8*}.
106 llvm::PointerType *SelectorTy;
107 /// Element type of SelectorTy.
108 llvm::Type *SelectorElemTy;
109 /// LLVM i8 type. Cached here to avoid repeatedly getting it in all of the
110 /// places where it's used
111 llvm::IntegerType *Int8Ty;
112 /// Pointer to i8 - LLVM type of char*, for all of the places where the
113 /// runtime needs to deal with C strings.
114 llvm::PointerType *PtrToInt8Ty;
115 /// struct objc_protocol type
116 llvm::StructType *ProtocolTy;
117 /// Protocol * type.
118 llvm::PointerType *ProtocolPtrTy;
119 /// Instance Method Pointer type. This is a pointer to a function that takes,
120 /// at a minimum, an object and a selector, and is the generic type for
121 /// Objective-C methods. Due to differences between variadic / non-variadic
122 /// calling conventions, it must always be cast to the correct type before
123 /// actually being used.
124 llvm::PointerType *IMPTy;
125 /// Type of an untyped Objective-C object. Clang treats id as a built-in type
126 /// when compiling Objective-C code, so this may be an opaque pointer (i8*),
127 /// but if the runtime header declaring it is included then it may be a
128 /// pointer to a structure.
129 llvm::PointerType *IdTy;
130 /// Element type of IdTy.
131 llvm::Type *IdElemTy;
132 /// Pointer to a pointer to an Objective-C object. Used in the new ABI
133 /// message lookup function and some GC-related functions.
134 llvm::PointerType *PtrToIdTy;
135 /// The clang type of id. Used when using the clang CGCall infrastructure to
136 /// call Objective-C methods.
137 CanQualType ASTIdTy;
138 /// LLVM type for C int type.
139 llvm::IntegerType *IntTy;
140 /// LLVM type for an opaque pointer. This is identical to PtrToInt8Ty, but is
141 /// used in the code to document the difference between i8* meaning a pointer
142 /// to a C string and i8* meaning a pointer to some opaque type.
143 llvm::PointerType *PtrTy;
144 /// LLVM type for C long type. The runtime uses this in a lot of places where
145 /// it should be using intptr_t, but we can't fix this without breaking
146 /// compatibility with GCC...
147 llvm::IntegerType *LongTy;
148 /// LLVM type for C size_t. Used in various runtime data structures.
149 llvm::IntegerType *SizeTy;
150 /// LLVM type for C intptr_t.
151 llvm::IntegerType *IntPtrTy;
152 /// LLVM type for C ptrdiff_t. Mainly used in property accessor functions.
153 llvm::IntegerType *PtrDiffTy;
154 /// LLVM type for C int*. Used for GCC-ABI-compatible non-fragile instance
155 /// variables.
156 llvm::PointerType *PtrToIntTy;
157 /// LLVM type for Objective-C BOOL type.
158 llvm::Type *BoolTy;
159 /// 32-bit integer type, to save us needing to look it up every time it's used.
160 llvm::IntegerType *Int32Ty;
161 /// 64-bit integer type, to save us needing to look it up every time it's used.
162 llvm::IntegerType *Int64Ty;
163 /// The type of struct objc_property.
164 llvm::StructType *PropertyMetadataTy;
165 /// Metadata kind used to tie method lookups to message sends. The GNUstep
166 /// runtime provides some LLVM passes that can use this to do things like
167 /// automatic IMP caching and speculative inlining.
168 unsigned msgSendMDKind;
169 /// Does the current target use SEH-based exceptions? False implies
170 /// Itanium-style DWARF unwinding.
171 bool usesSEHExceptions;
172 /// Does the current target uses C++-based exceptions?
173 bool usesCxxExceptions;
174
175 /// Helper to check if we are targeting a specific runtime version or later.
176 bool isRuntime(ObjCRuntime::Kind kind, unsigned major, unsigned minor=0) {
177 const ObjCRuntime &R = CGM.getLangOpts().ObjCRuntime;
178 return (R.getKind() == kind) &&
179 (R.getVersion() >= VersionTuple(major, minor));
180 }
181
182 std::string ManglePublicSymbol(StringRef Name) {
183 return (StringRef(CGM.getTriple().isOSBinFormatCOFF() ? "$_" : "._") + Name).str();
184 }
185
186 std::string SymbolForProtocol(Twine Name) {
187 return (ManglePublicSymbol("OBJC_PROTOCOL_") + Name).str();
188 }
189
190 std::string SymbolForProtocolRef(StringRef Name) {
191 return (ManglePublicSymbol("OBJC_REF_PROTOCOL_") + Name).str();
192 }
193
194
195 /// Helper function that generates a constant string and returns a pointer to
196 /// the start of the string. The result of this function can be used anywhere
197 /// where the C code specifies const char*.
198 llvm::Constant *MakeConstantString(StringRef Str, StringRef Name = "") {
199 ConstantAddress Array =
200 CGM.GetAddrOfConstantCString(std::string(Str), Name);
201 return Array.getPointer();
202 }
203
204 /// Emits a linkonce_odr string, whose name is the prefix followed by the
205 /// string value. This allows the linker to combine the strings between
206 /// different modules. Used for EH typeinfo names, selector strings, and a
207 /// few other things.
208 llvm::Constant *ExportUniqueString(const std::string &Str,
209 const std::string &prefix,
210 bool Private=false) {
211 std::string name = prefix + Str;
212 auto *ConstStr = TheModule.getGlobalVariable(name);
213 if (!ConstStr) {
214 llvm::Constant *value = llvm::ConstantDataArray::getString(VMContext,Str);
215 auto *GV = new llvm::GlobalVariable(TheModule, value->getType(), true,
216 llvm::GlobalValue::LinkOnceODRLinkage, value, name);
217 GV->setComdat(TheModule.getOrInsertComdat(name));
218 if (Private)
219 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
220 ConstStr = GV;
221 }
222 return ConstStr;
223 }
224
225 /// Returns a property name and encoding string.
226 llvm::Constant *MakePropertyEncodingString(const ObjCPropertyDecl *PD,
227 const Decl *Container) {
228 assert(!isRuntime(ObjCRuntime::GNUstep, 2));
229 if (isRuntime(ObjCRuntime::GNUstep, 1, 6)) {
230 std::string NameAndAttributes;
231 std::string TypeStr =
232 CGM.getContext().getObjCEncodingForPropertyDecl(PD, Container);
233 NameAndAttributes += '\0';
234 NameAndAttributes += TypeStr.length() + 3;
235 NameAndAttributes += TypeStr;
236 NameAndAttributes += '\0';
237 NameAndAttributes += PD->getNameAsString();
238 return MakeConstantString(NameAndAttributes);
239 }
240 return MakeConstantString(PD->getNameAsString());
241 }
242
243 /// Push the property attributes into two structure fields.
244 void PushPropertyAttributes(ConstantStructBuilder &Fields,
245 const ObjCPropertyDecl *property, bool isSynthesized=true, bool
246 isDynamic=true) {
247 int attrs = property->getPropertyAttributes();
248 // For read-only properties, clear the copy and retain flags
250 attrs &= ~ObjCPropertyAttribute::kind_copy;
251 attrs &= ~ObjCPropertyAttribute::kind_retain;
252 attrs &= ~ObjCPropertyAttribute::kind_weak;
253 attrs &= ~ObjCPropertyAttribute::kind_strong;
254 }
255 // The first flags field has the same attribute values as clang uses internally
256 Fields.addInt(Int8Ty, attrs & 0xff);
257 attrs >>= 8;
258 attrs <<= 2;
259 // For protocol properties, synthesized and dynamic have no meaning, so we
260 // reuse these flags to indicate that this is a protocol property (both set
261 // has no meaning, as a property can't be both synthesized and dynamic)
262 attrs |= isSynthesized ? (1<<0) : 0;
263 attrs |= isDynamic ? (1<<1) : 0;
264 // The second field is the next four fields left shifted by two, with the
265 // low bit set to indicate whether the field is synthesized or dynamic.
266 Fields.addInt(Int8Ty, attrs & 0xff);
267 // Two padding fields
268 Fields.addInt(Int8Ty, 0);
269 Fields.addInt(Int8Ty, 0);
270 }
271
272 virtual llvm::Constant *GenerateCategoryProtocolList(const
273 ObjCCategoryDecl *OCD);
274 virtual ConstantArrayBuilder PushPropertyListHeader(ConstantStructBuilder &Fields,
275 int count) {
276 // int count;
277 Fields.addInt(IntTy, count);
278 // int size; (only in GNUstep v2 ABI.
279 if (isRuntime(ObjCRuntime::GNUstep, 2)) {
280 const llvm::DataLayout &DL = TheModule.getDataLayout();
281 Fields.addInt(IntTy, DL.getTypeSizeInBits(PropertyMetadataTy) /
282 CGM.getContext().getCharWidth());
283 }
284 // struct objc_property_list *next;
285 Fields.add(NULLPtr);
286 // struct objc_property properties[]
287 return Fields.beginArray(PropertyMetadataTy);
288 }
289 virtual void PushProperty(ConstantArrayBuilder &PropertiesArray,
290 const ObjCPropertyDecl *property,
291 const Decl *OCD,
292 bool isSynthesized=true, bool
293 isDynamic=true) {
294 auto Fields = PropertiesArray.beginStruct(PropertyMetadataTy);
295 ASTContext &Context = CGM.getContext();
296 Fields.add(MakePropertyEncodingString(property, OCD));
297 PushPropertyAttributes(Fields, property, isSynthesized, isDynamic);
298 auto addPropertyMethod = [&](const ObjCMethodDecl *accessor) {
299 if (accessor) {
300 std::string TypeStr = Context.getObjCEncodingForMethodDecl(accessor);
301 llvm::Constant *TypeEncoding = MakeConstantString(TypeStr);
302 Fields.add(MakeConstantString(accessor->getSelector().getAsString()));
303 Fields.add(TypeEncoding);
304 } else {
305 Fields.add(NULLPtr);
306 Fields.add(NULLPtr);
307 }
308 };
309 addPropertyMethod(property->getGetterMethodDecl());
310 addPropertyMethod(property->getSetterMethodDecl());
311 Fields.finishAndAddTo(PropertiesArray);
312 }
313
314 /// Ensures that the value has the required type, by inserting a bitcast if
315 /// required. This function lets us avoid inserting bitcasts that are
316 /// redundant.
317 llvm::Value *EnforceType(CGBuilderTy &B, llvm::Value *V, llvm::Type *Ty) {
318 if (V->getType() == Ty)
319 return V;
320 return B.CreateBitCast(V, Ty);
321 }
322
323 // Some zeros used for GEPs in lots of places.
324 llvm::Constant *Zeros[2];
325 /// Null pointer value. Mainly used as a terminator in various arrays.
326 llvm::Constant *NULLPtr;
327 /// LLVM context.
328 llvm::LLVMContext &VMContext;
329
330protected:
331
332 /// Placeholder for the class. Lots of things refer to the class before we've
333 /// actually emitted it. We use this alias as a placeholder, and then replace
334 /// it with a pointer to the class structure before finally emitting the
335 /// module.
336 llvm::GlobalAlias *ClassPtrAlias;
337 /// Placeholder for the metaclass. Lots of things refer to the class before
338 /// we've / actually emitted it. We use this alias as a placeholder, and then
339 /// replace / it with a pointer to the metaclass structure before finally
340 /// emitting the / module.
341 llvm::GlobalAlias *MetaClassPtrAlias;
342 /// All of the classes that have been generated for this compilation units.
343 std::vector<llvm::Constant*> Classes;
344 /// All of the categories that have been generated for this compilation units.
345 std::vector<llvm::Constant*> Categories;
346 /// All of the Objective-C constant strings that have been generated for this
347 /// compilation units.
348 std::vector<llvm::Constant*> ConstantStrings;
349 /// Map from string values to Objective-C constant strings in the output.
350 /// Used to prevent emitting Objective-C strings more than once. This should
351 /// not be required at all - CodeGenModule should manage this list.
352 llvm::StringMap<llvm::Constant*> ObjCStrings;
353 /// All of the protocols that have been declared.
354 llvm::StringMap<llvm::Constant*> ExistingProtocols;
355 /// For each variant of a selector, we store the type encoding and a
356 /// placeholder value. For an untyped selector, the type will be the empty
357 /// string. Selector references are all done via the module's selector table,
358 /// so we create an alias as a placeholder and then replace it with the real
359 /// value later.
360 typedef std::pair<std::string, llvm::GlobalAlias*> TypedSelector;
361 /// Type of the selector map. This is roughly equivalent to the structure
362 /// used in the GNUstep runtime, which maintains a list of all of the valid
363 /// types for a selector in a table.
364 typedef llvm::DenseMap<Selector, SmallVector<TypedSelector, 2> >
365 SelectorMap;
366 /// A map from selectors to selector types. This allows us to emit all
367 /// selectors of the same name and type together.
368 SelectorMap SelectorTable;
369
370 /// Selectors related to memory management. When compiling in GC mode, we
371 /// omit these.
372 Selector RetainSel, ReleaseSel, AutoreleaseSel;
373 /// Runtime functions used for memory management in GC mode. Note that clang
374 /// supports code generation for calling these functions, but neither GNU
375 /// runtime actually supports this API properly yet.
376 LazyRuntimeFunction IvarAssignFn, StrongCastAssignFn, MemMoveFn, WeakReadFn,
377 WeakAssignFn, GlobalAssignFn;
378
379 typedef std::pair<std::string, std::string> ClassAliasPair;
380 /// All classes that have aliases set for them.
381 std::vector<ClassAliasPair> ClassAliases;
382
383protected:
384 /// Function used for throwing Objective-C exceptions.
385 LazyRuntimeFunction ExceptionThrowFn;
386 /// Function used for rethrowing exceptions, used at the end of \@finally or
387 /// \@synchronize blocks.
388 LazyRuntimeFunction ExceptionReThrowFn;
389 /// Function called when entering a catch function. This is required for
390 /// differentiating Objective-C exceptions and foreign exceptions.
391 LazyRuntimeFunction EnterCatchFn;
392 /// Function called when exiting from a catch block. Used to do exception
393 /// cleanup.
394 LazyRuntimeFunction ExitCatchFn;
395 /// Function called when entering an \@synchronize block. Acquires the lock.
396 LazyRuntimeFunction SyncEnterFn;
397 /// Function called when exiting an \@synchronize block. Releases the lock.
398 LazyRuntimeFunction SyncExitFn;
399
400private:
401 /// Function called if fast enumeration detects that the collection is
402 /// modified during the update.
403 LazyRuntimeFunction EnumerationMutationFn;
404 /// Function for implementing synthesized property getters that return an
405 /// object.
406 LazyRuntimeFunction GetPropertyFn;
407 /// Function for implementing synthesized property setters that return an
408 /// object.
409 LazyRuntimeFunction SetPropertyFn;
410 /// Function used for non-object declared property getters.
411 LazyRuntimeFunction GetStructPropertyFn;
412 /// Function used for non-object declared property setters.
413 LazyRuntimeFunction SetStructPropertyFn;
414
415protected:
416 /// The version of the runtime that this class targets. Must match the
417 /// version in the runtime.
418 int RuntimeVersion;
419 /// The version of the protocol class. Used to differentiate between ObjC1
420 /// and ObjC2 protocols. Objective-C 1 protocols can not contain optional
421 /// components and can not contain declared properties. We always emit
422 /// Objective-C 2 property structures, but we have to pretend that they're
423 /// Objective-C 1 property structures when targeting the GCC runtime or it
424 /// will abort.
425 const int ProtocolVersion;
426 /// The version of the class ABI. This value is used in the class structure
427 /// and indicates how various fields should be interpreted.
428 const int ClassABIVersion;
429 /// Generates an instance variable list structure. This is a structure
430 /// containing a size and an array of structures containing instance variable
431 /// metadata. This is used purely for introspection in the fragile ABI. In
432 /// the non-fragile ABI, it's used for instance variable fixup.
433 virtual llvm::Constant *GenerateIvarList(ArrayRef<llvm::Constant *> IvarNames,
434 ArrayRef<llvm::Constant *> IvarTypes,
435 ArrayRef<llvm::Constant *> IvarOffsets,
436 ArrayRef<llvm::Constant *> IvarAlign,
437 ArrayRef<Qualifiers::ObjCLifetime> IvarOwnership);
438
439 /// Generates a method list structure. This is a structure containing a size
440 /// and an array of structures containing method metadata.
441 ///
442 /// This structure is used by both classes and categories, and contains a next
443 /// pointer allowing them to be chained together in a linked list.
444 llvm::Constant *GenerateMethodList(StringRef ClassName,
445 StringRef CategoryName,
446 ArrayRef<const ObjCMethodDecl*> Methods,
447 bool isClassMethodList);
448
449 /// Emits an empty protocol. This is used for \@protocol() where no protocol
450 /// is found. The runtime will (hopefully) fix up the pointer to refer to the
451 /// real protocol.
452 virtual llvm::Constant *GenerateEmptyProtocol(StringRef ProtocolName);
453
454 /// Generates a list of property metadata structures. This follows the same
455 /// pattern as method and instance variable metadata lists.
456 llvm::Constant *GeneratePropertyList(const Decl *Container,
457 const ObjCContainerDecl *OCD,
458 bool isClassProperty=false,
459 bool protocolOptionalProperties=false);
460
461 /// Generates a list of referenced protocols. Classes, categories, and
462 /// protocols all use this structure.
463 llvm::Constant *GenerateProtocolList(ArrayRef<std::string> Protocols);
464
465 /// To ensure that all protocols are seen by the runtime, we add a category on
466 /// a class defined in the runtime, declaring no methods, but adopting the
467 /// protocols. This is a horribly ugly hack, but it allows us to collect all
468 /// of the protocols without changing the ABI.
469 void GenerateProtocolHolderCategory();
470
471 /// Generates a class structure.
472 llvm::Constant *GenerateClassStructure(
473 llvm::Constant *MetaClass,
474 llvm::Constant *SuperClass,
475 unsigned info,
476 const char *Name,
477 llvm::Constant *Version,
478 llvm::Constant *InstanceSize,
479 llvm::Constant *IVars,
480 llvm::Constant *Methods,
481 llvm::Constant *Protocols,
482 llvm::Constant *IvarOffsets,
483 llvm::Constant *Properties,
484 llvm::Constant *StrongIvarBitmap,
485 llvm::Constant *WeakIvarBitmap,
486 bool isMeta=false);
487
488 /// Generates a method list. This is used by protocols to define the required
489 /// and optional methods.
490 virtual llvm::Constant *GenerateProtocolMethodList(
491 ArrayRef<const ObjCMethodDecl*> Methods);
492 /// Emits optional and required method lists.
493 template<class T>
494 void EmitProtocolMethodList(T &&Methods, llvm::Constant *&Required,
495 llvm::Constant *&Optional) {
496 SmallVector<const ObjCMethodDecl*, 16> RequiredMethods;
497 SmallVector<const ObjCMethodDecl*, 16> OptionalMethods;
498 for (const auto *I : Methods)
499 if (I->isOptional())
500 OptionalMethods.push_back(I);
501 else
502 RequiredMethods.push_back(I);
503 Required = GenerateProtocolMethodList(RequiredMethods);
504 Optional = GenerateProtocolMethodList(OptionalMethods);
505 }
506
507 /// Returns a selector with the specified type encoding. An empty string is
508 /// used to return an untyped selector (with the types field set to NULL).
509 virtual llvm::Value *GetTypedSelector(CodeGenFunction &CGF, Selector Sel,
510 const std::string &TypeEncoding);
511
512 /// Returns the name of ivar offset variables. In the GNUstep v1 ABI, this
513 /// contains the class and ivar names, in the v2 ABI this contains the type
514 /// encoding as well.
515 virtual std::string GetIVarOffsetVariableName(const ObjCInterfaceDecl *ID,
516 const ObjCIvarDecl *Ivar) {
517 const std::string Name = "__objc_ivar_offset_" + ID->getNameAsString()
518 + '.' + Ivar->getNameAsString();
519 return Name;
520 }
521 /// Returns the variable used to store the offset of an instance variable.
522 llvm::GlobalVariable *ObjCIvarOffsetVariable(const ObjCInterfaceDecl *ID,
523 const ObjCIvarDecl *Ivar);
524 /// Emits a reference to a class. This allows the linker to object if there
525 /// is no class of the matching name.
526 void EmitClassRef(const std::string &className);
527
528 /// Emits a pointer to the named class
529 virtual llvm::Value *GetClassNamed(CodeGenFunction &CGF,
530 const std::string &Name, bool isWeak);
531
532 /// Looks up the method for sending a message to the specified object. This
533 /// mechanism differs between the GCC and GNU runtimes, so this method must be
534 /// overridden in subclasses.
535 virtual llvm::Value *LookupIMP(CodeGenFunction &CGF,
536 llvm::Value *&Receiver,
537 llvm::Value *cmd,
538 llvm::MDNode *node,
539 MessageSendInfo &MSI) = 0;
540
541 /// Looks up the method for sending a message to a superclass. This
542 /// mechanism differs between the GCC and GNU runtimes, so this method must
543 /// be overridden in subclasses.
544 virtual llvm::Value *LookupIMPSuper(CodeGenFunction &CGF,
545 Address ObjCSuper,
546 llvm::Value *cmd,
547 MessageSendInfo &MSI) = 0;
548
549 /// Libobjc2 uses a bitfield representation where small(ish) bitfields are
550 /// stored in a 64-bit value with the low bit set to 1 and the remaining 63
551 /// bits set to their values, LSB first, while larger ones are stored in a
552 /// structure of this / form:
553 ///
554 /// struct { int32_t length; int32_t values[length]; };
555 ///
556 /// The values in the array are stored in host-endian format, with the least
557 /// significant bit being assumed to come first in the bitfield. Therefore,
558 /// a bitfield with the 64th bit set will be (int64_t)&{ 2, [0, 1<<31] },
559 /// while a bitfield / with the 63rd bit set will be 1<<64.
560 llvm::Constant *MakeBitField(ArrayRef<bool> bits);
561
562public:
563 CGObjCGNU(CodeGenModule &cgm, unsigned runtimeABIVersion,
564 unsigned protocolClassVersion, unsigned classABI=1);
565
566 ConstantAddress GenerateConstantString(const StringLiteral *) override;
567
568 RValue
569 GenerateMessageSend(CodeGenFunction &CGF, ReturnValueSlot Return,
570 QualType ResultType, Selector Sel,
571 llvm::Value *Receiver, const CallArgList &CallArgs,
572 const ObjCInterfaceDecl *Class,
573 const ObjCMethodDecl *Method) override;
574 RValue
575 GenerateMessageSendSuper(CodeGenFunction &CGF, ReturnValueSlot Return,
576 QualType ResultType, Selector Sel,
577 const ObjCInterfaceDecl *Class,
578 bool isCategoryImpl, llvm::Value *Receiver,
579 bool IsClassMessage, const CallArgList &CallArgs,
580 const ObjCMethodDecl *Method) override;
581 llvm::Value *GetClass(CodeGenFunction &CGF,
582 const ObjCInterfaceDecl *OID) override;
583 llvm::Value *GetSelector(CodeGenFunction &CGF, Selector Sel) override;
584 Address GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) override;
585 llvm::Value *GetSelector(CodeGenFunction &CGF,
586 const ObjCMethodDecl *Method) override;
587 virtual llvm::Constant *GetConstantSelector(Selector Sel,
588 const std::string &TypeEncoding) {
589 llvm_unreachable("Runtime unable to generate constant selector");
590 }
591 llvm::Constant *GetConstantSelector(const ObjCMethodDecl *M) {
592 return GetConstantSelector(M->getSelector(),
594 }
595 llvm::Constant *GetEHType(QualType T) override;
596
597 llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
598 const ObjCContainerDecl *CD) override;
599
600 // Map to unify direct method definitions.
601 llvm::DenseMap<const ObjCMethodDecl *, llvm::Function *>
602 DirectMethodDefinitions;
603 void GenerateDirectMethodPrologue(CodeGenFunction &CGF, llvm::Function *Fn,
604 const ObjCMethodDecl *OMD,
605 const ObjCContainerDecl *CD) override;
606 void GenerateCategory(const ObjCCategoryImplDecl *CMD) override;
607 void GenerateClass(const ObjCImplementationDecl *ClassDecl) override;
608 void RegisterAlias(const ObjCCompatibleAliasDecl *OAD) override;
609 llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
610 const ObjCProtocolDecl *PD) override;
611 void GenerateProtocol(const ObjCProtocolDecl *PD) override;
612
613 virtual llvm::Constant *GenerateProtocolRef(const ObjCProtocolDecl *PD);
614
615 llvm::Constant *GetOrEmitProtocol(const ObjCProtocolDecl *PD) override {
616 return GenerateProtocolRef(PD);
617 }
618
619 llvm::Function *ModuleInitFunction() override;
620 llvm::FunctionCallee GetPropertyGetFunction() override;
621 llvm::FunctionCallee GetPropertySetFunction() override;
622 llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic,
623 bool copy) override;
624 llvm::FunctionCallee GetSetStructFunction() override;
625 llvm::FunctionCallee GetGetStructFunction() override;
626 llvm::FunctionCallee GetCppAtomicObjectGetFunction() override;
627 llvm::FunctionCallee GetCppAtomicObjectSetFunction() override;
628 llvm::FunctionCallee EnumerationMutationFunction() override;
629
630 void EmitTryStmt(CodeGenFunction &CGF,
631 const ObjCAtTryStmt &S) override;
632 void EmitSynchronizedStmt(CodeGenFunction &CGF,
633 const ObjCAtSynchronizedStmt &S) override;
634 void EmitThrowStmt(CodeGenFunction &CGF,
635 const ObjCAtThrowStmt &S,
636 bool ClearInsertionPoint=true) override;
637 llvm::Value * EmitObjCWeakRead(CodeGenFunction &CGF,
638 Address AddrWeakObj) override;
639 void EmitObjCWeakAssign(CodeGenFunction &CGF,
640 llvm::Value *src, Address dst) override;
641 void EmitObjCGlobalAssign(CodeGenFunction &CGF,
642 llvm::Value *src, Address dest,
643 bool threadlocal=false) override;
644 void EmitObjCIvarAssign(CodeGenFunction &CGF, llvm::Value *src,
645 Address dest, llvm::Value *ivarOffset) override;
646 void EmitObjCStrongCastAssign(CodeGenFunction &CGF,
647 llvm::Value *src, Address dest) override;
648 void EmitGCMemmoveCollectable(CodeGenFunction &CGF, Address DestPtr,
649 Address SrcPtr,
650 llvm::Value *Size) override;
651 LValue EmitObjCValueForIvar(CodeGenFunction &CGF, QualType ObjectTy,
652 llvm::Value *BaseValue, const ObjCIvarDecl *Ivar,
653 unsigned CVRQualifiers) override;
654 llvm::Value *EmitIvarOffset(CodeGenFunction &CGF,
655 const ObjCInterfaceDecl *Interface,
656 const ObjCIvarDecl *Ivar) override;
657 llvm::Value *EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) override;
658 llvm::Constant *BuildGCBlockLayout(CodeGenModule &CGM,
659 const CGBlockInfo &blockInfo) override {
660 return NULLPtr;
661 }
662 llvm::Constant *BuildRCBlockLayout(CodeGenModule &CGM,
663 const CGBlockInfo &blockInfo) override {
664 return NULLPtr;
665 }
666
667 llvm::Constant *BuildByrefLayout(CodeGenModule &CGM, QualType T) override {
668 return NULLPtr;
669 }
670};
671
672/// Class representing the legacy GCC Objective-C ABI. This is the default when
673/// -fobjc-nonfragile-abi is not specified.
674///
675/// The GCC ABI target actually generates code that is approximately compatible
676/// with the new GNUstep runtime ABI, but refrains from using any features that
677/// would not work with the GCC runtime. For example, clang always generates
678/// the extended form of the class structure, and the extra fields are simply
679/// ignored by GCC libobjc.
680class CGObjCGCC : public CGObjCGNU {
681 /// The GCC ABI message lookup function. Returns an IMP pointing to the
682 /// method implementation for this message.
683 LazyRuntimeFunction MsgLookupFn;
684 /// The GCC ABI superclass message lookup function. Takes a pointer to a
685 /// structure describing the receiver and the class, and a selector as
686 /// arguments. Returns the IMP for the corresponding method.
687 LazyRuntimeFunction MsgLookupSuperFn;
688
689protected:
690 llvm::Value *LookupIMP(CodeGenFunction &CGF, llvm::Value *&Receiver,
691 llvm::Value *cmd, llvm::MDNode *node,
692 MessageSendInfo &MSI) override {
693 CGBuilderTy &Builder = CGF.Builder;
694 llvm::Value *args[] = {
695 EnforceType(Builder, Receiver, IdTy),
696 EnforceType(Builder, cmd, SelectorTy) };
697 llvm::CallBase *imp = CGF.EmitRuntimeCallOrInvoke(MsgLookupFn, args);
698 imp->setMetadata(msgSendMDKind, node);
699 return imp;
700 }
701
702 llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper,
703 llvm::Value *cmd, MessageSendInfo &MSI) override {
704 CGBuilderTy &Builder = CGF.Builder;
705 llvm::Value *lookupArgs[] = {
706 EnforceType(Builder, ObjCSuper.emitRawPointer(CGF), PtrToObjCSuperTy),
707 cmd};
708 return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFn, lookupArgs);
709 }
710
711public:
712 CGObjCGCC(CodeGenModule &Mod) : CGObjCGNU(Mod, 8, 2) {
713 // IMP objc_msg_lookup(id, SEL);
714 MsgLookupFn.init(&CGM, "objc_msg_lookup", IMPTy, IdTy, SelectorTy);
715 // IMP objc_msg_lookup_super(struct objc_super*, SEL);
716 MsgLookupSuperFn.init(&CGM, "objc_msg_lookup_super", IMPTy,
717 PtrToObjCSuperTy, SelectorTy);
718 }
719};
720
721/// Class used when targeting the new GNUstep runtime ABI.
722class CGObjCGNUstep : public CGObjCGNU {
723 /// The slot lookup function. Returns a pointer to a cacheable structure
724 /// that contains (among other things) the IMP.
725 LazyRuntimeFunction SlotLookupFn;
726 /// The GNUstep ABI superclass message lookup function. Takes a pointer to
727 /// a structure describing the receiver and the class, and a selector as
728 /// arguments. Returns the slot for the corresponding method. Superclass
729 /// message lookup rarely changes, so this is a good caching opportunity.
730 LazyRuntimeFunction SlotLookupSuperFn;
731 /// Specialised function for setting atomic retain properties
732 LazyRuntimeFunction SetPropertyAtomic;
733 /// Specialised function for setting atomic copy properties
734 LazyRuntimeFunction SetPropertyAtomicCopy;
735 /// Specialised function for setting nonatomic retain properties
736 LazyRuntimeFunction SetPropertyNonAtomic;
737 /// Specialised function for setting nonatomic copy properties
738 LazyRuntimeFunction SetPropertyNonAtomicCopy;
739 /// Function to perform atomic copies of C++ objects with nontrivial copy
740 /// constructors from Objective-C ivars.
741 LazyRuntimeFunction CxxAtomicObjectGetFn;
742 /// Function to perform atomic copies of C++ objects with nontrivial copy
743 /// constructors to Objective-C ivars.
744 LazyRuntimeFunction CxxAtomicObjectSetFn;
745 /// Type of a slot structure pointer. This is returned by the various
746 /// lookup functions.
747 llvm::Type *SlotTy;
748 /// Type of a slot structure.
749 llvm::Type *SlotStructTy;
750
751 public:
752 llvm::Constant *GetEHType(QualType T) override;
753
754 protected:
755 llvm::Value *LookupIMP(CodeGenFunction &CGF, llvm::Value *&Receiver,
756 llvm::Value *cmd, llvm::MDNode *node,
757 MessageSendInfo &MSI) override {
758 CGBuilderTy &Builder = CGF.Builder;
759 llvm::FunctionCallee LookupFn = SlotLookupFn;
760
761 // Store the receiver on the stack so that we can reload it later
762 RawAddress ReceiverPtr =
763 CGF.CreateTempAlloca(Receiver->getType(), CGF.getPointerAlign());
764 Builder.CreateStore(Receiver, ReceiverPtr);
765
766 llvm::Value *self;
767
769 self = CGF.LoadObjCSelf();
770 } else {
771 self = llvm::ConstantPointerNull::get(IdTy);
772 }
773
774 // The lookup function is guaranteed not to capture the receiver pointer.
775 if (auto *LookupFn2 = dyn_cast<llvm::Function>(LookupFn.getCallee()))
776 LookupFn2->addParamAttr(
777 0, llvm::Attribute::getWithCaptureInfo(CGF.getLLVMContext(),
778 llvm::CaptureInfo::none()));
779
780 llvm::Value *args[] = {
781 EnforceType(Builder, ReceiverPtr.getPointer(), PtrToIdTy),
782 EnforceType(Builder, cmd, SelectorTy),
783 EnforceType(Builder, self, IdTy)};
784 llvm::CallBase *slot = CGF.EmitRuntimeCallOrInvoke(LookupFn, args);
785 slot->setOnlyReadsMemory();
786 slot->setMetadata(msgSendMDKind, node);
787
788 // Load the imp from the slot
789 llvm::Value *imp = Builder.CreateAlignedLoad(
790 IMPTy, Builder.CreateStructGEP(SlotStructTy, slot, 4),
791 CGF.getPointerAlign());
792
793 // The lookup function may have changed the receiver, so make sure we use
794 // the new one.
795 Receiver = Builder.CreateLoad(ReceiverPtr, true);
796 return imp;
797 }
798
799 llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper,
800 llvm::Value *cmd,
801 MessageSendInfo &MSI) override {
802 CGBuilderTy &Builder = CGF.Builder;
803 llvm::Value *lookupArgs[] = {ObjCSuper.emitRawPointer(CGF), cmd};
804
805 llvm::CallInst *slot =
806 CGF.EmitNounwindRuntimeCall(SlotLookupSuperFn, lookupArgs);
807 slot->setOnlyReadsMemory();
808
809 return Builder.CreateAlignedLoad(
810 IMPTy, Builder.CreateStructGEP(SlotStructTy, slot, 4),
811 CGF.getPointerAlign());
812 }
813
814 public:
815 CGObjCGNUstep(CodeGenModule &Mod) : CGObjCGNUstep(Mod, 9, 3, 1) {}
816 CGObjCGNUstep(CodeGenModule &Mod, unsigned ABI, unsigned ProtocolABI,
817 unsigned ClassABI) :
818 CGObjCGNU(Mod, ABI, ProtocolABI, ClassABI) {
819 const ObjCRuntime &R = CGM.getLangOpts().ObjCRuntime;
820
821 SlotStructTy = llvm::StructType::get(PtrTy, PtrTy, PtrTy, IntTy, IMPTy);
822 SlotTy = PtrTy;
823 // Slot_t objc_msg_lookup_sender(id *receiver, SEL selector, id sender);
824 SlotLookupFn.init(&CGM, "objc_msg_lookup_sender", SlotTy, PtrToIdTy,
825 SelectorTy, IdTy);
826 // Slot_t objc_slot_lookup_super(struct objc_super*, SEL);
827 SlotLookupSuperFn.init(&CGM, "objc_slot_lookup_super", SlotTy,
828 PtrToObjCSuperTy, SelectorTy);
829 // If we're in ObjC++ mode, then we want to make
830 llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
831 if (usesCxxExceptions) {
832 // void *__cxa_begin_catch(void *e)
833 EnterCatchFn.init(&CGM, "__cxa_begin_catch", PtrTy, PtrTy);
834 // void __cxa_end_catch(void)
835 ExitCatchFn.init(&CGM, "__cxa_end_catch", VoidTy);
836 // void objc_exception_rethrow(void*)
837 ExceptionReThrowFn.init(&CGM, "__cxa_rethrow", PtrTy);
838 } else if (usesSEHExceptions) {
839 // void objc_exception_rethrow(void)
840 ExceptionReThrowFn.init(&CGM, "objc_exception_rethrow", VoidTy);
841 } else if (CGM.getLangOpts().CPlusPlus) {
842 // void *__cxa_begin_catch(void *e)
843 EnterCatchFn.init(&CGM, "__cxa_begin_catch", PtrTy, PtrTy);
844 // void __cxa_end_catch(void)
845 ExitCatchFn.init(&CGM, "__cxa_end_catch", VoidTy);
846 // void _Unwind_Resume_or_Rethrow(void*)
847 ExceptionReThrowFn.init(&CGM, "_Unwind_Resume_or_Rethrow", VoidTy,
848 PtrTy);
849 } else if (R.getVersion() >= VersionTuple(1, 7)) {
850 // id objc_begin_catch(void *e)
851 EnterCatchFn.init(&CGM, "objc_begin_catch", IdTy, PtrTy);
852 // void objc_end_catch(void)
853 ExitCatchFn.init(&CGM, "objc_end_catch", VoidTy);
854 // void _Unwind_Resume_or_Rethrow(void*)
855 ExceptionReThrowFn.init(&CGM, "objc_exception_rethrow", VoidTy, PtrTy);
856 }
857 SetPropertyAtomic.init(&CGM, "objc_setProperty_atomic", VoidTy, IdTy,
858 SelectorTy, IdTy, PtrDiffTy);
859 SetPropertyAtomicCopy.init(&CGM, "objc_setProperty_atomic_copy", VoidTy,
860 IdTy, SelectorTy, IdTy, PtrDiffTy);
861 SetPropertyNonAtomic.init(&CGM, "objc_setProperty_nonatomic", VoidTy,
862 IdTy, SelectorTy, IdTy, PtrDiffTy);
863 SetPropertyNonAtomicCopy.init(&CGM, "objc_setProperty_nonatomic_copy",
864 VoidTy, IdTy, SelectorTy, IdTy, PtrDiffTy);
865 // void objc_setCppObjectAtomic(void *dest, const void *src, void
866 // *helper);
867 CxxAtomicObjectSetFn.init(&CGM, "objc_setCppObjectAtomic", VoidTy, PtrTy,
868 PtrTy, PtrTy);
869 // void objc_getCppObjectAtomic(void *dest, const void *src, void
870 // *helper);
871 CxxAtomicObjectGetFn.init(&CGM, "objc_getCppObjectAtomic", VoidTy, PtrTy,
872 PtrTy, PtrTy);
873 }
874
875 llvm::FunctionCallee GetCppAtomicObjectGetFunction() override {
876 // The optimised functions were added in version 1.7 of the GNUstep
877 // runtime.
878 assert (CGM.getLangOpts().ObjCRuntime.getVersion() >=
879 VersionTuple(1, 7));
880 return CxxAtomicObjectGetFn;
881 }
882
883 llvm::FunctionCallee GetCppAtomicObjectSetFunction() override {
884 // The optimised functions were added in version 1.7 of the GNUstep
885 // runtime.
886 assert (CGM.getLangOpts().ObjCRuntime.getVersion() >=
887 VersionTuple(1, 7));
888 return CxxAtomicObjectSetFn;
889 }
890
891 llvm::FunctionCallee GetOptimizedPropertySetFunction(bool atomic,
892 bool copy) override {
893 // The optimised property functions omit the GC check, and so are not
894 // safe to use in GC mode. The standard functions are fast in GC mode,
895 // so there is less advantage in using them.
896 assert ((CGM.getLangOpts().getGC() == LangOptions::NonGC));
897 // The optimised functions were added in version 1.7 of the GNUstep
898 // runtime.
899 assert (CGM.getLangOpts().ObjCRuntime.getVersion() >=
900 VersionTuple(1, 7));
901
902 if (atomic) {
903 if (copy) return SetPropertyAtomicCopy;
904 return SetPropertyAtomic;
905 }
906
907 return copy ? SetPropertyNonAtomicCopy : SetPropertyNonAtomic;
908 }
909};
910
911/// GNUstep Objective-C ABI version 2 implementation.
912/// This is the ABI that provides a clean break with the legacy GCC ABI and
913/// cleans up a number of things that were added to work around 1980s linkers.
914class CGObjCGNUstep2 : public CGObjCGNUstep {
915 enum SectionKind
916 {
917 SelectorSection = 0,
918 ClassSection,
919 ClassReferenceSection,
920 CategorySection,
921 ProtocolSection,
922 ProtocolReferenceSection,
923 ClassAliasSection,
924 ConstantStringSection
925 };
926 /// The subset of `objc_class_flags` used at compile time.
927 enum ClassFlags {
928 /// This is a metaclass
929 ClassFlagMeta = (1 << 0),
930 /// This class has been initialised by the runtime (+initialize has been
931 /// sent if necessary).
932 ClassFlagInitialized = (1 << 8),
933 };
934 static const char *const SectionsBaseNames[8];
935 static const char *const PECOFFSectionsBaseNames[8];
936 template<SectionKind K>
937 std::string sectionName() {
938 if (CGM.getTriple().isOSBinFormatCOFF()) {
939 std::string name(PECOFFSectionsBaseNames[K]);
940 name += "$m";
941 return name;
942 }
943 return SectionsBaseNames[K];
944 }
945 /// The GCC ABI superclass message lookup function. Takes a pointer to a
946 /// structure describing the receiver and the class, and a selector as
947 /// arguments. Returns the IMP for the corresponding method.
948 LazyRuntimeFunction MsgLookupSuperFn;
949 /// Function to ensure that +initialize is sent to a class.
950 LazyRuntimeFunction SentInitializeFn;
951 /// A flag indicating if we've emitted at least one protocol.
952 /// If we haven't, then we need to emit an empty protocol, to ensure that the
953 /// __start__objc_protocols and __stop__objc_protocols sections exist.
954 bool EmittedProtocol = false;
955 /// A flag indicating if we've emitted at least one protocol reference.
956 /// If we haven't, then we need to emit an empty protocol, to ensure that the
957 /// __start__objc_protocol_refs and __stop__objc_protocol_refs sections
958 /// exist.
959 bool EmittedProtocolRef = false;
960 /// A flag indicating if we've emitted at least one class.
961 /// If we haven't, then we need to emit an empty protocol, to ensure that the
962 /// __start__objc_classes and __stop__objc_classes sections / exist.
963 bool EmittedClass = false;
964 /// Generate the name of a symbol for a reference to a class. Accesses to
965 /// classes should be indirected via this.
966
967 typedef std::pair<std::string, std::pair<llvm::GlobalVariable*, int>>
968 EarlyInitPair;
969 std::vector<EarlyInitPair> EarlyInitList;
970
971 std::string SymbolForClassRef(StringRef Name, bool isWeak) {
972 if (isWeak)
973 return (ManglePublicSymbol("OBJC_WEAK_REF_CLASS_") + Name).str();
974 else
975 return (ManglePublicSymbol("OBJC_REF_CLASS_") + Name).str();
976 }
977 /// Generate the name of a class symbol.
978 std::string SymbolForClass(StringRef Name) {
979 return (ManglePublicSymbol("OBJC_CLASS_") + Name).str();
980 }
981 void CallRuntimeFunction(CGBuilderTy &B, StringRef FunctionName,
982 ArrayRef<llvm::Value*> Args) {
983 SmallVector<llvm::Type *,8> Types;
984 for (auto *Arg : Args)
985 Types.push_back(Arg->getType());
986 llvm::FunctionType *FT = llvm::FunctionType::get(B.getVoidTy(), Types,
987 false);
988 llvm::FunctionCallee Fn = CGM.CreateRuntimeFunction(FT, FunctionName);
989 B.CreateCall(Fn, Args);
990 }
991
992 ConstantAddress GenerateConstantString(const StringLiteral *SL) override {
993
994 auto Str = SL->getString();
995 CharUnits Align = CGM.getPointerAlign();
996
997 // Look for an existing one
998 llvm::StringMap<llvm::Constant*>::iterator old = ObjCStrings.find(Str);
999 if (old != ObjCStrings.end())
1000 return ConstantAddress(old->getValue(), IdElemTy, Align);
1001
1002 bool isNonASCII = SL->containsNonAscii();
1003
1004 auto LiteralLength = SL->getLength();
1005
1006 if ((CGM.getTarget().getPointerWidth(LangAS::Default) == 64) &&
1007 (LiteralLength < 9) && !isNonASCII) {
1008 // Tiny strings are only used on 64-bit platforms. They store 8 7-bit
1009 // ASCII characters in the high 56 bits, followed by a 4-bit length and a
1010 // 3-bit tag (which is always 4).
1011 uint64_t str = 0;
1012 // Fill in the characters
1013 for (unsigned i=0 ; i<LiteralLength ; i++)
1014 str |= ((uint64_t)SL->getCodeUnit(i)) << ((64 - 4 - 3) - (i*7));
1015 // Fill in the length
1016 str |= LiteralLength << 3;
1017 // Set the tag
1018 str |= 4;
1019 auto *ObjCStr = llvm::ConstantExpr::getIntToPtr(
1020 llvm::ConstantInt::get(Int64Ty, str), IdTy);
1021 ObjCStrings[Str] = ObjCStr;
1022 return ConstantAddress(ObjCStr, IdElemTy, Align);
1023 }
1024
1025 StringRef StringClass = CGM.getLangOpts().ObjCConstantStringClass;
1026
1027 if (StringClass.empty()) StringClass = "NSConstantString";
1028
1029 std::string Sym = SymbolForClass(StringClass);
1030
1031 llvm::Constant *isa = TheModule.getNamedGlobal(Sym);
1032
1033 if (!isa) {
1034 isa = new llvm::GlobalVariable(TheModule, IdTy, /* isConstant */false,
1035 llvm::GlobalValue::ExternalLinkage, nullptr, Sym);
1036 if (CGM.getTriple().isOSBinFormatCOFF()) {
1037 cast<llvm::GlobalValue>(isa)->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
1038 }
1039 }
1040
1041 // struct
1042 // {
1043 // Class isa;
1044 // uint32_t flags;
1045 // uint32_t length; // Number of codepoints
1046 // uint32_t size; // Number of bytes
1047 // uint32_t hash;
1048 // const char *data;
1049 // };
1050
1051 ConstantInitBuilder Builder(CGM);
1052 auto Fields = Builder.beginStruct();
1053 if (!CGM.getTriple().isOSBinFormatCOFF()) {
1054 Fields.add(isa);
1055 } else {
1056 Fields.addNullPointer(PtrTy);
1057 }
1058 // For now, all non-ASCII strings are represented as UTF-16. As such, the
1059 // number of bytes is simply double the number of UTF-16 codepoints. In
1060 // ASCII strings, the number of bytes is equal to the number of non-ASCII
1061 // codepoints.
1062 if (isNonASCII) {
1063 unsigned NumU8CodeUnits = Str.size();
1064 // A UTF-16 representation of a unicode string contains at most the same
1065 // number of code units as a UTF-8 representation. Allocate that much
1066 // space, plus one for the final null character.
1067 SmallVector<llvm::UTF16, 128> ToBuf(NumU8CodeUnits + 1);
1068 const llvm::UTF8 *FromPtr = (const llvm::UTF8 *)Str.data();
1069 llvm::UTF16 *ToPtr = &ToBuf[0];
1070 (void)llvm::ConvertUTF8toUTF16(&FromPtr, FromPtr + NumU8CodeUnits,
1071 &ToPtr, ToPtr + NumU8CodeUnits, llvm::strictConversion);
1072 uint32_t StringLength = ToPtr - &ToBuf[0];
1073 // Add null terminator
1074 *ToPtr = 0;
1075 // Flags: 2 indicates UTF-16 encoding
1076 Fields.addInt(Int32Ty, 2);
1077 // Number of UTF-16 codepoints
1078 Fields.addInt(Int32Ty, StringLength);
1079 // Number of bytes
1080 Fields.addInt(Int32Ty, StringLength * 2);
1081 // Hash. Not currently initialised by the compiler.
1082 Fields.addInt(Int32Ty, 0);
1083 // pointer to the data string.
1084 auto Arr = llvm::ArrayRef(&ToBuf[0], ToPtr + 1);
1085 auto *C = llvm::ConstantDataArray::get(VMContext, Arr);
1086 auto *Buffer = new llvm::GlobalVariable(TheModule, C->getType(),
1087 /*isConstant=*/true, llvm::GlobalValue::PrivateLinkage, C, ".str");
1088 Buffer->setUnnamedAddr(llvm::GlobalValue::UnnamedAddr::Global);
1089 Fields.add(Buffer);
1090 } else {
1091 // Flags: 0 indicates ASCII encoding
1092 Fields.addInt(Int32Ty, 0);
1093 // Number of UTF-16 codepoints, each ASCII byte is a UTF-16 codepoint
1094 Fields.addInt(Int32Ty, Str.size());
1095 // Number of bytes
1096 Fields.addInt(Int32Ty, Str.size());
1097 // Hash. Not currently initialised by the compiler.
1098 Fields.addInt(Int32Ty, 0);
1099 // Data pointer
1100 Fields.add(MakeConstantString(Str));
1101 }
1102 std::string StringName;
1103 bool isNamed = !isNonASCII;
1104 if (isNamed) {
1105 StringName = ".objc_str_";
1106 for (unsigned char c : Str) {
1107 if (isalnum(c))
1108 StringName += c;
1109 else if (c == ' ')
1110 StringName += '_';
1111 else {
1112 isNamed = false;
1113 break;
1114 }
1115 }
1116 }
1117 llvm::GlobalVariable *ObjCStrGV =
1118 Fields.finishAndCreateGlobal(
1119 isNamed ? StringRef(StringName) : ".objc_string",
1120 Align, false, isNamed ? llvm::GlobalValue::LinkOnceODRLinkage
1121 : llvm::GlobalValue::PrivateLinkage);
1122 ObjCStrGV->setSection(sectionName<ConstantStringSection>());
1123 if (isNamed) {
1124 ObjCStrGV->setComdat(TheModule.getOrInsertComdat(StringName));
1125 ObjCStrGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
1126 }
1127 if (CGM.getTriple().isOSBinFormatCOFF()) {
1128 std::pair<llvm::GlobalVariable*, int> v{ObjCStrGV, 0};
1129 EarlyInitList.emplace_back(Sym, v);
1130 }
1131 ObjCStrings[Str] = ObjCStrGV;
1132 ConstantStrings.push_back(ObjCStrGV);
1133 return ConstantAddress(ObjCStrGV, IdElemTy, Align);
1134 }
1135
1136 void PushProperty(ConstantArrayBuilder &PropertiesArray,
1137 const ObjCPropertyDecl *property,
1138 const Decl *OCD,
1139 bool isSynthesized=true, bool
1140 isDynamic=true) override {
1141 // struct objc_property
1142 // {
1143 // const char *name;
1144 // const char *attributes;
1145 // const char *type;
1146 // SEL getter;
1147 // SEL setter;
1148 // };
1149 auto Fields = PropertiesArray.beginStruct(PropertyMetadataTy);
1150 ASTContext &Context = CGM.getContext();
1151 Fields.add(MakeConstantString(property->getNameAsString()));
1152 std::string TypeStr =
1153 CGM.getContext().getObjCEncodingForPropertyDecl(property, OCD);
1154 Fields.add(MakeConstantString(TypeStr));
1155 std::string typeStr;
1156 Context.getObjCEncodingForType(property->getType(), typeStr);
1157 Fields.add(MakeConstantString(typeStr));
1158 auto addPropertyMethod = [&](const ObjCMethodDecl *accessor) {
1159 if (accessor) {
1160 std::string TypeStr = Context.getObjCEncodingForMethodDecl(accessor);
1161 Fields.add(GetConstantSelector(accessor->getSelector(), TypeStr));
1162 } else {
1163 Fields.add(NULLPtr);
1164 }
1165 };
1166 addPropertyMethod(property->getGetterMethodDecl());
1167 addPropertyMethod(property->getSetterMethodDecl());
1168 Fields.finishAndAddTo(PropertiesArray);
1169 }
1170
1171 llvm::Constant *
1172 GenerateProtocolMethodList(ArrayRef<const ObjCMethodDecl*> Methods) override {
1173 // struct objc_protocol_method_description
1174 // {
1175 // SEL selector;
1176 // const char *types;
1177 // };
1178 llvm::StructType *ObjCMethodDescTy =
1179 llvm::StructType::get(CGM.getLLVMContext(),
1180 { PtrToInt8Ty, PtrToInt8Ty });
1181 ASTContext &Context = CGM.getContext();
1182 ConstantInitBuilder Builder(CGM);
1183 // struct objc_protocol_method_description_list
1184 // {
1185 // int count;
1186 // int size;
1187 // struct objc_protocol_method_description methods[];
1188 // };
1189 auto MethodList = Builder.beginStruct();
1190 // int count;
1191 MethodList.addInt(IntTy, Methods.size());
1192 // int size; // sizeof(struct objc_method_description)
1193 const llvm::DataLayout &DL = TheModule.getDataLayout();
1194 MethodList.addInt(IntTy, DL.getTypeSizeInBits(ObjCMethodDescTy) /
1195 CGM.getContext().getCharWidth());
1196 // struct objc_method_description[]
1197 auto MethodArray = MethodList.beginArray(ObjCMethodDescTy);
1198 for (auto *M : Methods) {
1199 auto Method = MethodArray.beginStruct(ObjCMethodDescTy);
1200 Method.add(CGObjCGNU::GetConstantSelector(M));
1201 Method.add(GetTypeString(Context.getObjCEncodingForMethodDecl(M, true)));
1202 Method.finishAndAddTo(MethodArray);
1203 }
1204 MethodArray.finishAndAddTo(MethodList);
1205 return MethodList.finishAndCreateGlobal(".objc_protocol_method_list",
1206 CGM.getPointerAlign());
1207 }
1208 llvm::Constant *GenerateCategoryProtocolList(const ObjCCategoryDecl *OCD)
1209 override {
1210 const auto &ReferencedProtocols = OCD->getReferencedProtocols();
1211 auto RuntimeProtocols = GetRuntimeProtocolList(ReferencedProtocols.begin(),
1212 ReferencedProtocols.end());
1213 SmallVector<llvm::Constant *, 16> Protocols;
1214 for (const auto *PI : RuntimeProtocols)
1215 Protocols.push_back(GenerateProtocolRef(PI));
1216 return GenerateProtocolList(Protocols);
1217 }
1218
1219 llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper,
1220 llvm::Value *cmd, MessageSendInfo &MSI) override {
1221 // Don't access the slot unless we're trying to cache the result.
1222 CGBuilderTy &Builder = CGF.Builder;
1223 llvm::Value *lookupArgs[] = {
1224 CGObjCGNU::EnforceType(Builder, ObjCSuper.emitRawPointer(CGF),
1225 PtrToObjCSuperTy),
1226 cmd};
1227 return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFn, lookupArgs);
1228 }
1229
1230 llvm::GlobalVariable *GetClassVar(StringRef Name, bool isWeak=false) {
1231 std::string SymbolName = SymbolForClassRef(Name, isWeak);
1232 auto *ClassSymbol = TheModule.getNamedGlobal(SymbolName);
1233 if (ClassSymbol)
1234 return ClassSymbol;
1235 ClassSymbol = new llvm::GlobalVariable(TheModule,
1236 IdTy, false, llvm::GlobalValue::ExternalLinkage,
1237 nullptr, SymbolName);
1238 // If this is a weak symbol, then we are creating a valid definition for
1239 // the symbol, pointing to a weak definition of the real class pointer. If
1240 // this is not a weak reference, then we are expecting another compilation
1241 // unit to provide the real indirection symbol.
1242 if (isWeak)
1243 ClassSymbol->setInitializer(new llvm::GlobalVariable(TheModule,
1244 Int8Ty, false, llvm::GlobalValue::ExternalWeakLinkage,
1245 nullptr, SymbolForClass(Name)));
1246 else {
1247 if (CGM.getTriple().isOSBinFormatCOFF()) {
1248 IdentifierInfo &II = CGM.getContext().Idents.get(Name);
1249 TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl();
1250 DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl);
1251
1252 const ObjCInterfaceDecl *OID = nullptr;
1253 for (const auto *Result : DC->lookup(&II))
1254 if ((OID = dyn_cast<ObjCInterfaceDecl>(Result)))
1255 break;
1256
1257 // The first Interface we find may be a @class,
1258 // which should only be treated as the source of
1259 // truth in the absence of a true declaration.
1260 assert(OID && "Failed to find ObjCInterfaceDecl");
1261 const ObjCInterfaceDecl *OIDDef = OID->getDefinition();
1262 if (OIDDef != nullptr)
1263 OID = OIDDef;
1264
1265 auto Storage = llvm::GlobalValue::DefaultStorageClass;
1266 if (OID->hasAttr<DLLImportAttr>())
1267 Storage = llvm::GlobalValue::DLLImportStorageClass;
1268 else if (OID->hasAttr<DLLExportAttr>())
1269 Storage = llvm::GlobalValue::DLLExportStorageClass;
1270
1271 cast<llvm::GlobalValue>(ClassSymbol)->setDLLStorageClass(Storage);
1272 }
1273 }
1274 assert(ClassSymbol->getName() == SymbolName);
1275 return ClassSymbol;
1276 }
1277 llvm::Value *GetClassNamed(CodeGenFunction &CGF,
1278 const std::string &Name,
1279 bool isWeak) override {
1280 return CGF.Builder.CreateLoad(
1281 Address(GetClassVar(Name, isWeak), IdTy, CGM.getPointerAlign()));
1282 }
1283 int32_t FlagsForOwnership(Qualifiers::ObjCLifetime Ownership) {
1284 // typedef enum {
1285 // ownership_invalid = 0,
1286 // ownership_strong = 1,
1287 // ownership_weak = 2,
1288 // ownership_unsafe = 3
1289 // } ivar_ownership;
1290 int Flag;
1291 switch (Ownership) {
1293 Flag = 1;
1294 break;
1296 Flag = 2;
1297 break;
1299 Flag = 3;
1300 break;
1303 assert(Ownership != Qualifiers::OCL_Autoreleasing);
1304 Flag = 0;
1305 }
1306 return Flag;
1307 }
1308 llvm::Constant *GenerateIvarList(ArrayRef<llvm::Constant *> IvarNames,
1309 ArrayRef<llvm::Constant *> IvarTypes,
1310 ArrayRef<llvm::Constant *> IvarOffsets,
1311 ArrayRef<llvm::Constant *> IvarAlign,
1312 ArrayRef<Qualifiers::ObjCLifetime> IvarOwnership) override {
1313 llvm_unreachable("Method should not be called!");
1314 }
1315
1316 llvm::Constant *GenerateEmptyProtocol(StringRef ProtocolName) override {
1317 std::string Name = SymbolForProtocol(ProtocolName);
1318 auto *GV = TheModule.getGlobalVariable(Name);
1319 if (!GV) {
1320 // Emit a placeholder symbol.
1321 GV = new llvm::GlobalVariable(TheModule, ProtocolTy, false,
1322 llvm::GlobalValue::ExternalLinkage, nullptr, Name);
1323 GV->setAlignment(CGM.getPointerAlign().getAsAlign());
1324 }
1325 return GV;
1326 }
1327
1328 /// Existing protocol references.
1329 llvm::StringMap<llvm::Constant*> ExistingProtocolRefs;
1330
1331 llvm::Value *GenerateProtocolRef(CodeGenFunction &CGF,
1332 const ObjCProtocolDecl *PD) override {
1333 auto Name = PD->getNameAsString();
1334 auto *&Ref = ExistingProtocolRefs[Name];
1335 if (!Ref) {
1336 auto *&Protocol = ExistingProtocols[Name];
1337 if (!Protocol)
1338 Protocol = GenerateProtocolRef(PD);
1339 std::string RefName = SymbolForProtocolRef(Name);
1340 assert(!TheModule.getGlobalVariable(RefName));
1341 // Emit a reference symbol.
1342 auto GV = new llvm::GlobalVariable(TheModule, ProtocolPtrTy, false,
1343 llvm::GlobalValue::LinkOnceODRLinkage,
1344 Protocol, RefName);
1345 GV->setComdat(TheModule.getOrInsertComdat(RefName));
1346 GV->setSection(sectionName<ProtocolReferenceSection>());
1347 GV->setAlignment(CGM.getPointerAlign().getAsAlign());
1348 Ref = GV;
1349 }
1350 EmittedProtocolRef = true;
1351 return CGF.Builder.CreateAlignedLoad(ProtocolPtrTy, Ref,
1352 CGM.getPointerAlign());
1353 }
1354
1355 llvm::Constant *GenerateProtocolList(ArrayRef<llvm::Constant*> Protocols) {
1356 llvm::ArrayType *ProtocolArrayTy = llvm::ArrayType::get(ProtocolPtrTy,
1357 Protocols.size());
1358 llvm::Constant * ProtocolArray = llvm::ConstantArray::get(ProtocolArrayTy,
1359 Protocols);
1360 ConstantInitBuilder builder(CGM);
1361 auto ProtocolBuilder = builder.beginStruct();
1362 ProtocolBuilder.addNullPointer(PtrTy);
1363 ProtocolBuilder.addInt(SizeTy, Protocols.size());
1364 ProtocolBuilder.add(ProtocolArray);
1365 return ProtocolBuilder.finishAndCreateGlobal(".objc_protocol_list",
1366 CGM.getPointerAlign(), false, llvm::GlobalValue::InternalLinkage);
1367 }
1368
1369 void GenerateProtocol(const ObjCProtocolDecl *PD) override {
1370 // Do nothing - we only emit referenced protocols.
1371 }
1372 llvm::Constant *GenerateProtocolRef(const ObjCProtocolDecl *PD) override {
1373 std::string ProtocolName = PD->getNameAsString();
1374 auto *&Protocol = ExistingProtocols[ProtocolName];
1375 if (Protocol)
1376 return Protocol;
1377
1378 EmittedProtocol = true;
1379
1380 auto SymName = SymbolForProtocol(ProtocolName);
1381 auto *OldGV = TheModule.getGlobalVariable(SymName);
1382
1383 // Use the protocol definition, if there is one.
1384 if (const ObjCProtocolDecl *Def = PD->getDefinition())
1385 PD = Def;
1386 else {
1387 // If there is no definition, then create an external linkage symbol and
1388 // hope that someone else fills it in for us (and fail to link if they
1389 // don't).
1390 assert(!OldGV);
1391 Protocol = new llvm::GlobalVariable(TheModule, ProtocolTy,
1392 /*isConstant*/false,
1393 llvm::GlobalValue::ExternalLinkage, nullptr, SymName);
1394 return Protocol;
1395 }
1396
1397 SmallVector<llvm::Constant*, 16> Protocols;
1398 auto RuntimeProtocols =
1399 GetRuntimeProtocolList(PD->protocol_begin(), PD->protocol_end());
1400 for (const auto *PI : RuntimeProtocols)
1401 Protocols.push_back(GenerateProtocolRef(PI));
1402 llvm::Constant *ProtocolList = GenerateProtocolList(Protocols);
1403
1404 // Collect information about methods
1405 llvm::Constant *InstanceMethodList, *OptionalInstanceMethodList;
1406 llvm::Constant *ClassMethodList, *OptionalClassMethodList;
1407 EmitProtocolMethodList(PD->instance_methods(), InstanceMethodList,
1408 OptionalInstanceMethodList);
1409 EmitProtocolMethodList(PD->class_methods(), ClassMethodList,
1410 OptionalClassMethodList);
1411
1412 // The isa pointer must be set to a magic number so the runtime knows it's
1413 // the correct layout.
1414 ConstantInitBuilder builder(CGM);
1415 auto ProtocolBuilder = builder.beginStruct();
1416 ProtocolBuilder.add(llvm::ConstantExpr::getIntToPtr(
1417 llvm::ConstantInt::get(Int32Ty, ProtocolVersion), IdTy));
1418 ProtocolBuilder.add(MakeConstantString(ProtocolName));
1419 ProtocolBuilder.add(ProtocolList);
1420 ProtocolBuilder.add(InstanceMethodList);
1421 ProtocolBuilder.add(ClassMethodList);
1422 ProtocolBuilder.add(OptionalInstanceMethodList);
1423 ProtocolBuilder.add(OptionalClassMethodList);
1424 // Required instance properties
1425 ProtocolBuilder.add(GeneratePropertyList(nullptr, PD, false, false));
1426 // Optional instance properties
1427 ProtocolBuilder.add(GeneratePropertyList(nullptr, PD, false, true));
1428 // Required class properties
1429 ProtocolBuilder.add(GeneratePropertyList(nullptr, PD, true, false));
1430 // Optional class properties
1431 ProtocolBuilder.add(GeneratePropertyList(nullptr, PD, true, true));
1432
1433 auto *GV = ProtocolBuilder.finishAndCreateGlobal(SymName,
1434 CGM.getPointerAlign(), false, llvm::GlobalValue::ExternalLinkage);
1435 GV->setSection(sectionName<ProtocolSection>());
1436 GV->setComdat(TheModule.getOrInsertComdat(SymName));
1437 if (OldGV) {
1438 OldGV->replaceAllUsesWith(GV);
1439 OldGV->removeFromParent();
1440 GV->setName(SymName);
1441 }
1442 Protocol = GV;
1443 return GV;
1444 }
1445 llvm::Value *GetTypedSelector(CodeGenFunction &CGF, Selector Sel,
1446 const std::string &TypeEncoding) override {
1447 return GetConstantSelector(Sel, TypeEncoding);
1448 }
1449 std::string GetSymbolNameForTypeEncoding(const std::string &TypeEncoding) {
1450 std::string MangledTypes = std::string(TypeEncoding);
1451 // @ is used as a special character in ELF symbol names (used for symbol
1452 // versioning), so mangle the name to not include it. Replace it with a
1453 // character that is not a valid type encoding character (and, being
1454 // non-printable, never will be!)
1455 if (CGM.getTriple().isOSBinFormatELF())
1456 llvm::replace(MangledTypes, '@', '\1');
1457 // = in dll exported names causes lld to fail when linking on Windows.
1458 if (CGM.getTriple().isOSWindows())
1459 llvm::replace(MangledTypes, '=', '\2');
1460 return MangledTypes;
1461 }
1462 llvm::Constant *GetTypeString(llvm::StringRef TypeEncoding) {
1463 if (TypeEncoding.empty())
1464 return NULLPtr;
1465 std::string MangledTypes =
1466 GetSymbolNameForTypeEncoding(std::string(TypeEncoding));
1467 std::string TypesVarName = ".objc_sel_types_" + MangledTypes;
1468 auto *TypesGlobal = TheModule.getGlobalVariable(TypesVarName);
1469 if (!TypesGlobal) {
1470 llvm::Constant *Init = llvm::ConstantDataArray::getString(VMContext,
1471 TypeEncoding);
1472 auto *GV = new llvm::GlobalVariable(TheModule, Init->getType(),
1473 true, llvm::GlobalValue::LinkOnceODRLinkage, Init, TypesVarName);
1474 GV->setComdat(TheModule.getOrInsertComdat(TypesVarName));
1475 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
1476 TypesGlobal = GV;
1477 }
1478 return TypesGlobal;
1479 }
1480 llvm::Constant *GetConstantSelector(Selector Sel,
1481 const std::string &TypeEncoding) override {
1482 std::string MangledTypes = GetSymbolNameForTypeEncoding(TypeEncoding);
1483 auto SelVarName = (StringRef(".objc_selector_") + Sel.getAsString() + "_" +
1484 MangledTypes).str();
1485 if (auto *GV = TheModule.getNamedGlobal(SelVarName))
1486 return GV;
1487 ConstantInitBuilder builder(CGM);
1488 auto SelBuilder = builder.beginStruct();
1489 SelBuilder.add(ExportUniqueString(Sel.getAsString(), ".objc_sel_name_",
1490 true));
1491 SelBuilder.add(GetTypeString(TypeEncoding));
1492 auto *GV = SelBuilder.finishAndCreateGlobal(SelVarName,
1493 CGM.getPointerAlign(), false, llvm::GlobalValue::LinkOnceODRLinkage);
1494 GV->setComdat(TheModule.getOrInsertComdat(SelVarName));
1495 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
1496 GV->setSection(sectionName<SelectorSection>());
1497 return GV;
1498 }
1499 llvm::StructType *emptyStruct = nullptr;
1500
1501 /// Return pointers to the start and end of a section. On ELF platforms, we
1502 /// use the __start_ and __stop_ symbols that GNU-compatible linkers will set
1503 /// to the start and end of section names, as long as those section names are
1504 /// valid identifiers and the symbols are referenced but not defined. On
1505 /// Windows, we use the fact that MSVC-compatible linkers will lexically sort
1506 /// by subsections and place everything that we want to reference in a middle
1507 /// subsection and then insert zero-sized symbols in subsections a and z.
1508 std::pair<llvm::Constant*,llvm::Constant*>
1509 GetSectionBounds(StringRef Section) {
1510 if (CGM.getTriple().isOSBinFormatCOFF()) {
1511 if (emptyStruct == nullptr) {
1512 emptyStruct = llvm::StructType::create(
1513 VMContext, {}, ".objc_section_sentinel", /*isPacked=*/true);
1514 }
1515 auto ZeroInit = llvm::Constant::getNullValue(emptyStruct);
1516 auto Sym = [&](StringRef Prefix, StringRef SecSuffix) {
1517 auto *Sym = new llvm::GlobalVariable(TheModule, emptyStruct,
1518 /*isConstant*/false,
1519 llvm::GlobalValue::LinkOnceODRLinkage, ZeroInit, Prefix +
1520 Section);
1521 Sym->setVisibility(llvm::GlobalValue::HiddenVisibility);
1522 Sym->setSection((Section + SecSuffix).str());
1523 Sym->setComdat(TheModule.getOrInsertComdat((Prefix +
1524 Section).str()));
1525 Sym->setAlignment(CGM.getPointerAlign().getAsAlign());
1526 return Sym;
1527 };
1528 return { Sym("__start_", "$a"), Sym("__stop", "$z") };
1529 }
1530 auto *Start = new llvm::GlobalVariable(TheModule, PtrTy,
1531 /*isConstant*/false,
1532 llvm::GlobalValue::ExternalLinkage, nullptr, StringRef("__start_") +
1533 Section);
1534 Start->setVisibility(llvm::GlobalValue::HiddenVisibility);
1535 auto *Stop = new llvm::GlobalVariable(TheModule, PtrTy,
1536 /*isConstant*/false,
1537 llvm::GlobalValue::ExternalLinkage, nullptr, StringRef("__stop_") +
1538 Section);
1539 Stop->setVisibility(llvm::GlobalValue::HiddenVisibility);
1540 return { Start, Stop };
1541 }
1542 CatchTypeInfo getCatchAllTypeInfo() override {
1543 return CGM.getCXXABI().getCatchAllTypeInfo();
1544 }
1545 llvm::Function *ModuleInitFunction() override {
1546 llvm::Function *LoadFunction = llvm::Function::Create(
1547 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), false),
1548 llvm::GlobalValue::LinkOnceODRLinkage, ".objcv2_load_function",
1549 &TheModule);
1550 LoadFunction->setVisibility(llvm::GlobalValue::HiddenVisibility);
1551 LoadFunction->setComdat(TheModule.getOrInsertComdat(".objcv2_load_function"));
1552
1553 llvm::BasicBlock *EntryBB =
1554 llvm::BasicBlock::Create(VMContext, "entry", LoadFunction);
1555 CGBuilderTy B(CGM, VMContext);
1556 B.SetInsertPoint(EntryBB);
1557 ConstantInitBuilder builder(CGM);
1558 auto InitStructBuilder = builder.beginStruct();
1559 InitStructBuilder.addInt(Int64Ty, 0);
1560 auto &sectionVec = CGM.getTriple().isOSBinFormatCOFF() ? PECOFFSectionsBaseNames : SectionsBaseNames;
1561 for (auto *s : sectionVec) {
1562 auto bounds = GetSectionBounds(s);
1563 InitStructBuilder.add(bounds.first);
1564 InitStructBuilder.add(bounds.second);
1565 }
1566 auto *InitStruct = InitStructBuilder.finishAndCreateGlobal(".objc_init",
1567 CGM.getPointerAlign(), false, llvm::GlobalValue::LinkOnceODRLinkage);
1568 InitStruct->setVisibility(llvm::GlobalValue::HiddenVisibility);
1569 InitStruct->setComdat(TheModule.getOrInsertComdat(".objc_init"));
1570
1571 CallRuntimeFunction(B, "__objc_load", {InitStruct});;
1572 B.CreateRetVoid();
1573 // Make sure that the optimisers don't delete this function.
1574 CGM.addCompilerUsedGlobal(LoadFunction);
1575 // FIXME: Currently ELF only!
1576 // We have to do this by hand, rather than with @llvm.ctors, so that the
1577 // linker can remove the duplicate invocations.
1578 auto *InitVar = new llvm::GlobalVariable(TheModule, LoadFunction->getType(),
1579 /*isConstant*/false, llvm::GlobalValue::LinkOnceAnyLinkage,
1580 LoadFunction, ".objc_ctor");
1581 // Check that this hasn't been renamed. This shouldn't happen, because
1582 // this function should be called precisely once.
1583 assert(InitVar->getName() == ".objc_ctor");
1584 // In Windows, initialisers are sorted by the suffix. XCL is for library
1585 // initialisers, which run before user initialisers. We are running
1586 // Objective-C loads at the end of library load. This means +load methods
1587 // will run before any other static constructors, but that static
1588 // constructors can see a fully initialised Objective-C state.
1589 if (CGM.getTriple().isOSBinFormatCOFF())
1590 InitVar->setSection(".CRT$XCLz");
1591 else
1592 {
1593 if (CGM.getCodeGenOpts().UseInitArray)
1594 InitVar->setSection(".init_array");
1595 else
1596 InitVar->setSection(".ctors");
1597 }
1598 InitVar->setVisibility(llvm::GlobalValue::HiddenVisibility);
1599 InitVar->setComdat(TheModule.getOrInsertComdat(".objc_ctor"));
1600 CGM.addUsedGlobal(InitVar);
1601 for (auto *C : Categories) {
1602 auto *Cat = cast<llvm::GlobalVariable>(C->stripPointerCasts());
1603 Cat->setSection(sectionName<CategorySection>());
1604 CGM.addUsedGlobal(Cat);
1605 }
1606 auto createNullGlobal = [&](StringRef Name, ArrayRef<llvm::Constant*> Init,
1607 StringRef Section) {
1608 auto nullBuilder = builder.beginStruct();
1609 for (auto *F : Init)
1610 nullBuilder.add(F);
1611 auto GV = nullBuilder.finishAndCreateGlobal(Name, CGM.getPointerAlign(),
1612 false, llvm::GlobalValue::LinkOnceODRLinkage);
1613 GV->setSection(Section);
1614 GV->setComdat(TheModule.getOrInsertComdat(Name));
1615 GV->setVisibility(llvm::GlobalValue::HiddenVisibility);
1616 CGM.addUsedGlobal(GV);
1617 return GV;
1618 };
1619 for (auto clsAlias : ClassAliases)
1620 createNullGlobal(std::string(".objc_class_alias") +
1621 clsAlias.second, { MakeConstantString(clsAlias.second),
1622 GetClassVar(clsAlias.first) }, sectionName<ClassAliasSection>());
1623 // On ELF platforms, add a null value for each special section so that we
1624 // can always guarantee that the _start and _stop symbols will exist and be
1625 // meaningful. This is not required on COFF platforms, where our start and
1626 // stop symbols will create the section.
1627 if (!CGM.getTriple().isOSBinFormatCOFF()) {
1628 createNullGlobal(".objc_null_selector", {NULLPtr, NULLPtr},
1629 sectionName<SelectorSection>());
1630 if (Categories.empty())
1631 createNullGlobal(".objc_null_category", {NULLPtr, NULLPtr,
1632 NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr},
1633 sectionName<CategorySection>());
1634 if (!EmittedClass) {
1635 createNullGlobal(".objc_null_cls_init_ref", NULLPtr,
1636 sectionName<ClassSection>());
1637 createNullGlobal(".objc_null_class_ref", { NULLPtr, NULLPtr },
1638 sectionName<ClassReferenceSection>());
1639 }
1640 if (!EmittedProtocol)
1641 createNullGlobal(".objc_null_protocol", {NULLPtr, NULLPtr, NULLPtr,
1642 NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr, NULLPtr,
1643 NULLPtr}, sectionName<ProtocolSection>());
1644 if (!EmittedProtocolRef)
1645 createNullGlobal(".objc_null_protocol_ref", {NULLPtr},
1646 sectionName<ProtocolReferenceSection>());
1647 if (ClassAliases.empty())
1648 createNullGlobal(".objc_null_class_alias", { NULLPtr, NULLPtr },
1649 sectionName<ClassAliasSection>());
1650 if (ConstantStrings.empty()) {
1651 auto i32Zero = llvm::ConstantInt::get(Int32Ty, 0);
1652 createNullGlobal(".objc_null_constant_string", { NULLPtr, i32Zero,
1653 i32Zero, i32Zero, i32Zero, NULLPtr },
1654 sectionName<ConstantStringSection>());
1655 }
1656 }
1657 ConstantStrings.clear();
1658 Categories.clear();
1659 Classes.clear();
1660
1661 if (EarlyInitList.size() > 0) {
1662 auto *Init = llvm::Function::Create(llvm::FunctionType::get(CGM.VoidTy,
1663 {}), llvm::GlobalValue::InternalLinkage, ".objc_early_init",
1664 &CGM.getModule());
1665 llvm::IRBuilder<> b(llvm::BasicBlock::Create(CGM.getLLVMContext(), "entry",
1666 Init));
1667 for (const auto &lateInit : EarlyInitList) {
1668 auto *global = TheModule.getGlobalVariable(lateInit.first);
1669 if (global) {
1670 llvm::GlobalVariable *GV = lateInit.second.first;
1671 b.CreateAlignedStore(
1672 global,
1673 b.CreateStructGEP(GV->getValueType(), GV, lateInit.second.second),
1674 CGM.getPointerAlign().getAsAlign());
1675 }
1676 }
1677 b.CreateRetVoid();
1678 // We can't use the normal LLVM global initialisation array, because we
1679 // need to specify that this runs early in library initialisation.
1680 auto *InitVar = new llvm::GlobalVariable(CGM.getModule(), Init->getType(),
1681 /*isConstant*/true, llvm::GlobalValue::InternalLinkage,
1682 Init, ".objc_early_init_ptr");
1683 InitVar->setSection(".CRT$XCLb");
1684 CGM.addUsedGlobal(InitVar);
1685 }
1686 return nullptr;
1687 }
1688 /// In the v2 ABI, ivar offset variables use the type encoding in their name
1689 /// to trigger linker failures if the types don't match.
1690 std::string GetIVarOffsetVariableName(const ObjCInterfaceDecl *ID,
1691 const ObjCIvarDecl *Ivar) override {
1692 std::string TypeEncoding;
1693 CGM.getContext().getObjCEncodingForType(Ivar->getType(), TypeEncoding);
1694 TypeEncoding = GetSymbolNameForTypeEncoding(TypeEncoding);
1695 const std::string Name = "__objc_ivar_offset_" + ID->getNameAsString()
1696 + '.' + Ivar->getNameAsString() + '.' + TypeEncoding;
1697 return Name;
1698 }
1699 llvm::Value *EmitIvarOffset(CodeGenFunction &CGF,
1700 const ObjCInterfaceDecl *Interface,
1701 const ObjCIvarDecl *Ivar) override {
1702 const ObjCInterfaceDecl *ContainingInterface =
1703 Ivar->getContainingInterface();
1704 const std::string Name =
1705 GetIVarOffsetVariableName(ContainingInterface, Ivar);
1706 llvm::GlobalVariable *IvarOffsetPointer = TheModule.getNamedGlobal(Name);
1707 if (!IvarOffsetPointer) {
1708 IvarOffsetPointer = new llvm::GlobalVariable(TheModule, IntTy, false,
1709 llvm::GlobalValue::ExternalLinkage, nullptr, Name);
1710 if (Ivar->getAccessControl() != ObjCIvarDecl::Private &&
1712 CGM.setGVProperties(IvarOffsetPointer, ContainingInterface);
1713 }
1714 CharUnits Align = CGM.getIntAlign();
1715 llvm::Value *Offset =
1716 CGF.Builder.CreateAlignedLoad(IntTy, IvarOffsetPointer, Align);
1717 if (Offset->getType() != PtrDiffTy)
1718 Offset = CGF.Builder.CreateZExtOrBitCast(Offset, PtrDiffTy);
1719 return Offset;
1720 }
1721 void GenerateClass(const ObjCImplementationDecl *OID) override {
1722 ASTContext &Context = CGM.getContext();
1723 bool IsCOFF = CGM.getTriple().isOSBinFormatCOFF();
1724
1725 // Get the class name
1726 ObjCInterfaceDecl *classDecl =
1727 const_cast<ObjCInterfaceDecl *>(OID->getClassInterface());
1728 std::string className = classDecl->getNameAsString();
1729 auto *classNameConstant = MakeConstantString(className);
1730
1731 ConstantInitBuilder builder(CGM);
1732 auto metaclassFields = builder.beginStruct();
1733 // struct objc_class *isa;
1734 metaclassFields.addNullPointer(PtrTy);
1735 // struct objc_class *super_class;
1736 metaclassFields.addNullPointer(PtrTy);
1737 // const char *name;
1738 metaclassFields.add(classNameConstant);
1739 // long version;
1740 metaclassFields.addInt(LongTy, 0);
1741 // unsigned long info;
1742 // objc_class_flag_meta
1743 metaclassFields.addInt(LongTy, ClassFlags::ClassFlagMeta);
1744 // long instance_size;
1745 // Setting this to zero is consistent with the older ABI, but it might be
1746 // more sensible to set this to sizeof(struct objc_class)
1747 metaclassFields.addInt(LongTy, 0);
1748 // struct objc_ivar_list *ivars;
1749 metaclassFields.addNullPointer(PtrTy);
1750 // struct objc_method_list *methods
1751 // FIXME: Almost identical code is copied and pasted below for the
1752 // class, but refactoring it cleanly requires C++14 generic lambdas.
1753 if (OID->class_methods().empty())
1754 metaclassFields.addNullPointer(PtrTy);
1755 else {
1756 SmallVector<ObjCMethodDecl*, 16> ClassMethods;
1757 ClassMethods.insert(ClassMethods.begin(), OID->classmeth_begin(),
1758 OID->classmeth_end());
1759 metaclassFields.add(
1760 GenerateMethodList(className, "", ClassMethods, true));
1761 }
1762 // void *dtable;
1763 metaclassFields.addNullPointer(PtrTy);
1764 // IMP cxx_construct;
1765 metaclassFields.addNullPointer(PtrTy);
1766 // IMP cxx_destruct;
1767 metaclassFields.addNullPointer(PtrTy);
1768 // struct objc_class *subclass_list
1769 metaclassFields.addNullPointer(PtrTy);
1770 // struct objc_class *sibling_class
1771 metaclassFields.addNullPointer(PtrTy);
1772 // struct objc_protocol_list *protocols;
1773 metaclassFields.addNullPointer(PtrTy);
1774 // struct reference_list *extra_data;
1775 metaclassFields.addNullPointer(PtrTy);
1776 // long abi_version;
1777 metaclassFields.addInt(LongTy, 0);
1778 // struct objc_property_list *properties
1779 metaclassFields.add(GeneratePropertyList(OID, classDecl, /*isClassProperty*/true));
1780
1781 auto *metaclass = metaclassFields.finishAndCreateGlobal(
1782 ManglePublicSymbol("OBJC_METACLASS_") + className,
1783 CGM.getPointerAlign());
1784
1785 auto classFields = builder.beginStruct();
1786 // struct objc_class *isa;
1787 classFields.add(metaclass);
1788 // struct objc_class *super_class;
1789 // Get the superclass name.
1790 const ObjCInterfaceDecl * SuperClassDecl =
1792 llvm::Constant *SuperClass = nullptr;
1793 if (SuperClassDecl) {
1794 auto SuperClassName = SymbolForClass(SuperClassDecl->getNameAsString());
1795 SuperClass = TheModule.getNamedGlobal(SuperClassName);
1796 if (!SuperClass)
1797 {
1798 SuperClass = new llvm::GlobalVariable(TheModule, PtrTy, false,
1799 llvm::GlobalValue::ExternalLinkage, nullptr, SuperClassName);
1800 if (IsCOFF) {
1801 auto Storage = llvm::GlobalValue::DefaultStorageClass;
1802 if (SuperClassDecl->hasAttr<DLLImportAttr>())
1803 Storage = llvm::GlobalValue::DLLImportStorageClass;
1804 else if (SuperClassDecl->hasAttr<DLLExportAttr>())
1805 Storage = llvm::GlobalValue::DLLExportStorageClass;
1806
1807 cast<llvm::GlobalValue>(SuperClass)->setDLLStorageClass(Storage);
1808 }
1809 }
1810 if (!IsCOFF)
1811 classFields.add(SuperClass);
1812 else
1813 classFields.addNullPointer(PtrTy);
1814 } else
1815 classFields.addNullPointer(PtrTy);
1816 // const char *name;
1817 classFields.add(classNameConstant);
1818 // long version;
1819 classFields.addInt(LongTy, 0);
1820 // unsigned long info;
1821 // !objc_class_flag_meta
1822 classFields.addInt(LongTy, 0);
1823 // long instance_size;
1824 int superInstanceSize = !SuperClassDecl ? 0 :
1825 Context.getASTObjCInterfaceLayout(SuperClassDecl).getSize().getQuantity();
1826 // Instance size is negative for classes that have not yet had their ivar
1827 // layout calculated.
1828 classFields.addInt(
1829 LongTy, 0 - (Context.getASTObjCInterfaceLayout(OID->getClassInterface())
1830 .getSize()
1831 .getQuantity() -
1832 superInstanceSize));
1833
1834 if (classDecl->all_declared_ivar_begin() == nullptr)
1835 classFields.addNullPointer(PtrTy);
1836 else {
1837 int ivar_count = 0;
1838 for (const ObjCIvarDecl *IVD = classDecl->all_declared_ivar_begin(); IVD;
1839 IVD = IVD->getNextIvar()) ivar_count++;
1840 const llvm::DataLayout &DL = TheModule.getDataLayout();
1841 // struct objc_ivar_list *ivars;
1842 ConstantInitBuilder b(CGM);
1843 auto ivarListBuilder = b.beginStruct();
1844 // int count;
1845 ivarListBuilder.addInt(IntTy, ivar_count);
1846 // size_t size;
1847 llvm::StructType *ObjCIvarTy = llvm::StructType::get(
1848 PtrToInt8Ty,
1849 PtrToInt8Ty,
1850 PtrToInt8Ty,
1851 Int32Ty,
1852 Int32Ty);
1853 ivarListBuilder.addInt(SizeTy, DL.getTypeSizeInBits(ObjCIvarTy) /
1854 CGM.getContext().getCharWidth());
1855 // struct objc_ivar ivars[]
1856 auto ivarArrayBuilder = ivarListBuilder.beginArray();
1857 for (const ObjCIvarDecl *IVD = classDecl->all_declared_ivar_begin(); IVD;
1858 IVD = IVD->getNextIvar()) {
1859 auto ivarTy = IVD->getType();
1860 auto ivarBuilder = ivarArrayBuilder.beginStruct();
1861 // const char *name;
1862 ivarBuilder.add(MakeConstantString(IVD->getNameAsString()));
1863 // const char *type;
1864 std::string TypeStr;
1865 //Context.getObjCEncodingForType(ivarTy, TypeStr, IVD, true);
1866 Context.getObjCEncodingForMethodParameter(Decl::OBJC_TQ_None, ivarTy, TypeStr, true);
1867 ivarBuilder.add(MakeConstantString(TypeStr));
1868 // int *offset;
1869 uint64_t BaseOffset = ComputeIvarBaseOffset(CGM, OID, IVD);
1870 uint64_t Offset = BaseOffset - superInstanceSize;
1871 llvm::Constant *OffsetValue = llvm::ConstantInt::get(IntTy, Offset);
1872 std::string OffsetName = GetIVarOffsetVariableName(classDecl, IVD);
1873 llvm::GlobalVariable *OffsetVar = TheModule.getGlobalVariable(OffsetName);
1874 if (OffsetVar)
1875 OffsetVar->setInitializer(OffsetValue);
1876 else
1877 OffsetVar = new llvm::GlobalVariable(TheModule, IntTy,
1878 false, llvm::GlobalValue::ExternalLinkage,
1879 OffsetValue, OffsetName);
1880 auto ivarVisibility =
1881 (IVD->getAccessControl() == ObjCIvarDecl::Private ||
1882 IVD->getAccessControl() == ObjCIvarDecl::Package ||
1883 classDecl->getVisibility() == HiddenVisibility) ?
1884 llvm::GlobalValue::HiddenVisibility :
1885 llvm::GlobalValue::DefaultVisibility;
1886 OffsetVar->setVisibility(ivarVisibility);
1887 if (ivarVisibility != llvm::GlobalValue::HiddenVisibility)
1888 CGM.setGVProperties(OffsetVar, OID->getClassInterface());
1889 ivarBuilder.add(OffsetVar);
1890 // Ivar size
1891 ivarBuilder.addInt(Int32Ty,
1892 CGM.getContext().getTypeSizeInChars(ivarTy).getQuantity());
1893 // Alignment will be stored as a base-2 log of the alignment.
1894 unsigned align =
1895 llvm::Log2_32(Context.getTypeAlignInChars(ivarTy).getQuantity());
1896 // Objects that require more than 2^64-byte alignment should be impossible!
1897 assert(align < 64);
1898 // uint32_t flags;
1899 // Bits 0-1 are ownership.
1900 // Bit 2 indicates an extended type encoding
1901 // Bits 3-8 contain log2(aligment)
1902 ivarBuilder.addInt(Int32Ty,
1903 (align << 3) | (1<<2) |
1904 FlagsForOwnership(ivarTy.getQualifiers().getObjCLifetime()));
1905 ivarBuilder.finishAndAddTo(ivarArrayBuilder);
1906 }
1907 ivarArrayBuilder.finishAndAddTo(ivarListBuilder);
1908 auto ivarList = ivarListBuilder.finishAndCreateGlobal(".objc_ivar_list",
1909 CGM.getPointerAlign(), /*constant*/ false,
1910 llvm::GlobalValue::PrivateLinkage);
1911 classFields.add(ivarList);
1912 }
1913 // struct objc_method_list *methods
1914 SmallVector<const ObjCMethodDecl*, 16> InstanceMethods;
1915 InstanceMethods.insert(InstanceMethods.begin(), OID->instmeth_begin(),
1916 OID->instmeth_end());
1917 for (auto *propImpl : OID->property_impls())
1918 if (propImpl->getPropertyImplementation() ==
1920 auto addIfExists = [&](const ObjCMethodDecl *OMD) {
1921 if (OMD && OMD->hasBody())
1922 InstanceMethods.push_back(OMD);
1923 };
1924 addIfExists(propImpl->getGetterMethodDecl());
1925 addIfExists(propImpl->getSetterMethodDecl());
1926 }
1927
1928 if (InstanceMethods.size() == 0)
1929 classFields.addNullPointer(PtrTy);
1930 else
1931 classFields.add(
1932 GenerateMethodList(className, "", InstanceMethods, false));
1933
1934 // void *dtable;
1935 classFields.addNullPointer(PtrTy);
1936 // IMP cxx_construct;
1937 classFields.addNullPointer(PtrTy);
1938 // IMP cxx_destruct;
1939 classFields.addNullPointer(PtrTy);
1940 // struct objc_class *subclass_list
1941 classFields.addNullPointer(PtrTy);
1942 // struct objc_class *sibling_class
1943 classFields.addNullPointer(PtrTy);
1944 // struct objc_protocol_list *protocols;
1945 auto RuntimeProtocols =
1946 GetRuntimeProtocolList(classDecl->all_referenced_protocol_begin(),
1947 classDecl->all_referenced_protocol_end());
1948 SmallVector<llvm::Constant *, 16> Protocols;
1949 for (const auto *I : RuntimeProtocols)
1950 Protocols.push_back(GenerateProtocolRef(I));
1951
1952 if (Protocols.empty())
1953 classFields.addNullPointer(PtrTy);
1954 else
1955 classFields.add(GenerateProtocolList(Protocols));
1956 // struct reference_list *extra_data;
1957 classFields.addNullPointer(PtrTy);
1958 // long abi_version;
1959 classFields.addInt(LongTy, 0);
1960 // struct objc_property_list *properties
1961 classFields.add(GeneratePropertyList(OID, classDecl));
1962
1963 llvm::GlobalVariable *classStruct =
1964 classFields.finishAndCreateGlobal(SymbolForClass(className),
1965 CGM.getPointerAlign(), false, llvm::GlobalValue::ExternalLinkage);
1966
1967 auto *classRefSymbol = GetClassVar(className);
1968 classRefSymbol->setSection(sectionName<ClassReferenceSection>());
1969 classRefSymbol->setInitializer(classStruct);
1970
1971 if (IsCOFF) {
1972 // we can't import a class struct.
1973 if (OID->getClassInterface()->hasAttr<DLLExportAttr>()) {
1974 classStruct->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
1975 cast<llvm::GlobalValue>(classRefSymbol)->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
1976 }
1977
1978 if (SuperClass) {
1979 std::pair<llvm::GlobalVariable*, int> v{classStruct, 1};
1980 EarlyInitList.emplace_back(std::string(SuperClass->getName()),
1981 std::move(v));
1982 }
1983
1984 }
1985
1986
1987 // Resolve the class aliases, if they exist.
1988 // FIXME: Class pointer aliases shouldn't exist!
1989 if (ClassPtrAlias) {
1990 ClassPtrAlias->replaceAllUsesWith(classStruct);
1991 ClassPtrAlias->eraseFromParent();
1992 ClassPtrAlias = nullptr;
1993 }
1994 if (auto Placeholder =
1995 TheModule.getNamedGlobal(SymbolForClass(className)))
1996 if (Placeholder != classStruct) {
1997 Placeholder->replaceAllUsesWith(classStruct);
1998 Placeholder->eraseFromParent();
1999 classStruct->setName(SymbolForClass(className));
2000 }
2001 if (MetaClassPtrAlias) {
2002 MetaClassPtrAlias->replaceAllUsesWith(metaclass);
2003 MetaClassPtrAlias->eraseFromParent();
2004 MetaClassPtrAlias = nullptr;
2005 }
2006 assert(classStruct->getName() == SymbolForClass(className));
2007
2008 auto classInitRef = new llvm::GlobalVariable(TheModule,
2009 classStruct->getType(), false, llvm::GlobalValue::ExternalLinkage,
2010 classStruct, ManglePublicSymbol("OBJC_INIT_CLASS_") + className);
2011 classInitRef->setSection(sectionName<ClassSection>());
2012 CGM.addUsedGlobal(classInitRef);
2013
2014 EmittedClass = true;
2015 }
2016 public:
2017 CGObjCGNUstep2(CodeGenModule &Mod) : CGObjCGNUstep(Mod, 10, 4, 2) {
2018 MsgLookupSuperFn.init(&CGM, "objc_msg_lookup_super", IMPTy,
2019 PtrToObjCSuperTy, SelectorTy);
2020 SentInitializeFn.init(&CGM, "objc_send_initialize",
2021 llvm::Type::getVoidTy(VMContext), IdTy);
2022 // struct objc_property
2023 // {
2024 // const char *name;
2025 // const char *attributes;
2026 // const char *type;
2027 // SEL getter;
2028 // SEL setter;
2029 // }
2030 PropertyMetadataTy =
2031 llvm::StructType::get(CGM.getLLVMContext(),
2032 { PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty, PtrToInt8Ty });
2033 }
2034
2035 void GenerateDirectMethodPrologue(CodeGenFunction &CGF, llvm::Function *Fn,
2036 const ObjCMethodDecl *OMD,
2037 const ObjCContainerDecl *CD) override {
2038 auto &Builder = CGF.Builder;
2039 bool ReceiverCanBeNull = true;
2040 auto selfAddr = CGF.GetAddrOfLocalVar(OMD->getSelfDecl());
2041 auto selfValue = Builder.CreateLoad(selfAddr);
2042
2043 // Generate:
2044 //
2045 // /* unless the receiver is never NULL */
2046 // if (self == nil) {
2047 // return (ReturnType){ };
2048 // }
2049 //
2050 // /* for class methods only to force class lazy initialization */
2051 // if (!__objc_{class}_initialized)
2052 // {
2053 // objc_send_initialize(class);
2054 // __objc_{class}_initialized = 1;
2055 // }
2056 //
2057 // _cmd = @selector(...)
2058 // ...
2059
2060 if (OMD->isClassMethod()) {
2061 const ObjCInterfaceDecl *OID = cast<ObjCInterfaceDecl>(CD);
2062
2063 // Nullable `Class` expressions cannot be messaged with a direct method
2064 // so the only reason why the receive can be null would be because
2065 // of weak linking.
2066 ReceiverCanBeNull = isWeakLinkedClass(OID);
2067 }
2068
2069 llvm::MDBuilder MDHelper(CGM.getLLVMContext());
2070 if (ReceiverCanBeNull) {
2071 llvm::BasicBlock *SelfIsNilBlock =
2072 CGF.createBasicBlock("objc_direct_method.self_is_nil");
2073 llvm::BasicBlock *ContBlock =
2074 CGF.createBasicBlock("objc_direct_method.cont");
2075
2076 // if (self == nil) {
2077 auto selfTy = cast<llvm::PointerType>(selfValue->getType());
2078 auto Zero = llvm::ConstantPointerNull::get(selfTy);
2079
2080 Builder.CreateCondBr(Builder.CreateICmpEQ(selfValue, Zero),
2081 SelfIsNilBlock, ContBlock,
2082 MDHelper.createUnlikelyBranchWeights());
2083
2084 CGF.EmitBlock(SelfIsNilBlock);
2085
2086 // return (ReturnType){ };
2087 auto retTy = OMD->getReturnType();
2088 Builder.SetInsertPoint(SelfIsNilBlock);
2089 if (!retTy->isVoidType()) {
2090 CGF.EmitNullInitialization(CGF.ReturnValue, retTy);
2091 }
2093 // }
2094
2095 // rest of the body
2096 CGF.EmitBlock(ContBlock);
2097 Builder.SetInsertPoint(ContBlock);
2098 }
2099
2100 if (OMD->isClassMethod()) {
2101 // Prefix of the class type.
2102 auto *classStart =
2103 llvm::StructType::get(PtrTy, PtrTy, PtrTy, LongTy, LongTy);
2104 auto &astContext = CGM.getContext();
2105 // FIXME: The following few lines up to and including the call to
2106 // `CreateLoad` were known to miscompile when MSVC 19.40.33813 is used
2107 // to build Clang. When the bug is fixed in future MSVC releases, we
2108 // should revert these lines to their previous state. See discussion in
2109 // https://github.com/llvm/llvm-project/pull/102681
2110 llvm::Value *Val = Builder.CreateStructGEP(classStart, selfValue, 4);
2111 auto Align = CharUnits::fromQuantity(
2112 astContext.getTypeAlign(astContext.UnsignedLongTy));
2113 auto flags = Builder.CreateLoad(Address{Val, LongTy, Align});
2114 auto isInitialized =
2115 Builder.CreateAnd(flags, ClassFlags::ClassFlagInitialized);
2116 llvm::BasicBlock *notInitializedBlock =
2117 CGF.createBasicBlock("objc_direct_method.class_uninitialized");
2118 llvm::BasicBlock *initializedBlock =
2119 CGF.createBasicBlock("objc_direct_method.class_initialized");
2120 Builder.CreateCondBr(Builder.CreateICmpEQ(isInitialized, Zeros[0]),
2121 notInitializedBlock, initializedBlock,
2122 MDHelper.createUnlikelyBranchWeights());
2123 CGF.EmitBlock(notInitializedBlock);
2124 Builder.SetInsertPoint(notInitializedBlock);
2125 CGF.EmitRuntimeCall(SentInitializeFn, selfValue);
2126 Builder.CreateBr(initializedBlock);
2127 CGF.EmitBlock(initializedBlock);
2128 Builder.SetInsertPoint(initializedBlock);
2129 }
2130
2131 // only synthesize _cmd if it's referenced
2132 if (OMD->getCmdDecl()->isUsed()) {
2133 // `_cmd` is not a parameter to direct methods, so storage must be
2134 // explicitly declared for it.
2135 CGF.EmitVarDecl(*OMD->getCmdDecl());
2136 Builder.CreateStore(GetSelector(CGF, OMD),
2137 CGF.GetAddrOfLocalVar(OMD->getCmdDecl()));
2138 }
2139 }
2140};
2141
2142const char *const CGObjCGNUstep2::SectionsBaseNames[8] =
2143{
2144"__objc_selectors",
2145"__objc_classes",
2146"__objc_class_refs",
2147"__objc_cats",
2148"__objc_protocols",
2149"__objc_protocol_refs",
2150"__objc_class_aliases",
2151"__objc_constant_string"
2152};
2153
2154const char *const CGObjCGNUstep2::PECOFFSectionsBaseNames[8] =
2155{
2156".objcrt$SEL",
2157".objcrt$CLS",
2158".objcrt$CLR",
2159".objcrt$CAT",
2160".objcrt$PCL",
2161".objcrt$PCR",
2162".objcrt$CAL",
2163".objcrt$STR"
2164};
2165
2166/// Support for the ObjFW runtime.
2167class CGObjCObjFW: public CGObjCGNU {
2168protected:
2169 /// The GCC ABI message lookup function. Returns an IMP pointing to the
2170 /// method implementation for this message.
2171 LazyRuntimeFunction MsgLookupFn;
2172 /// stret lookup function. While this does not seem to make sense at the
2173 /// first look, this is required to call the correct forwarding function.
2174 LazyRuntimeFunction MsgLookupFnSRet;
2175 /// The GCC ABI superclass message lookup function. Takes a pointer to a
2176 /// structure describing the receiver and the class, and a selector as
2177 /// arguments. Returns the IMP for the corresponding method.
2178 LazyRuntimeFunction MsgLookupSuperFn, MsgLookupSuperFnSRet;
2179
2180 llvm::Value *LookupIMP(CodeGenFunction &CGF, llvm::Value *&Receiver,
2181 llvm::Value *cmd, llvm::MDNode *node,
2182 MessageSendInfo &MSI) override {
2183 CGBuilderTy &Builder = CGF.Builder;
2184 llvm::Value *args[] = {
2185 EnforceType(Builder, Receiver, IdTy),
2186 EnforceType(Builder, cmd, SelectorTy) };
2187
2188 llvm::CallBase *imp;
2189 if (CGM.ReturnTypeUsesSRet(MSI.CallInfo))
2190 imp = CGF.EmitRuntimeCallOrInvoke(MsgLookupFnSRet, args);
2191 else
2192 imp = CGF.EmitRuntimeCallOrInvoke(MsgLookupFn, args);
2193
2194 imp->setMetadata(msgSendMDKind, node);
2195 return imp;
2196 }
2197
2198 llvm::Value *LookupIMPSuper(CodeGenFunction &CGF, Address ObjCSuper,
2199 llvm::Value *cmd, MessageSendInfo &MSI) override {
2200 CGBuilderTy &Builder = CGF.Builder;
2201 llvm::Value *lookupArgs[] = {
2202 EnforceType(Builder, ObjCSuper.emitRawPointer(CGF), PtrToObjCSuperTy),
2203 cmd,
2204 };
2205
2206 if (CGM.ReturnTypeUsesSRet(MSI.CallInfo))
2207 return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFnSRet, lookupArgs);
2208 else
2209 return CGF.EmitNounwindRuntimeCall(MsgLookupSuperFn, lookupArgs);
2210 }
2211
2212 llvm::Value *GetClassNamed(CodeGenFunction &CGF, const std::string &Name,
2213 bool isWeak) override {
2214 if (isWeak)
2215 return CGObjCGNU::GetClassNamed(CGF, Name, isWeak);
2216
2217 EmitClassRef(Name);
2218 std::string SymbolName = "_OBJC_CLASS_" + Name;
2219 llvm::GlobalVariable *ClassSymbol = TheModule.getGlobalVariable(SymbolName);
2220 if (!ClassSymbol)
2221 ClassSymbol = new llvm::GlobalVariable(TheModule, LongTy, false,
2222 llvm::GlobalValue::ExternalLinkage,
2223 nullptr, SymbolName);
2224 return ClassSymbol;
2225 }
2226
2227 void GenerateDirectMethodPrologue(
2228 CodeGenFunction &CGF, llvm::Function *Fn, const ObjCMethodDecl *OMD,
2229 const ObjCContainerDecl *CD) override {
2230 auto &Builder = CGF.Builder;
2231 bool ReceiverCanBeNull = true;
2232 auto selfAddr = CGF.GetAddrOfLocalVar(OMD->getSelfDecl());
2233 auto selfValue = Builder.CreateLoad(selfAddr);
2234
2235 // Generate:
2236 //
2237 // /* for class methods only to force class lazy initialization */
2238 // self = [self self];
2239 //
2240 // /* unless the receiver is never NULL */
2241 // if (self == nil) {
2242 // return (ReturnType){ };
2243 // }
2244 //
2245 // _cmd = @selector(...)
2246 // ...
2247
2248 if (OMD->isClassMethod()) {
2249 const ObjCInterfaceDecl *OID = cast<ObjCInterfaceDecl>(CD);
2250 assert(
2251 OID &&
2252 "GenerateDirectMethod() should be called with the Class Interface");
2253 Selector SelfSel = GetNullarySelector("self", CGM.getContext());
2254 auto ResultType = CGF.getContext().getObjCIdType();
2255 RValue result;
2256 CallArgList Args;
2257
2258 // TODO: If this method is inlined, the caller might know that `self` is
2259 // already initialized; for example, it might be an ordinary Objective-C
2260 // method which always receives an initialized `self`, or it might have
2261 // just forced initialization on its own.
2262 //
2263 // We should find a way to eliminate this unnecessary initialization in
2264 // such cases in LLVM.
2265 result = GeneratePossiblySpecializedMessageSend(
2266 CGF, ReturnValueSlot(), ResultType, SelfSel, selfValue, Args, OID,
2267 nullptr, true);
2268 Builder.CreateStore(result.getScalarVal(), selfAddr);
2269
2270 // Nullable `Class` expressions cannot be messaged with a direct method
2271 // so the only reason why the receive can be null would be because
2272 // of weak linking.
2273 ReceiverCanBeNull = isWeakLinkedClass(OID);
2274 }
2275
2276 if (ReceiverCanBeNull) {
2277 llvm::BasicBlock *SelfIsNilBlock =
2278 CGF.createBasicBlock("objc_direct_method.self_is_nil");
2279 llvm::BasicBlock *ContBlock =
2280 CGF.createBasicBlock("objc_direct_method.cont");
2281
2282 // if (self == nil) {
2283 auto selfTy = cast<llvm::PointerType>(selfValue->getType());
2284 auto Zero = llvm::ConstantPointerNull::get(selfTy);
2285
2286 llvm::MDBuilder MDHelper(CGM.getLLVMContext());
2287 Builder.CreateCondBr(Builder.CreateICmpEQ(selfValue, Zero),
2288 SelfIsNilBlock, ContBlock,
2289 MDHelper.createUnlikelyBranchWeights());
2290
2291 CGF.EmitBlock(SelfIsNilBlock);
2292
2293 // return (ReturnType){ };
2294 auto retTy = OMD->getReturnType();
2295 Builder.SetInsertPoint(SelfIsNilBlock);
2296 if (!retTy->isVoidType()) {
2297 CGF.EmitNullInitialization(CGF.ReturnValue, retTy);
2298 }
2300 // }
2301
2302 // rest of the body
2303 CGF.EmitBlock(ContBlock);
2304 Builder.SetInsertPoint(ContBlock);
2305 }
2306
2307 // only synthesize _cmd if it's referenced
2308 if (OMD->getCmdDecl()->isUsed()) {
2309 // `_cmd` is not a parameter to direct methods, so storage must be
2310 // explicitly declared for it.
2311 CGF.EmitVarDecl(*OMD->getCmdDecl());
2312 Builder.CreateStore(GetSelector(CGF, OMD),
2313 CGF.GetAddrOfLocalVar(OMD->getCmdDecl()));
2314 }
2315 }
2316
2317public:
2318 CGObjCObjFW(CodeGenModule &Mod): CGObjCGNU(Mod, 9, 3) {
2319 // IMP objc_msg_lookup(id, SEL);
2320 MsgLookupFn.init(&CGM, "objc_msg_lookup", IMPTy, IdTy, SelectorTy);
2321 MsgLookupFnSRet.init(&CGM, "objc_msg_lookup_stret", IMPTy, IdTy,
2322 SelectorTy);
2323 // IMP objc_msg_lookup_super(struct objc_super*, SEL);
2324 MsgLookupSuperFn.init(&CGM, "objc_msg_lookup_super", IMPTy,
2325 PtrToObjCSuperTy, SelectorTy);
2326 MsgLookupSuperFnSRet.init(&CGM, "objc_msg_lookup_super_stret", IMPTy,
2327 PtrToObjCSuperTy, SelectorTy);
2328 }
2329};
2330} // end anonymous namespace
2331
2332/// Emits a reference to a dummy variable which is emitted with each class.
2333/// This ensures that a linker error will be generated when trying to link
2334/// together modules where a referenced class is not defined.
2335void CGObjCGNU::EmitClassRef(const std::string &className) {
2336 std::string symbolRef = "__objc_class_ref_" + className;
2337 // Don't emit two copies of the same symbol
2338 if (TheModule.getGlobalVariable(symbolRef))
2339 return;
2340 std::string symbolName = "__objc_class_name_" + className;
2341 llvm::GlobalVariable *ClassSymbol = TheModule.getGlobalVariable(symbolName);
2342 if (!ClassSymbol) {
2343 ClassSymbol = new llvm::GlobalVariable(TheModule, LongTy, false,
2344 llvm::GlobalValue::ExternalLinkage,
2345 nullptr, symbolName);
2346 }
2347 new llvm::GlobalVariable(TheModule, ClassSymbol->getType(), true,
2348 llvm::GlobalValue::WeakAnyLinkage, ClassSymbol, symbolRef);
2349}
2350
2351CGObjCGNU::CGObjCGNU(CodeGenModule &cgm, unsigned runtimeABIVersion,
2352 unsigned protocolClassVersion, unsigned classABI)
2353 : CGObjCRuntime(cgm), TheModule(CGM.getModule()),
2354 VMContext(cgm.getLLVMContext()), ClassPtrAlias(nullptr),
2355 MetaClassPtrAlias(nullptr), RuntimeVersion(runtimeABIVersion),
2356 ProtocolVersion(protocolClassVersion), ClassABIVersion(classABI) {
2357
2358 msgSendMDKind = VMContext.getMDKindID("GNUObjCMessageSend");
2359 usesSEHExceptions =
2360 cgm.getContext().getTargetInfo().getTriple().isWindowsMSVCEnvironment();
2361 usesCxxExceptions =
2362 cgm.getContext().getTargetInfo().getTriple().isOSCygMing() &&
2363 isRuntime(ObjCRuntime::GNUstep, 2);
2364
2365 CodeGenTypes &Types = CGM.getTypes();
2367 Types.ConvertType(CGM.getContext().IntTy));
2368 LongTy = cast<llvm::IntegerType>(
2369 Types.ConvertType(CGM.getContext().LongTy));
2370 SizeTy = cast<llvm::IntegerType>(
2371 Types.ConvertType(CGM.getContext().getSizeType()));
2372 PtrDiffTy = cast<llvm::IntegerType>(
2374 BoolTy = CGM.getTypes().ConvertType(CGM.getContext().BoolTy);
2375
2376 Int8Ty = llvm::Type::getInt8Ty(VMContext);
2377
2378 PtrTy = llvm::PointerType::getUnqual(cgm.getLLVMContext());
2379 PtrToIntTy = PtrTy;
2380 // C string type. Used in lots of places.
2381 PtrToInt8Ty = PtrTy;
2382 ProtocolPtrTy = PtrTy;
2383
2384 Zeros[0] = llvm::ConstantInt::get(LongTy, 0);
2385 Zeros[1] = Zeros[0];
2386 NULLPtr = llvm::ConstantPointerNull::get(PtrToInt8Ty);
2387 // Get the selector Type.
2388 QualType selTy = CGM.getContext().getObjCSelType();
2389 if (QualType() == selTy) {
2390 SelectorTy = PtrToInt8Ty;
2391 SelectorElemTy = Int8Ty;
2392 } else {
2393 SelectorTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(selTy));
2394 SelectorElemTy = CGM.getTypes().ConvertTypeForMem(selTy->getPointeeType());
2395 }
2396
2397 Int32Ty = llvm::Type::getInt32Ty(VMContext);
2398 Int64Ty = llvm::Type::getInt64Ty(VMContext);
2399
2400 IntPtrTy =
2401 CGM.getDataLayout().getPointerSizeInBits() == 32 ? Int32Ty : Int64Ty;
2402
2403 // Object type
2404 QualType UnqualIdTy = CGM.getContext().getObjCIdType();
2405 ASTIdTy = CanQualType();
2406 if (UnqualIdTy != QualType()) {
2407 ASTIdTy = CGM.getContext().getCanonicalType(UnqualIdTy);
2408 IdTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(ASTIdTy));
2409 IdElemTy = CGM.getTypes().ConvertTypeForMem(
2410 ASTIdTy.getTypePtr()->getPointeeType());
2411 } else {
2412 IdTy = PtrToInt8Ty;
2413 IdElemTy = Int8Ty;
2414 }
2415 PtrToIdTy = PtrTy;
2416 ProtocolTy = llvm::StructType::get(IdTy,
2417 PtrToInt8Ty, // name
2418 PtrToInt8Ty, // protocols
2419 PtrToInt8Ty, // instance methods
2420 PtrToInt8Ty, // class methods
2421 PtrToInt8Ty, // optional instance methods
2422 PtrToInt8Ty, // optional class methods
2423 PtrToInt8Ty, // properties
2424 PtrToInt8Ty);// optional properties
2425
2426 // struct objc_property_gsv1
2427 // {
2428 // const char *name;
2429 // char attributes;
2430 // char attributes2;
2431 // char unused1;
2432 // char unused2;
2433 // const char *getter_name;
2434 // const char *getter_types;
2435 // const char *setter_name;
2436 // const char *setter_types;
2437 // }
2438 PropertyMetadataTy = llvm::StructType::get(CGM.getLLVMContext(), {
2439 PtrToInt8Ty, Int8Ty, Int8Ty, Int8Ty, Int8Ty, PtrToInt8Ty, PtrToInt8Ty,
2440 PtrToInt8Ty, PtrToInt8Ty });
2441
2442 ObjCSuperTy = llvm::StructType::get(IdTy, IdTy);
2443 PtrToObjCSuperTy = PtrTy;
2444
2445 llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
2446
2447 // void objc_exception_throw(id);
2448 ExceptionThrowFn.init(&CGM, "objc_exception_throw", VoidTy, IdTy);
2449 ExceptionReThrowFn.init(&CGM,
2450 usesCxxExceptions ? "objc_exception_rethrow"
2451 : "objc_exception_throw",
2452 VoidTy, IdTy);
2453 // int objc_sync_enter(id);
2454 SyncEnterFn.init(&CGM, "objc_sync_enter", IntTy, IdTy);
2455 // int objc_sync_exit(id);
2456 SyncExitFn.init(&CGM, "objc_sync_exit", IntTy, IdTy);
2457
2458 // void objc_enumerationMutation (id)
2459 EnumerationMutationFn.init(&CGM, "objc_enumerationMutation", VoidTy, IdTy);
2460
2461 // id objc_getProperty(id, SEL, ptrdiff_t, BOOL)
2462 GetPropertyFn.init(&CGM, "objc_getProperty", IdTy, IdTy, SelectorTy,
2463 PtrDiffTy, BoolTy);
2464 // void objc_setProperty(id, SEL, ptrdiff_t, id, BOOL, BOOL)
2465 SetPropertyFn.init(&CGM, "objc_setProperty", VoidTy, IdTy, SelectorTy,
2466 PtrDiffTy, IdTy, BoolTy, BoolTy);
2467 // void objc_setPropertyStruct(void*, void*, ptrdiff_t, BOOL, BOOL)
2468 GetStructPropertyFn.init(&CGM, "objc_getPropertyStruct", VoidTy, PtrTy, PtrTy,
2469 PtrDiffTy, BoolTy, BoolTy);
2470 // void objc_setPropertyStruct(void*, void*, ptrdiff_t, BOOL, BOOL)
2471 SetStructPropertyFn.init(&CGM, "objc_setPropertyStruct", VoidTy, PtrTy, PtrTy,
2472 PtrDiffTy, BoolTy, BoolTy);
2473
2474 // IMP type
2475 IMPTy = PtrTy;
2476
2477 const LangOptions &Opts = CGM.getLangOpts();
2478 if ((Opts.getGC() != LangOptions::NonGC) || Opts.ObjCAutoRefCount)
2479 RuntimeVersion = 10;
2480
2481 // Don't bother initialising the GC stuff unless we're compiling in GC mode
2482 if (Opts.getGC() != LangOptions::NonGC) {
2483 // This is a bit of an hack. We should sort this out by having a proper
2484 // CGObjCGNUstep subclass for GC, but we may want to really support the old
2485 // ABI and GC added in ObjectiveC2.framework, so we fudge it a bit for now
2486 // Get selectors needed in GC mode
2487 RetainSel = GetNullarySelector("retain", CGM.getContext());
2488 ReleaseSel = GetNullarySelector("release", CGM.getContext());
2489 AutoreleaseSel = GetNullarySelector("autorelease", CGM.getContext());
2490
2491 // Get functions needed in GC mode
2492
2493 // id objc_assign_ivar(id, id, ptrdiff_t);
2494 IvarAssignFn.init(&CGM, "objc_assign_ivar", IdTy, IdTy, IdTy, PtrDiffTy);
2495 // id objc_assign_strongCast (id, id*)
2496 StrongCastAssignFn.init(&CGM, "objc_assign_strongCast", IdTy, IdTy,
2497 PtrToIdTy);
2498 // id objc_assign_global(id, id*);
2499 GlobalAssignFn.init(&CGM, "objc_assign_global", IdTy, IdTy, PtrToIdTy);
2500 // id objc_assign_weak(id, id*);
2501 WeakAssignFn.init(&CGM, "objc_assign_weak", IdTy, IdTy, PtrToIdTy);
2502 // id objc_read_weak(id*);
2503 WeakReadFn.init(&CGM, "objc_read_weak", IdTy, PtrToIdTy);
2504 // void *objc_memmove_collectable(void*, void *, size_t);
2505 MemMoveFn.init(&CGM, "objc_memmove_collectable", PtrTy, PtrTy, PtrTy,
2506 SizeTy);
2507 }
2508}
2509
2510llvm::Value *CGObjCGNU::GetClassNamed(CodeGenFunction &CGF,
2511 const std::string &Name, bool isWeak) {
2512 llvm::Constant *ClassName = MakeConstantString(Name);
2513 // With the incompatible ABI, this will need to be replaced with a direct
2514 // reference to the class symbol. For the compatible nonfragile ABI we are
2515 // still performing this lookup at run time but emitting the symbol for the
2516 // class externally so that we can make the switch later.
2517 //
2518 // Libobjc2 contains an LLVM pass that replaces calls to objc_lookup_class
2519 // with memoized versions or with static references if it's safe to do so.
2520 if (!isWeak)
2521 EmitClassRef(Name);
2522
2523 llvm::FunctionCallee ClassLookupFn = CGM.CreateRuntimeFunction(
2524 llvm::FunctionType::get(IdTy, PtrToInt8Ty, true), "objc_lookup_class");
2525 return CGF.EmitNounwindRuntimeCall(ClassLookupFn, ClassName);
2526}
2527
2528// This has to perform the lookup every time, since posing and related
2529// techniques can modify the name -> class mapping.
2530llvm::Value *CGObjCGNU::GetClass(CodeGenFunction &CGF,
2531 const ObjCInterfaceDecl *OID) {
2532 auto *Value =
2533 GetClassNamed(CGF, OID->getNameAsString(), OID->isWeakImported());
2534 if (auto *ClassSymbol = dyn_cast<llvm::GlobalVariable>(Value))
2535 CGM.setGVProperties(ClassSymbol, OID);
2536 return Value;
2537}
2538
2539llvm::Value *CGObjCGNU::EmitNSAutoreleasePoolClassRef(CodeGenFunction &CGF) {
2540 auto *Value = GetClassNamed(CGF, "NSAutoreleasePool", false);
2541 if (CGM.getTriple().isOSBinFormatCOFF()) {
2542 if (auto *ClassSymbol = dyn_cast<llvm::GlobalVariable>(Value)) {
2543 IdentifierInfo &II = CGF.CGM.getContext().Idents.get("NSAutoreleasePool");
2544 TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl();
2545 DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl);
2546
2547 const VarDecl *VD = nullptr;
2548 for (const auto *Result : DC->lookup(&II))
2549 if ((VD = dyn_cast<VarDecl>(Result)))
2550 break;
2551
2552 CGM.setGVProperties(ClassSymbol, VD);
2553 }
2554 }
2555 return Value;
2556}
2557
2558llvm::Value *CGObjCGNU::GetTypedSelector(CodeGenFunction &CGF, Selector Sel,
2559 const std::string &TypeEncoding) {
2560 SmallVectorImpl<TypedSelector> &Types = SelectorTable[Sel];
2561 llvm::GlobalAlias *SelValue = nullptr;
2562
2563 for (const TypedSelector &Type : Types) {
2564 if (Type.first == TypeEncoding) {
2565 SelValue = Type.second;
2566 break;
2567 }
2568 }
2569 if (!SelValue) {
2570 SelValue = llvm::GlobalAlias::create(SelectorElemTy, 0,
2571 llvm::GlobalValue::PrivateLinkage,
2572 ".objc_selector_" + Sel.getAsString(),
2573 &TheModule);
2574 Types.emplace_back(TypeEncoding, SelValue);
2575 }
2576
2577 return SelValue;
2578}
2579
2580Address CGObjCGNU::GetAddrOfSelector(CodeGenFunction &CGF, Selector Sel) {
2581 llvm::Value *SelValue = GetSelector(CGF, Sel);
2582
2583 // Store it to a temporary. Does this satisfy the semantics of
2584 // GetAddrOfSelector? Hopefully.
2585 Address tmp = CGF.CreateTempAlloca(SelValue->getType(),
2586 CGF.getPointerAlign());
2587 CGF.Builder.CreateStore(SelValue, tmp);
2588 return tmp;
2589}
2590
2591llvm::Value *CGObjCGNU::GetSelector(CodeGenFunction &CGF, Selector Sel) {
2592 return GetTypedSelector(CGF, Sel, std::string());
2593}
2594
2595llvm::Value *CGObjCGNU::GetSelector(CodeGenFunction &CGF,
2596 const ObjCMethodDecl *Method) {
2597 std::string SelTypes = CGM.getContext().getObjCEncodingForMethodDecl(Method);
2598 return GetTypedSelector(CGF, Method->getSelector(), SelTypes);
2599}
2600
2601llvm::Constant *CGObjCGNU::GetEHType(QualType T) {
2602 if (T->isObjCIdType() || T->isObjCQualifiedIdType()) {
2603 // With the old ABI, there was only one kind of catchall, which broke
2604 // foreign exceptions. With the new ABI, we use __objc_id_typeinfo as
2605 // a pointer indicating object catchalls, and NULL to indicate real
2606 // catchalls
2607 if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
2608 return MakeConstantString("@id");
2609 } else {
2610 return nullptr;
2611 }
2612 }
2613
2614 // All other types should be Objective-C interface pointer types.
2615 const ObjCObjectPointerType *OPT = T->getAs<ObjCObjectPointerType>();
2616 assert(OPT && "Invalid @catch type.");
2617 const ObjCInterfaceDecl *IDecl = OPT->getObjectType()->getInterface();
2618 assert(IDecl && "Invalid @catch type.");
2619 return MakeConstantString(IDecl->getIdentifier()->getName());
2620}
2621
2622llvm::Constant *CGObjCGNUstep::GetEHType(QualType T) {
2623 if (usesSEHExceptions)
2624 return CGM.getCXXABI().getAddrOfRTTIDescriptor(T);
2625
2626 if (!CGM.getLangOpts().CPlusPlus && !usesCxxExceptions)
2627 return CGObjCGNU::GetEHType(T);
2628
2629 // For Objective-C++, we want to provide the ability to catch both C++ and
2630 // Objective-C objects in the same function.
2631
2632 // There's a particular fixed type info for 'id'.
2633 if (T->isObjCIdType() ||
2635 llvm::Constant *IDEHType =
2636 CGM.getModule().getGlobalVariable("__objc_id_type_info");
2637 if (!IDEHType)
2638 IDEHType =
2639 new llvm::GlobalVariable(CGM.getModule(), PtrToInt8Ty,
2640 false,
2641 llvm::GlobalValue::ExternalLinkage,
2642 nullptr, "__objc_id_type_info");
2643 return IDEHType;
2644 }
2645
2646 const ObjCObjectPointerType *PT =
2647 T->getAs<ObjCObjectPointerType>();
2648 assert(PT && "Invalid @catch type.");
2649 const ObjCInterfaceType *IT = PT->getInterfaceType();
2650 assert(IT && "Invalid @catch type.");
2651 std::string className =
2652 std::string(IT->getDecl()->getIdentifier()->getName());
2653
2654 std::string typeinfoName = "__objc_eh_typeinfo_" + className;
2655
2656 // Return the existing typeinfo if it exists
2657 if (llvm::Constant *typeinfo = TheModule.getGlobalVariable(typeinfoName))
2658 return typeinfo;
2659
2660 // Otherwise create it.
2661
2662 // vtable for gnustep::libobjc::__objc_class_type_info
2663 // It's quite ugly hard-coding this. Ideally we'd generate it using the host
2664 // platform's name mangling.
2665 const char *vtableName = "_ZTVN7gnustep7libobjc22__objc_class_type_infoE";
2666 auto *Vtable = TheModule.getGlobalVariable(vtableName);
2667 if (!Vtable) {
2668 Vtable = new llvm::GlobalVariable(TheModule, PtrToInt8Ty, true,
2669 llvm::GlobalValue::ExternalLinkage,
2670 nullptr, vtableName);
2671 }
2672 llvm::Constant *Two = llvm::ConstantInt::get(IntTy, 2);
2673 auto *BVtable =
2674 llvm::ConstantExpr::getGetElementPtr(Vtable->getValueType(), Vtable, Two);
2675
2676 llvm::Constant *typeName =
2677 ExportUniqueString(className, "__objc_eh_typename_");
2678
2679 ConstantInitBuilder builder(CGM);
2680 auto fields = builder.beginStruct();
2681 fields.add(BVtable);
2682 fields.add(typeName);
2683 llvm::Constant *TI =
2684 fields.finishAndCreateGlobal("__objc_eh_typeinfo_" + className,
2685 CGM.getPointerAlign(),
2686 /*constant*/ false,
2687 llvm::GlobalValue::LinkOnceODRLinkage);
2688 return TI;
2689}
2690
2691/// Generate an NSConstantString object.
2692ConstantAddress CGObjCGNU::GenerateConstantString(const StringLiteral *SL) {
2693
2694 std::string Str = SL->getString().str();
2695 CharUnits Align = CGM.getPointerAlign();
2696
2697 // Look for an existing one
2698 llvm::StringMap<llvm::Constant*>::iterator old = ObjCStrings.find(Str);
2699 if (old != ObjCStrings.end())
2700 return ConstantAddress(old->getValue(), Int8Ty, Align);
2701
2702 StringRef StringClass = CGM.getLangOpts().ObjCConstantStringClass;
2703
2704 if (StringClass.empty()) StringClass = "NSConstantString";
2705
2706 std::string Sym = "_OBJC_CLASS_";
2707 Sym += StringClass;
2708
2709 llvm::Constant *isa = TheModule.getNamedGlobal(Sym);
2710
2711 if (!isa)
2712 isa = new llvm::GlobalVariable(TheModule, IdTy, /* isConstant */ false,
2713 llvm::GlobalValue::ExternalWeakLinkage,
2714 nullptr, Sym);
2715
2716 ConstantInitBuilder Builder(CGM);
2717 auto Fields = Builder.beginStruct();
2718 Fields.add(isa);
2719 Fields.add(MakeConstantString(Str));
2720 Fields.addInt(IntTy, Str.size());
2721 llvm::Constant *ObjCStr = Fields.finishAndCreateGlobal(".objc_str", Align);
2722 ObjCStrings[Str] = ObjCStr;
2723 ConstantStrings.push_back(ObjCStr);
2724 return ConstantAddress(ObjCStr, Int8Ty, Align);
2725}
2726
2727///Generates a message send where the super is the receiver. This is a message
2728///send to self with special delivery semantics indicating which class's method
2729///should be called.
2730RValue
2731CGObjCGNU::GenerateMessageSendSuper(CodeGenFunction &CGF,
2732 ReturnValueSlot Return,
2733 QualType ResultType,
2734 Selector Sel,
2735 const ObjCInterfaceDecl *Class,
2736 bool isCategoryImpl,
2737 llvm::Value *Receiver,
2738 bool IsClassMessage,
2739 const CallArgList &CallArgs,
2740 const ObjCMethodDecl *Method) {
2741 CGBuilderTy &Builder = CGF.Builder;
2742 if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) {
2743 if (Sel == RetainSel || Sel == AutoreleaseSel) {
2744 return RValue::get(EnforceType(Builder, Receiver,
2745 CGM.getTypes().ConvertType(ResultType)));
2746 }
2747 if (Sel == ReleaseSel) {
2748 return RValue::get(nullptr);
2749 }
2750 }
2751
2752 llvm::Value *cmd = GetSelector(CGF, Sel);
2753 CallArgList ActualArgs;
2754
2755 ActualArgs.add(RValue::get(EnforceType(Builder, Receiver, IdTy)), ASTIdTy);
2756 ActualArgs.add(RValue::get(cmd), CGF.getContext().getObjCSelType());
2757 ActualArgs.addFrom(CallArgs);
2758
2759 MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs);
2760
2761 llvm::Value *ReceiverClass = nullptr;
2762 bool isV2ABI = isRuntime(ObjCRuntime::GNUstep, 2);
2763 if (isV2ABI) {
2764 ReceiverClass = GetClassNamed(CGF,
2765 Class->getSuperClass()->getNameAsString(), /*isWeak*/false);
2766 if (IsClassMessage) {
2767 // Load the isa pointer of the superclass is this is a class method.
2768 ReceiverClass =
2769 Builder.CreateAlignedLoad(IdTy, ReceiverClass, CGF.getPointerAlign());
2770 }
2771 ReceiverClass = EnforceType(Builder, ReceiverClass, IdTy);
2772 } else {
2773 if (isCategoryImpl) {
2774 llvm::FunctionCallee classLookupFunction = nullptr;
2775 if (IsClassMessage) {
2776 classLookupFunction = CGM.CreateRuntimeFunction(llvm::FunctionType::get(
2777 IdTy, PtrTy, true), "objc_get_meta_class");
2778 } else {
2779 classLookupFunction = CGM.CreateRuntimeFunction(llvm::FunctionType::get(
2780 IdTy, PtrTy, true), "objc_get_class");
2781 }
2782 ReceiverClass = Builder.CreateCall(classLookupFunction,
2783 MakeConstantString(Class->getNameAsString()));
2784 } else {
2785 // Set up global aliases for the metaclass or class pointer if they do not
2786 // already exist. These will are forward-references which will be set to
2787 // pointers to the class and metaclass structure created for the runtime
2788 // load function. To send a message to super, we look up the value of the
2789 // super_class pointer from either the class or metaclass structure.
2790 if (IsClassMessage) {
2791 if (!MetaClassPtrAlias) {
2792 MetaClassPtrAlias = llvm::GlobalAlias::create(
2793 IdElemTy, 0, llvm::GlobalValue::InternalLinkage,
2794 ".objc_metaclass_ref" + Class->getNameAsString(), &TheModule);
2795 }
2796 ReceiverClass = MetaClassPtrAlias;
2797 } else {
2798 if (!ClassPtrAlias) {
2799 ClassPtrAlias = llvm::GlobalAlias::create(
2800 IdElemTy, 0, llvm::GlobalValue::InternalLinkage,
2801 ".objc_class_ref" + Class->getNameAsString(), &TheModule);
2802 }
2803 ReceiverClass = ClassPtrAlias;
2804 }
2805 }
2806 // Cast the pointer to a simplified version of the class structure
2807 llvm::Type *CastTy = llvm::StructType::get(IdTy, IdTy);
2808 // Get the superclass pointer
2809 ReceiverClass = Builder.CreateStructGEP(CastTy, ReceiverClass, 1);
2810 // Load the superclass pointer
2811 ReceiverClass =
2812 Builder.CreateAlignedLoad(IdTy, ReceiverClass, CGF.getPointerAlign());
2813 }
2814 // Construct the structure used to look up the IMP
2815 llvm::StructType *ObjCSuperTy =
2816 llvm::StructType::get(Receiver->getType(), IdTy);
2817
2818 Address ObjCSuper = CGF.CreateTempAlloca(ObjCSuperTy,
2819 CGF.getPointerAlign());
2820
2821 Builder.CreateStore(Receiver, Builder.CreateStructGEP(ObjCSuper, 0));
2822 Builder.CreateStore(ReceiverClass, Builder.CreateStructGEP(ObjCSuper, 1));
2823
2824 // Get the IMP
2825 llvm::Value *imp = LookupIMPSuper(CGF, ObjCSuper, cmd, MSI);
2826 imp = EnforceType(Builder, imp, MSI.MessengerType);
2827
2828 llvm::Metadata *impMD[] = {
2829 llvm::MDString::get(VMContext, Sel.getAsString()),
2830 llvm::MDString::get(VMContext, Class->getSuperClass()->getNameAsString()),
2831 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
2832 llvm::Type::getInt1Ty(VMContext), IsClassMessage))};
2833 llvm::MDNode *node = llvm::MDNode::get(VMContext, impMD);
2834
2835 CGCallee callee(CGCalleeInfo(), imp);
2836
2837 llvm::CallBase *call;
2838 RValue msgRet = CGF.EmitCall(MSI.CallInfo, callee, Return, ActualArgs, &call);
2839 call->setMetadata(msgSendMDKind, node);
2840 return msgRet;
2841}
2842
2843/// Generate code for a message send expression.
2844RValue
2845CGObjCGNU::GenerateMessageSend(CodeGenFunction &CGF,
2846 ReturnValueSlot Return,
2847 QualType ResultType,
2848 Selector Sel,
2849 llvm::Value *Receiver,
2850 const CallArgList &CallArgs,
2851 const ObjCInterfaceDecl *Class,
2852 const ObjCMethodDecl *Method) {
2853 CGBuilderTy &Builder = CGF.Builder;
2854
2855 // Strip out message sends to retain / release in GC mode
2856 if (CGM.getLangOpts().getGC() == LangOptions::GCOnly) {
2857 if (Sel == RetainSel || Sel == AutoreleaseSel) {
2858 return RValue::get(EnforceType(Builder, Receiver,
2859 CGM.getTypes().ConvertType(ResultType)));
2860 }
2861 if (Sel == ReleaseSel) {
2862 return RValue::get(nullptr);
2863 }
2864 }
2865
2866 bool isDirect = Method && Method->isDirectMethod();
2867
2868 IdTy = cast<llvm::PointerType>(CGM.getTypes().ConvertType(ASTIdTy));
2869 llvm::Value *cmd;
2870 if (!isDirect) {
2871 if (Method)
2872 cmd = GetSelector(CGF, Method);
2873 else
2874 cmd = GetSelector(CGF, Sel);
2875 cmd = EnforceType(Builder, cmd, SelectorTy);
2876 }
2877
2878 Receiver = EnforceType(Builder, Receiver, IdTy);
2879
2880 llvm::Metadata *impMD[] = {
2881 llvm::MDString::get(VMContext, Sel.getAsString()),
2882 llvm::MDString::get(VMContext, Class ? Class->getNameAsString() : ""),
2883 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
2884 llvm::Type::getInt1Ty(VMContext), Class != nullptr))};
2885 llvm::MDNode *node = llvm::MDNode::get(VMContext, impMD);
2886
2887 CallArgList ActualArgs;
2888 ActualArgs.add(RValue::get(Receiver), ASTIdTy);
2889 if (!isDirect)
2890 ActualArgs.add(RValue::get(cmd), CGF.getContext().getObjCSelType());
2891 ActualArgs.addFrom(CallArgs);
2892
2893 MessageSendInfo MSI = getMessageSendInfo(Method, ResultType, ActualArgs);
2894
2895 // Message sends are expected to return a zero value when the
2896 // receiver is nil. At one point, this was only guaranteed for
2897 // simple integer and pointer types, but expectations have grown
2898 // over time.
2899 //
2900 // Given a nil receiver, the GNU runtime's message lookup will
2901 // return a stub function that simply sets various return-value
2902 // registers to zero and then returns. That's good enough for us
2903 // if and only if (1) the calling conventions of that stub are
2904 // compatible with the signature we're using and (2) the registers
2905 // it sets are sufficient to produce a zero value of the return type.
2906 // Rather than doing a whole target-specific analysis, we assume it
2907 // only works for void, integer, and pointer types, and in all
2908 // other cases we do an explicit nil check is emitted code. In
2909 // addition to ensuring we produce a zero value for other types, this
2910 // sidesteps the few outright CC incompatibilities we know about that
2911 // could otherwise lead to crashes, like when a method is expected to
2912 // return on the x87 floating point stack or adjust the stack pointer
2913 // because of an indirect return.
2914 bool hasParamDestroyedInCallee = false;
2915 bool requiresExplicitZeroResult = false;
2916 bool requiresNilReceiverCheck = [&] {
2917 // We never need a check if we statically know the receiver isn't nil.
2918 if (!canMessageReceiverBeNull(CGF, Method, /*IsSuper*/ false,
2919 Class, Receiver))
2920 return false;
2921
2922 // If there's a consumed argument, we need a nil check.
2923 if (Method && Method->hasParamDestroyedInCallee()) {
2924 hasParamDestroyedInCallee = true;
2925 }
2926
2927 // If the return value isn't flagged as unused, and the result
2928 // type isn't in our narrow set where we assume compatibility,
2929 // we need a nil check to ensure a nil value.
2930 if (!Return.isUnused()) {
2931 if (ResultType->isVoidType()) {
2932 // void results are definitely okay.
2933 } else if (ResultType->hasPointerRepresentation() &&
2934 CGM.getTypes().isZeroInitializable(ResultType)) {
2935 // Pointer types should be fine as long as they have
2936 // bitwise-zero null pointers. But do we need to worry
2937 // about unusual address spaces?
2938 } else if (ResultType->isIntegralOrEnumerationType()) {
2939 // Bitwise zero should always be zero for integral types.
2940 // FIXME: we probably need a size limit here, but we've
2941 // never imposed one before
2942 } else {
2943 // Otherwise, use an explicit check just to be sure, unless we're
2944 // calling a direct method, where the implementation does this for us.
2945 requiresExplicitZeroResult = !isDirect;
2946 }
2947 }
2948
2949 return hasParamDestroyedInCallee || requiresExplicitZeroResult;
2950 }();
2951
2952 // We will need to explicitly zero-initialize an aggregate result slot
2953 // if we generally require explicit zeroing and we have an aggregate
2954 // result.
2955 bool requiresExplicitAggZeroing =
2956 requiresExplicitZeroResult && CGF.hasAggregateEvaluationKind(ResultType);
2957
2958 // The block we're going to end up in after any message send or nil path.
2959 llvm::BasicBlock *continueBB = nullptr;
2960 // The block that eventually branched to continueBB along the nil path.
2961 llvm::BasicBlock *nilPathBB = nullptr;
2962 // The block to do explicit work in along the nil path, if necessary.
2963 llvm::BasicBlock *nilCleanupBB = nullptr;
2964
2965 // Emit the nil-receiver check.
2966 if (requiresNilReceiverCheck) {
2967 llvm::BasicBlock *messageBB = CGF.createBasicBlock("msgSend");
2968 continueBB = CGF.createBasicBlock("continue");
2969
2970 // If we need to zero-initialize an aggregate result or destroy
2971 // consumed arguments, we'll need a separate cleanup block.
2972 // Otherwise we can just branch directly to the continuation block.
2973 if (requiresExplicitAggZeroing || hasParamDestroyedInCallee) {
2974 nilCleanupBB = CGF.createBasicBlock("nilReceiverCleanup");
2975 } else {
2976 nilPathBB = Builder.GetInsertBlock();
2977 }
2978
2979 llvm::Value *isNil = Builder.CreateICmpEQ(Receiver,
2980 llvm::Constant::getNullValue(Receiver->getType()));
2981 Builder.CreateCondBr(isNil, nilCleanupBB ? nilCleanupBB : continueBB,
2982 messageBB);
2983 CGF.EmitBlock(messageBB);
2984 }
2985
2986 // Get the IMP to call
2987 llvm::Value *imp;
2988
2989 // If this is a direct method, just emit it here.
2990 if (isDirect)
2991 imp = GenerateMethod(Method, Method->getClassInterface());
2992 else
2993 // If we have non-legacy dispatch specified, we try using the
2994 // objc_msgSend() functions. These are not supported on all platforms
2995 // (or all runtimes on a given platform), so we
2996 switch (CGM.getCodeGenOpts().getObjCDispatchMethod()) {
2998 imp = LookupIMP(CGF, Receiver, cmd, node, MSI);
2999 break;
3002 StringRef name = "objc_msgSend";
3003 if (CGM.ReturnTypeUsesFPRet(ResultType)) {
3004 name = "objc_msgSend_fpret";
3005 } else if (CGM.ReturnTypeUsesSRet(MSI.CallInfo)) {
3006 name = "objc_msgSend_stret";
3007
3008 // The address of the memory block is be passed in x8 for POD type,
3009 // or in x0 for non-POD type (marked as inreg).
3010 bool shouldCheckForInReg =
3011 CGM.getContext()
3012 .getTargetInfo()
3013 .getTriple()
3014 .isWindowsMSVCEnvironment() &&
3015 CGM.getContext().getTargetInfo().getTriple().isAArch64();
3016 if (shouldCheckForInReg && CGM.ReturnTypeHasInReg(MSI.CallInfo)) {
3017 name = "objc_msgSend_stret2";
3018 }
3019 }
3020 // The actual types here don't matter - we're going to bitcast the
3021 // function anyway
3022 imp = CGM.CreateRuntimeFunction(llvm::FunctionType::get(IdTy, IdTy, true),
3023 name)
3024 .getCallee();
3025 }
3026
3027 // Reset the receiver in case the lookup modified it
3028 ActualArgs[0] = CallArg(RValue::get(Receiver), ASTIdTy);
3029
3030 imp = EnforceType(Builder, imp, MSI.MessengerType);
3031
3032 llvm::CallBase *call;
3033 CGCallee callee(CGCalleeInfo(), imp);
3034 RValue msgRet = CGF.EmitCall(MSI.CallInfo, callee, Return, ActualArgs, &call);
3035 if (!isDirect)
3036 call->setMetadata(msgSendMDKind, node);
3037
3038 if (requiresNilReceiverCheck) {
3039 llvm::BasicBlock *nonNilPathBB = CGF.Builder.GetInsertBlock();
3040 CGF.Builder.CreateBr(continueBB);
3041
3042 // Emit the nil path if we decided it was necessary above.
3043 if (nilCleanupBB) {
3044 CGF.EmitBlock(nilCleanupBB);
3045
3046 if (hasParamDestroyedInCallee) {
3047 destroyCalleeDestroyedArguments(CGF, Method, CallArgs);
3048 }
3049
3050 if (requiresExplicitAggZeroing) {
3051 assert(msgRet.isAggregate());
3052 Address addr = msgRet.getAggregateAddress();
3053 CGF.EmitNullInitialization(addr, ResultType);
3054 }
3055
3056 nilPathBB = CGF.Builder.GetInsertBlock();
3057 CGF.Builder.CreateBr(continueBB);
3058 }
3059
3060 // Enter the continuation block and emit a phi if required.
3061 CGF.EmitBlock(continueBB);
3062 if (msgRet.isScalar()) {
3063 // If the return type is void, do nothing
3064 if (llvm::Value *v = msgRet.getScalarVal()) {
3065 llvm::PHINode *phi = Builder.CreatePHI(v->getType(), 2);
3066 phi->addIncoming(v, nonNilPathBB);
3067 phi->addIncoming(CGM.EmitNullConstant(ResultType), nilPathBB);
3068 msgRet = RValue::get(phi);
3069 }
3070 } else if (msgRet.isAggregate()) {
3071 // Aggregate zeroing is handled in nilCleanupBB when it's required.
3072 } else /* isComplex() */ {
3073 std::pair<llvm::Value*,llvm::Value*> v = msgRet.getComplexVal();
3074 llvm::PHINode *phi = Builder.CreatePHI(v.first->getType(), 2);
3075 phi->addIncoming(v.first, nonNilPathBB);
3076 phi->addIncoming(llvm::Constant::getNullValue(v.first->getType()),
3077 nilPathBB);
3078 llvm::PHINode *phi2 = Builder.CreatePHI(v.second->getType(), 2);
3079 phi2->addIncoming(v.second, nonNilPathBB);
3080 phi2->addIncoming(llvm::Constant::getNullValue(v.second->getType()),
3081 nilPathBB);
3082 msgRet = RValue::getComplex(phi, phi2);
3083 }
3084 }
3085 return msgRet;
3086}
3087
3088/// Generates a MethodList. Used in construction of a objc_class and
3089/// objc_category structures.
3090llvm::Constant *CGObjCGNU::
3091GenerateMethodList(StringRef ClassName,
3092 StringRef CategoryName,
3093 ArrayRef<const ObjCMethodDecl*> Methods,
3094 bool isClassMethodList) {
3095 if (Methods.empty())
3096 return NULLPtr;
3097
3098 ConstantInitBuilder Builder(CGM);
3099
3100 auto MethodList = Builder.beginStruct();
3101 MethodList.addNullPointer(CGM.Int8PtrTy);
3102 MethodList.addInt(Int32Ty, Methods.size());
3103
3104 // Get the method structure type.
3105 llvm::StructType *ObjCMethodTy =
3106 llvm::StructType::get(CGM.getLLVMContext(), {
3107 PtrToInt8Ty, // Really a selector, but the runtime creates it us.
3108 PtrToInt8Ty, // Method types
3109 IMPTy // Method pointer
3110 });
3111 bool isV2ABI = isRuntime(ObjCRuntime::GNUstep, 2);
3112 if (isV2ABI) {
3113 // size_t size;
3114 const llvm::DataLayout &DL = TheModule.getDataLayout();
3115 MethodList.addInt(SizeTy, DL.getTypeSizeInBits(ObjCMethodTy) /
3116 CGM.getContext().getCharWidth());
3117 ObjCMethodTy =
3118 llvm::StructType::get(CGM.getLLVMContext(), {
3119 IMPTy, // Method pointer
3120 PtrToInt8Ty, // Selector
3121 PtrToInt8Ty // Extended type encoding
3122 });
3123 } else {
3124 ObjCMethodTy =
3125 llvm::StructType::get(CGM.getLLVMContext(), {
3126 PtrToInt8Ty, // Really a selector, but the runtime creates it us.
3127 PtrToInt8Ty, // Method types
3128 IMPTy // Method pointer
3129 });
3130 }
3131 auto MethodArray = MethodList.beginArray();
3132 ASTContext &Context = CGM.getContext();
3133 for (const auto *OMD : Methods) {
3134 llvm::Constant *FnPtr =
3135 TheModule.getFunction(getSymbolNameForMethod(OMD));
3136 assert(FnPtr && "Can't generate metadata for method that doesn't exist");
3137 auto Method = MethodArray.beginStruct(ObjCMethodTy);
3138 if (isV2ABI) {
3139 Method.add(FnPtr);
3140 Method.add(GetConstantSelector(OMD->getSelector(),
3141 Context.getObjCEncodingForMethodDecl(OMD)));
3142 Method.add(MakeConstantString(Context.getObjCEncodingForMethodDecl(OMD, true)));
3143 } else {
3144 Method.add(MakeConstantString(OMD->getSelector().getAsString()));
3145 Method.add(MakeConstantString(Context.getObjCEncodingForMethodDecl(OMD)));
3146 Method.add(FnPtr);
3147 }
3148 Method.finishAndAddTo(MethodArray);
3149 }
3150 MethodArray.finishAndAddTo(MethodList);
3151
3152 // Create an instance of the structure
3153 return MethodList.finishAndCreateGlobal(".objc_method_list",
3154 CGM.getPointerAlign());
3155}
3156
3157/// Generates an IvarList. Used in construction of a objc_class.
3158llvm::Constant *CGObjCGNU::
3159GenerateIvarList(ArrayRef<llvm::Constant *> IvarNames,
3160 ArrayRef<llvm::Constant *> IvarTypes,
3161 ArrayRef<llvm::Constant *> IvarOffsets,
3162 ArrayRef<llvm::Constant *> IvarAlign,
3163 ArrayRef<Qualifiers::ObjCLifetime> IvarOwnership) {
3164 if (IvarNames.empty())
3165 return NULLPtr;
3166
3167 ConstantInitBuilder Builder(CGM);
3168
3169 // Structure containing array count followed by array.
3170 auto IvarList = Builder.beginStruct();
3171 IvarList.addInt(IntTy, (int)IvarNames.size());
3172
3173 // Get the ivar structure type.
3174 llvm::StructType *ObjCIvarTy =
3175 llvm::StructType::get(PtrToInt8Ty, PtrToInt8Ty, IntTy);
3176
3177 // Array of ivar structures.
3178 auto Ivars = IvarList.beginArray(ObjCIvarTy);
3179 for (unsigned int i = 0, e = IvarNames.size() ; i < e ; i++) {
3180 auto Ivar = Ivars.beginStruct(ObjCIvarTy);
3181 Ivar.add(IvarNames[i]);
3182 Ivar.add(IvarTypes[i]);
3183 Ivar.add(IvarOffsets[i]);
3184 Ivar.finishAndAddTo(Ivars);
3185 }
3186 Ivars.finishAndAddTo(IvarList);
3187
3188 // Create an instance of the structure
3189 return IvarList.finishAndCreateGlobal(".objc_ivar_list",
3190 CGM.getPointerAlign());
3191}
3192
3193/// Generate a class structure
3194llvm::Constant *CGObjCGNU::GenerateClassStructure(
3195 llvm::Constant *MetaClass,
3196 llvm::Constant *SuperClass,
3197 unsigned info,
3198 const char *Name,
3199 llvm::Constant *Version,
3200 llvm::Constant *InstanceSize,
3201 llvm::Constant *IVars,
3202 llvm::Constant *Methods,
3203 llvm::Constant *Protocols,
3204 llvm::Constant *IvarOffsets,
3205 llvm::Constant *Properties,
3206 llvm::Constant *StrongIvarBitmap,
3207 llvm::Constant *WeakIvarBitmap,
3208 bool isMeta) {
3209 // Set up the class structure
3210 // Note: Several of these are char*s when they should be ids. This is
3211 // because the runtime performs this translation on load.
3212 //
3213 // Fields marked New ABI are part of the GNUstep runtime. We emit them
3214 // anyway; the classes will still work with the GNU runtime, they will just
3215 // be ignored.
3216 llvm::StructType *ClassTy = llvm::StructType::get(
3217 PtrToInt8Ty, // isa
3218 PtrToInt8Ty, // super_class
3219 PtrToInt8Ty, // name
3220 LongTy, // version
3221 LongTy, // info
3222 LongTy, // instance_size
3223 IVars->getType(), // ivars
3224 Methods->getType(), // methods
3225 // These are all filled in by the runtime, so we pretend
3226 PtrTy, // dtable
3227 PtrTy, // subclass_list
3228 PtrTy, // sibling_class
3229 PtrTy, // protocols
3230 PtrTy, // gc_object_type
3231 // New ABI:
3232 LongTy, // abi_version
3233 IvarOffsets->getType(), // ivar_offsets
3234 Properties->getType(), // properties
3235 IntPtrTy, // strong_pointers
3236 IntPtrTy // weak_pointers
3237 );
3238
3239 ConstantInitBuilder Builder(CGM);
3240 auto Elements = Builder.beginStruct(ClassTy);
3241
3242 // Fill in the structure
3243
3244 // isa
3245 Elements.add(MetaClass);
3246 // super_class
3247 Elements.add(SuperClass);
3248 // name
3249 Elements.add(MakeConstantString(Name, ".class_name"));
3250 // version
3251 Elements.addInt(LongTy, 0);
3252 // info
3253 Elements.addInt(LongTy, info);
3254 // instance_size
3255 if (isMeta) {
3256 const llvm::DataLayout &DL = TheModule.getDataLayout();
3257 Elements.addInt(LongTy, DL.getTypeSizeInBits(ClassTy) /
3258 CGM.getContext().getCharWidth());
3259 } else
3260 Elements.add(InstanceSize);
3261 // ivars
3262 Elements.add(IVars);
3263 // methods
3264 Elements.add(Methods);
3265 // These are all filled in by the runtime, so we pretend
3266 // dtable
3267 Elements.add(NULLPtr);
3268 // subclass_list
3269 Elements.add(NULLPtr);
3270 // sibling_class
3271 Elements.add(NULLPtr);
3272 // protocols
3273 Elements.add(Protocols);
3274 // gc_object_type
3275 Elements.add(NULLPtr);
3276 // abi_version
3277 Elements.addInt(LongTy, ClassABIVersion);
3278 // ivar_offsets
3279 Elements.add(IvarOffsets);
3280 // properties
3281 Elements.add(Properties);
3282 // strong_pointers
3283 Elements.add(StrongIvarBitmap);
3284 // weak_pointers
3285 Elements.add(WeakIvarBitmap);
3286 // Create an instance of the structure
3287 // This is now an externally visible symbol, so that we can speed up class
3288 // messages in the next ABI. We may already have some weak references to
3289 // this, so check and fix them properly.
3290 std::string ClassSym((isMeta ? "_OBJC_METACLASS_": "_OBJC_CLASS_") +
3291 std::string(Name));
3292 llvm::GlobalVariable *ClassRef = TheModule.getNamedGlobal(ClassSym);
3293 llvm::Constant *Class =
3294 Elements.finishAndCreateGlobal(ClassSym, CGM.getPointerAlign(), false,
3295 llvm::GlobalValue::ExternalLinkage);
3296 if (ClassRef) {
3297 ClassRef->replaceAllUsesWith(Class);
3298 ClassRef->removeFromParent();
3299 Class->setName(ClassSym);
3300 }
3301 return Class;
3302}
3303
3304llvm::Constant *CGObjCGNU::
3305GenerateProtocolMethodList(ArrayRef<const ObjCMethodDecl*> Methods) {
3306 // Get the method structure type.
3307 llvm::StructType *ObjCMethodDescTy =
3308 llvm::StructType::get(CGM.getLLVMContext(), { PtrToInt8Ty, PtrToInt8Ty });
3309 ASTContext &Context = CGM.getContext();
3310 ConstantInitBuilder Builder(CGM);
3311 auto MethodList = Builder.beginStruct();
3312 MethodList.addInt(IntTy, Methods.size());
3313 auto MethodArray = MethodList.beginArray(ObjCMethodDescTy);
3314 for (auto *M : Methods) {
3315 auto Method = MethodArray.beginStruct(ObjCMethodDescTy);
3316 Method.add(MakeConstantString(M->getSelector().getAsString()));
3317 Method.add(MakeConstantString(Context.getObjCEncodingForMethodDecl(M)));
3318 Method.finishAndAddTo(MethodArray);
3319 }
3320 MethodArray.finishAndAddTo(MethodList);
3321 return MethodList.finishAndCreateGlobal(".objc_method_list",
3322 CGM.getPointerAlign());
3323}
3324
3325// Create the protocol list structure used in classes, categories and so on
3326llvm::Constant *
3327CGObjCGNU::GenerateProtocolList(ArrayRef<std::string> Protocols) {
3328
3329 ConstantInitBuilder Builder(CGM);
3330 auto ProtocolList = Builder.beginStruct();
3331 ProtocolList.add(NULLPtr);
3332 ProtocolList.addInt(LongTy, Protocols.size());
3333
3334 auto Elements = ProtocolList.beginArray(PtrToInt8Ty);
3335 for (const std::string &Protocol : Protocols) {
3336 llvm::Constant *protocol = nullptr;
3337 llvm::StringMap<llvm::Constant *>::iterator value =
3338 ExistingProtocols.find(Protocol);
3339 if (value == ExistingProtocols.end()) {
3340 protocol = GenerateEmptyProtocol(Protocol);
3341 } else {
3342 protocol = value->getValue();
3343 }
3344 Elements.add(protocol);
3345 }
3346 Elements.finishAndAddTo(ProtocolList);
3347 return ProtocolList.finishAndCreateGlobal(".objc_protocol_list",
3348 CGM.getPointerAlign());
3349}
3350
3351llvm::Value *CGObjCGNU::GenerateProtocolRef(CodeGenFunction &CGF,
3352 const ObjCProtocolDecl *PD) {
3353 return GenerateProtocolRef(PD);
3354}
3355
3356llvm::Constant *CGObjCGNU::GenerateProtocolRef(const ObjCProtocolDecl *PD) {
3357 llvm::Constant *&protocol = ExistingProtocols[PD->getNameAsString()];
3358 if (!protocol)
3359 GenerateProtocol(PD);
3360 assert(protocol && "Unknown protocol");
3361 return protocol;
3362}
3363
3364llvm::Constant *
3365CGObjCGNU::GenerateEmptyProtocol(StringRef ProtocolName) {
3366 llvm::Constant *ProtocolList = GenerateProtocolList({});
3367 llvm::Constant *MethodList = GenerateProtocolMethodList({});
3368 // Protocols are objects containing lists of the methods implemented and
3369 // protocols adopted.
3370 ConstantInitBuilder Builder(CGM);
3371 auto Elements = Builder.beginStruct();
3372
3373 // The isa pointer must be set to a magic number so the runtime knows it's
3374 // the correct layout.
3375 Elements.add(llvm::ConstantExpr::getIntToPtr(
3376 llvm::ConstantInt::get(Int32Ty, ProtocolVersion), IdTy));
3377
3378 Elements.add(MakeConstantString(ProtocolName, ".objc_protocol_name"));
3379 Elements.add(ProtocolList); /* .protocol_list */
3380 Elements.add(MethodList); /* .instance_methods */
3381 Elements.add(MethodList); /* .class_methods */
3382 Elements.add(MethodList); /* .optional_instance_methods */
3383 Elements.add(MethodList); /* .optional_class_methods */
3384 Elements.add(NULLPtr); /* .properties */
3385 Elements.add(NULLPtr); /* .optional_properties */
3386 return Elements.finishAndCreateGlobal(SymbolForProtocol(ProtocolName),
3387 CGM.getPointerAlign());
3388}
3389
3390void CGObjCGNU::GenerateProtocol(const ObjCProtocolDecl *PD) {
3391 if (PD->isNonRuntimeProtocol())
3392 return;
3393
3394 std::string ProtocolName = PD->getNameAsString();
3395
3396 // Use the protocol definition, if there is one.
3397 if (const ObjCProtocolDecl *Def = PD->getDefinition())
3398 PD = Def;
3399
3400 SmallVector<std::string, 16> Protocols;
3401 for (const auto *PI : PD->protocols())
3402 Protocols.push_back(PI->getNameAsString());
3403 SmallVector<const ObjCMethodDecl*, 16> InstanceMethods;
3404 SmallVector<const ObjCMethodDecl*, 16> OptionalInstanceMethods;
3405 for (const auto *I : PD->instance_methods())
3406 if (I->isOptional())
3407 OptionalInstanceMethods.push_back(I);
3408 else
3409 InstanceMethods.push_back(I);
3410 // Collect information about class methods:
3411 SmallVector<const ObjCMethodDecl*, 16> ClassMethods;
3412 SmallVector<const ObjCMethodDecl*, 16> OptionalClassMethods;
3413 for (const auto *I : PD->class_methods())
3414 if (I->isOptional())
3415 OptionalClassMethods.push_back(I);
3416 else
3417 ClassMethods.push_back(I);
3418
3419 llvm::Constant *ProtocolList = GenerateProtocolList(Protocols);
3420 llvm::Constant *InstanceMethodList =
3421 GenerateProtocolMethodList(InstanceMethods);
3422 llvm::Constant *ClassMethodList =
3423 GenerateProtocolMethodList(ClassMethods);
3424 llvm::Constant *OptionalInstanceMethodList =
3425 GenerateProtocolMethodList(OptionalInstanceMethods);
3426 llvm::Constant *OptionalClassMethodList =
3427 GenerateProtocolMethodList(OptionalClassMethods);
3428
3429 // Property metadata: name, attributes, isSynthesized, setter name, setter
3430 // types, getter name, getter types.
3431 // The isSynthesized value is always set to 0 in a protocol. It exists to
3432 // simplify the runtime library by allowing it to use the same data
3433 // structures for protocol metadata everywhere.
3434
3435 llvm::Constant *PropertyList =
3436 GeneratePropertyList(nullptr, PD, false, false);
3437 llvm::Constant *OptionalPropertyList =
3438 GeneratePropertyList(nullptr, PD, false, true);
3439
3440 // Protocols are objects containing lists of the methods implemented and
3441 // protocols adopted.
3442 // The isa pointer must be set to a magic number so the runtime knows it's
3443 // the correct layout.
3444 ConstantInitBuilder Builder(CGM);
3445 auto Elements = Builder.beginStruct();
3446 Elements.add(
3447 llvm::ConstantExpr::getIntToPtr(
3448 llvm::ConstantInt::get(Int32Ty, ProtocolVersion), IdTy));
3449 Elements.add(MakeConstantString(ProtocolName));
3450 Elements.add(ProtocolList);
3451 Elements.add(InstanceMethodList);
3452 Elements.add(ClassMethodList);
3453 Elements.add(OptionalInstanceMethodList);
3454 Elements.add(OptionalClassMethodList);
3455 Elements.add(PropertyList);
3456 Elements.add(OptionalPropertyList);
3457 ExistingProtocols[ProtocolName] =
3458 Elements.finishAndCreateGlobal(".objc_protocol", CGM.getPointerAlign());
3459}
3460void CGObjCGNU::GenerateProtocolHolderCategory() {
3461 // Collect information about instance methods
3462
3463 ConstantInitBuilder Builder(CGM);
3464 auto Elements = Builder.beginStruct();
3465
3466 const std::string ClassName = "__ObjC_Protocol_Holder_Ugly_Hack";
3467 const std::string CategoryName = "AnotherHack";
3468 Elements.add(MakeConstantString(CategoryName));
3469 Elements.add(MakeConstantString(ClassName));
3470 // Instance method list
3471 Elements.add(GenerateMethodList(ClassName, CategoryName, {}, false));
3472 // Class method list
3473 Elements.add(GenerateMethodList(ClassName, CategoryName, {}, true));
3474
3475 // Protocol list
3476 ConstantInitBuilder ProtocolListBuilder(CGM);
3477 auto ProtocolList = ProtocolListBuilder.beginStruct();
3478 ProtocolList.add(NULLPtr);
3479 ProtocolList.addInt(LongTy, ExistingProtocols.size());
3480 auto ProtocolElements = ProtocolList.beginArray(PtrTy);
3481 for (auto iter = ExistingProtocols.begin(), endIter = ExistingProtocols.end();
3482 iter != endIter ; iter++) {
3483 ProtocolElements.add(iter->getValue());
3484 }
3485 ProtocolElements.finishAndAddTo(ProtocolList);
3486 Elements.add(ProtocolList.finishAndCreateGlobal(".objc_protocol_list",
3487 CGM.getPointerAlign()));
3488 Categories.push_back(
3489 Elements.finishAndCreateGlobal("", CGM.getPointerAlign()));
3490}
3491
3492/// Libobjc2 uses a bitfield representation where small(ish) bitfields are
3493/// stored in a 64-bit value with the low bit set to 1 and the remaining 63
3494/// bits set to their values, LSB first, while larger ones are stored in a
3495/// structure of this / form:
3496///
3497/// struct { int32_t length; int32_t values[length]; };
3498///
3499/// The values in the array are stored in host-endian format, with the least
3500/// significant bit being assumed to come first in the bitfield. Therefore, a
3501/// bitfield with the 64th bit set will be (int64_t)&{ 2, [0, 1<<31] }, while a
3502/// bitfield / with the 63rd bit set will be 1<<64.
3503llvm::Constant *CGObjCGNU::MakeBitField(ArrayRef<bool> bits) {
3504 int bitCount = bits.size();
3505 int ptrBits = CGM.getDataLayout().getPointerSizeInBits();
3506 if (bitCount < ptrBits) {
3507 uint64_t val = 1;
3508 for (int i=0 ; i<bitCount ; ++i) {
3509 if (bits[i]) val |= 1ULL<<(i+1);
3510 }
3511 return llvm::ConstantInt::get(IntPtrTy, val);
3512 }
3513 SmallVector<llvm::Constant *, 8> values;
3514 int v=0;
3515 while (v < bitCount) {
3516 int32_t word = 0;
3517 for (int i=0 ; (i<32) && (v<bitCount) ; ++i) {
3518 if (bits[v]) word |= 1<<i;
3519 v++;
3520 }
3521 values.push_back(llvm::ConstantInt::get(Int32Ty, word));
3522 }
3523
3524 ConstantInitBuilder builder(CGM);
3525 auto fields = builder.beginStruct();
3526 fields.addInt(Int32Ty, values.size());
3527 auto array = fields.beginArray();
3528 for (auto *v : values) array.add(v);
3529 array.finishAndAddTo(fields);
3530
3531 llvm::Constant *GS =
3532 fields.finishAndCreateGlobal("", CharUnits::fromQuantity(4));
3533 llvm::Constant *ptr = llvm::ConstantExpr::getPtrToInt(GS, IntPtrTy);
3534 return ptr;
3535}
3536
3537llvm::Constant *CGObjCGNU::GenerateCategoryProtocolList(const
3538 ObjCCategoryDecl *OCD) {
3539 const auto &RefPro = OCD->getReferencedProtocols();
3540 const auto RuntimeProtos =
3541 GetRuntimeProtocolList(RefPro.begin(), RefPro.end());
3542 SmallVector<std::string, 16> Protocols;
3543 for (const auto *PD : RuntimeProtos)
3544 Protocols.push_back(PD->getNameAsString());
3545 return GenerateProtocolList(Protocols);
3546}
3547
3548void CGObjCGNU::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
3549 const ObjCInterfaceDecl *Class = OCD->getClassInterface();
3550 std::string ClassName = Class->getNameAsString();
3551 std::string CategoryName = OCD->getNameAsString();
3552
3553 // Collect the names of referenced protocols
3554 const ObjCCategoryDecl *CatDecl = OCD->getCategoryDecl();
3555
3556 ConstantInitBuilder Builder(CGM);
3557 auto Elements = Builder.beginStruct();
3558 Elements.add(MakeConstantString(CategoryName));
3559 Elements.add(MakeConstantString(ClassName));
3560 // Instance method list
3561 SmallVector<ObjCMethodDecl*, 16> InstanceMethods;
3562 InstanceMethods.insert(InstanceMethods.begin(), OCD->instmeth_begin(),
3563 OCD->instmeth_end());
3564 Elements.add(
3565 GenerateMethodList(ClassName, CategoryName, InstanceMethods, false));
3566
3567 // Class method list
3568
3569 SmallVector<ObjCMethodDecl*, 16> ClassMethods;
3570 ClassMethods.insert(ClassMethods.begin(), OCD->classmeth_begin(),
3571 OCD->classmeth_end());
3572 Elements.add(GenerateMethodList(ClassName, CategoryName, ClassMethods, true));
3573
3574 // Protocol list
3575 Elements.add(GenerateCategoryProtocolList(CatDecl));
3576 if (isRuntime(ObjCRuntime::GNUstep, 2)) {
3577 const ObjCCategoryDecl *Category =
3578 Class->FindCategoryDeclaration(OCD->getIdentifier());
3579 if (Category) {
3580 // Instance properties
3581 Elements.add(GeneratePropertyList(OCD, Category, false));
3582 // Class properties
3583 Elements.add(GeneratePropertyList(OCD, Category, true));
3584 } else {
3585 Elements.addNullPointer(PtrTy);
3586 Elements.addNullPointer(PtrTy);
3587 }
3588 }
3589
3590 Categories.push_back(Elements.finishAndCreateGlobal(
3591 std::string(".objc_category_") + ClassName + CategoryName,
3592 CGM.getPointerAlign()));
3593}
3594
3595llvm::Constant *CGObjCGNU::GeneratePropertyList(const Decl *Container,
3596 const ObjCContainerDecl *OCD,
3597 bool isClassProperty,
3598 bool protocolOptionalProperties) {
3599
3600 SmallVector<const ObjCPropertyDecl *, 16> Properties;
3601 llvm::SmallPtrSet<const IdentifierInfo*, 16> PropertySet;
3602 bool isProtocol = isa<ObjCProtocolDecl>(OCD);
3603 ASTContext &Context = CGM.getContext();
3604
3605 std::function<void(const ObjCProtocolDecl *Proto)> collectProtocolProperties
3606 = [&](const ObjCProtocolDecl *Proto) {
3607 for (const auto *P : Proto->protocols())
3608 collectProtocolProperties(P);
3609 for (const auto *PD : Proto->properties()) {
3610 if (isClassProperty != PD->isClassProperty())
3611 continue;
3612 // Skip any properties that are declared in protocols that this class
3613 // conforms to but are not actually implemented by this class.
3614 if (!isProtocol && !Context.getObjCPropertyImplDeclForPropertyDecl(PD, Container))
3615 continue;
3616 if (!PropertySet.insert(PD->getIdentifier()).second)
3617 continue;
3618 Properties.push_back(PD);
3619 }
3620 };
3621
3622 if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
3623 for (const ObjCCategoryDecl *ClassExt : OID->known_extensions())
3624 for (auto *PD : ClassExt->properties()) {
3625 if (isClassProperty != PD->isClassProperty())
3626 continue;
3627 PropertySet.insert(PD->getIdentifier());
3628 Properties.push_back(PD);
3629 }
3630
3631 for (const auto *PD : OCD->properties()) {
3632 if (isClassProperty != PD->isClassProperty())
3633 continue;
3634 // If we're generating a list for a protocol, skip optional / required ones
3635 // when generating the other list.
3636 if (isProtocol && (protocolOptionalProperties != PD->isOptional()))
3637 continue;
3638 // Don't emit duplicate metadata for properties that were already in a
3639 // class extension.
3640 if (!PropertySet.insert(PD->getIdentifier()).second)
3641 continue;
3642
3643 Properties.push_back(PD);
3644 }
3645
3646 if (const ObjCInterfaceDecl *OID = dyn_cast<ObjCInterfaceDecl>(OCD))
3647 for (const auto *P : OID->all_referenced_protocols())
3648 collectProtocolProperties(P);
3649 else if (const ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(OCD))
3650 for (const auto *P : CD->protocols())
3651 collectProtocolProperties(P);
3652
3653 auto numProperties = Properties.size();
3654
3655 if (numProperties == 0)
3656 return NULLPtr;
3657
3658 ConstantInitBuilder builder(CGM);
3659 auto propertyList = builder.beginStruct();
3660 auto properties = PushPropertyListHeader(propertyList, numProperties);
3661
3662 // Add all of the property methods need adding to the method list and to the
3663 // property metadata list.
3664 for (auto *property : Properties) {
3665 bool isSynthesized = false;
3666 bool isDynamic = false;
3667 if (!isProtocol) {
3668 auto *propertyImpl = Context.getObjCPropertyImplDeclForPropertyDecl(property, Container);
3669 if (propertyImpl) {
3670 isSynthesized = (propertyImpl->getPropertyImplementation() ==
3672 isDynamic = (propertyImpl->getPropertyImplementation() ==
3674 }
3675 }
3676 PushProperty(properties, property, Container, isSynthesized, isDynamic);
3677 }
3678 properties.finishAndAddTo(propertyList);
3679
3680 return propertyList.finishAndCreateGlobal(".objc_property_list",
3681 CGM.getPointerAlign());
3682}
3683
3684void CGObjCGNU::RegisterAlias(const ObjCCompatibleAliasDecl *OAD) {
3685 // Get the class declaration for which the alias is specified.
3686 ObjCInterfaceDecl *ClassDecl =
3687 const_cast<ObjCInterfaceDecl *>(OAD->getClassInterface());
3688 ClassAliases.emplace_back(ClassDecl->getNameAsString(),
3689 OAD->getNameAsString());
3690}
3691
3692void CGObjCGNU::GenerateClass(const ObjCImplementationDecl *OID) {
3693 ASTContext &Context = CGM.getContext();
3694
3695 // Get the superclass name.
3696 const ObjCInterfaceDecl * SuperClassDecl =
3698 std::string SuperClassName;
3699 if (SuperClassDecl) {
3700 SuperClassName = SuperClassDecl->getNameAsString();
3701 EmitClassRef(SuperClassName);
3702 }
3703
3704 // Get the class name
3705 ObjCInterfaceDecl *ClassDecl =
3706 const_cast<ObjCInterfaceDecl *>(OID->getClassInterface());
3707 std::string ClassName = ClassDecl->getNameAsString();
3708
3709 // Emit the symbol that is used to generate linker errors if this class is
3710 // referenced in other modules but not declared.
3711 std::string classSymbolName = "__objc_class_name_" + ClassName;
3712 if (auto *symbol = TheModule.getGlobalVariable(classSymbolName)) {
3713 symbol->setInitializer(llvm::ConstantInt::get(LongTy, 0));
3714 } else {
3715 new llvm::GlobalVariable(TheModule, LongTy, false,
3716 llvm::GlobalValue::ExternalLinkage,
3717 llvm::ConstantInt::get(LongTy, 0),
3718 classSymbolName);
3719 }
3720
3721 // Get the size of instances.
3722 int instanceSize = Context.getASTObjCInterfaceLayout(OID->getClassInterface())
3723 .getSize()
3724 .getQuantity();
3725
3726 // Collect information about instance variables.
3727 SmallVector<llvm::Constant*, 16> IvarNames;
3728 SmallVector<llvm::Constant*, 16> IvarTypes;
3729 SmallVector<llvm::Constant*, 16> IvarOffsets;
3730 SmallVector<llvm::Constant*, 16> IvarAligns;
3731 SmallVector<Qualifiers::ObjCLifetime, 16> IvarOwnership;
3732
3733 ConstantInitBuilder IvarOffsetBuilder(CGM);
3734 auto IvarOffsetValues = IvarOffsetBuilder.beginArray(PtrToIntTy);
3735 SmallVector<bool, 16> WeakIvars;
3736 SmallVector<bool, 16> StrongIvars;
3737
3738 int superInstanceSize = !SuperClassDecl ? 0 :
3739 Context.getASTObjCInterfaceLayout(SuperClassDecl).getSize().getQuantity();
3740 // For non-fragile ivars, set the instance size to 0 - {the size of just this
3741 // class}. The runtime will then set this to the correct value on load.
3742 if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
3743 instanceSize = 0 - (instanceSize - superInstanceSize);
3744 }
3745
3746 for (const ObjCIvarDecl *IVD = ClassDecl->all_declared_ivar_begin(); IVD;
3747 IVD = IVD->getNextIvar()) {
3748 // Store the name
3749 IvarNames.push_back(MakeConstantString(IVD->getNameAsString()));
3750 // Get the type encoding for this ivar
3751 std::string TypeStr;
3752 Context.getObjCEncodingForType(IVD->getType(), TypeStr, IVD);
3753 IvarTypes.push_back(MakeConstantString(TypeStr));
3754 IvarAligns.push_back(llvm::ConstantInt::get(IntTy,
3755 Context.getTypeSize(IVD->getType())));
3756 // Get the offset
3757 uint64_t BaseOffset = ComputeIvarBaseOffset(CGM, OID, IVD);
3758 uint64_t Offset = BaseOffset;
3759 if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
3760 Offset = BaseOffset - superInstanceSize;
3761 }
3762 llvm::Constant *OffsetValue = llvm::ConstantInt::get(IntTy, Offset);
3763 // Create the direct offset value
3764 std::string OffsetName = "__objc_ivar_offset_value_" + ClassName +"." +
3765 IVD->getNameAsString();
3766
3767 llvm::GlobalVariable *OffsetVar = TheModule.getGlobalVariable(OffsetName);
3768 if (OffsetVar) {
3769 OffsetVar->setInitializer(OffsetValue);
3770 // If this is the real definition, change its linkage type so that
3771 // different modules will use this one, rather than their private
3772 // copy.
3773 OffsetVar->setLinkage(llvm::GlobalValue::ExternalLinkage);
3774 } else
3775 OffsetVar = new llvm::GlobalVariable(TheModule, Int32Ty,
3776 false, llvm::GlobalValue::ExternalLinkage,
3777 OffsetValue, OffsetName);
3778 IvarOffsets.push_back(OffsetValue);
3779 IvarOffsetValues.add(OffsetVar);
3780 Qualifiers::ObjCLifetime lt = IVD->getType().getQualifiers().getObjCLifetime();
3781 IvarOwnership.push_back(lt);
3782 switch (lt) {
3784 StrongIvars.push_back(true);
3785 WeakIvars.push_back(false);
3786 break;
3788 StrongIvars.push_back(false);
3789 WeakIvars.push_back(true);
3790 break;
3791 default:
3792 StrongIvars.push_back(false);
3793 WeakIvars.push_back(false);
3794 }
3795 }
3796 llvm::Constant *StrongIvarBitmap = MakeBitField(StrongIvars);
3797 llvm::Constant *WeakIvarBitmap = MakeBitField(WeakIvars);
3798 llvm::GlobalVariable *IvarOffsetArray =
3799 IvarOffsetValues.finishAndCreateGlobal(".ivar.offsets",
3800 CGM.getPointerAlign());
3801
3802 // Collect information about instance methods
3803 SmallVector<const ObjCMethodDecl*, 16> InstanceMethods;
3804 InstanceMethods.insert(InstanceMethods.begin(), OID->instmeth_begin(),
3805 OID->instmeth_end());
3806
3807 SmallVector<const ObjCMethodDecl*, 16> ClassMethods;
3808 ClassMethods.insert(ClassMethods.begin(), OID->classmeth_begin(),
3809 OID->classmeth_end());
3810
3811 llvm::Constant *Properties = GeneratePropertyList(OID, ClassDecl);
3812
3813 // Collect the names of referenced protocols
3814 auto RefProtocols = ClassDecl->protocols();
3815 auto RuntimeProtocols =
3816 GetRuntimeProtocolList(RefProtocols.begin(), RefProtocols.end());
3817 SmallVector<std::string, 16> Protocols;
3818 for (const auto *I : RuntimeProtocols)
3819 Protocols.push_back(I->getNameAsString());
3820
3821 // Get the superclass pointer.
3822 llvm::Constant *SuperClass;
3823 if (!SuperClassName.empty()) {
3824 SuperClass = MakeConstantString(SuperClassName, ".super_class_name");
3825 } else {
3826 SuperClass = llvm::ConstantPointerNull::get(PtrToInt8Ty);
3827 }
3828 // Generate the method and instance variable lists
3829 llvm::Constant *MethodList = GenerateMethodList(ClassName, "",
3830 InstanceMethods, false);
3831 llvm::Constant *ClassMethodList = GenerateMethodList(ClassName, "",
3832 ClassMethods, true);
3833 llvm::Constant *IvarList = GenerateIvarList(IvarNames, IvarTypes,
3834 IvarOffsets, IvarAligns, IvarOwnership);
3835 // Irrespective of whether we are compiling for a fragile or non-fragile ABI,
3836 // we emit a symbol containing the offset for each ivar in the class. This
3837 // allows code compiled for the non-Fragile ABI to inherit from code compiled
3838 // for the legacy ABI, without causing problems. The converse is also
3839 // possible, but causes all ivar accesses to be fragile.
3840
3841 // Offset pointer for getting at the correct field in the ivar list when
3842 // setting up the alias. These are: The base address for the global, the
3843 // ivar array (second field), the ivar in this list (set for each ivar), and
3844 // the offset (third field in ivar structure)
3845 llvm::Type *IndexTy = Int32Ty;
3846 llvm::Constant *offsetPointerIndexes[] = {Zeros[0],
3847 llvm::ConstantInt::get(IndexTy, ClassABIVersion > 1 ? 2 : 1), nullptr,
3848 llvm::ConstantInt::get(IndexTy, ClassABIVersion > 1 ? 3 : 2) };
3849
3850 unsigned ivarIndex = 0;
3851 for (const ObjCIvarDecl *IVD = ClassDecl->all_declared_ivar_begin(); IVD;
3852 IVD = IVD->getNextIvar()) {
3853 const std::string Name = GetIVarOffsetVariableName(ClassDecl, IVD);
3854 offsetPointerIndexes[2] = llvm::ConstantInt::get(IndexTy, ivarIndex);
3855 // Get the correct ivar field
3856 llvm::Constant *offsetValue = llvm::ConstantExpr::getGetElementPtr(
3857 cast<llvm::GlobalVariable>(IvarList)->getValueType(), IvarList,
3858 offsetPointerIndexes);
3859 // Get the existing variable, if one exists.
3860 llvm::GlobalVariable *offset = TheModule.getNamedGlobal(Name);
3861 if (offset) {
3862 offset->setInitializer(offsetValue);
3863 // If this is the real definition, change its linkage type so that
3864 // different modules will use this one, rather than their private
3865 // copy.
3866 offset->setLinkage(llvm::GlobalValue::ExternalLinkage);
3867 } else
3868 // Add a new alias if there isn't one already.
3869 new llvm::GlobalVariable(TheModule, offsetValue->getType(),
3870 false, llvm::GlobalValue::ExternalLinkage, offsetValue, Name);
3871 ++ivarIndex;
3872 }
3873 llvm::Constant *ZeroPtr = llvm::ConstantInt::get(IntPtrTy, 0);
3874
3875 //Generate metaclass for class methods
3876 llvm::Constant *MetaClassStruct = GenerateClassStructure(
3877 NULLPtr, NULLPtr, 0x12L, ClassName.c_str(), nullptr, Zeros[0],
3878 NULLPtr, ClassMethodList, NULLPtr, NULLPtr,
3879 GeneratePropertyList(OID, ClassDecl, true), ZeroPtr, ZeroPtr, true);
3880 CGM.setGVProperties(cast<llvm::GlobalValue>(MetaClassStruct),
3881 OID->getClassInterface());
3882
3883 // Generate the class structure
3884 llvm::Constant *ClassStruct = GenerateClassStructure(
3885 MetaClassStruct, SuperClass, 0x11L, ClassName.c_str(), nullptr,
3886 llvm::ConstantInt::get(LongTy, instanceSize), IvarList, MethodList,
3887 GenerateProtocolList(Protocols), IvarOffsetArray, Properties,
3888 StrongIvarBitmap, WeakIvarBitmap);
3890 OID->getClassInterface());
3891
3892 // Resolve the class aliases, if they exist.
3893 if (ClassPtrAlias) {
3894 ClassPtrAlias->replaceAllUsesWith(ClassStruct);
3895 ClassPtrAlias->eraseFromParent();
3896 ClassPtrAlias = nullptr;
3897 }
3898 if (MetaClassPtrAlias) {
3899 MetaClassPtrAlias->replaceAllUsesWith(MetaClassStruct);
3900 MetaClassPtrAlias->eraseFromParent();
3901 MetaClassPtrAlias = nullptr;
3902 }
3903
3904 // Add class structure to list to be added to the symtab later
3905 Classes.push_back(ClassStruct);
3906}
3907
3908llvm::Function *CGObjCGNU::ModuleInitFunction() {
3909 // Only emit an ObjC load function if no Objective-C stuff has been called
3910 if (Classes.empty() && Categories.empty() && ConstantStrings.empty() &&
3911 ExistingProtocols.empty() && SelectorTable.empty())
3912 return nullptr;
3913
3914 // Add all referenced protocols to a category.
3915 GenerateProtocolHolderCategory();
3916
3917 llvm::StructType *selStructTy = dyn_cast<llvm::StructType>(SelectorElemTy);
3918 if (!selStructTy) {
3919 selStructTy = llvm::StructType::get(CGM.getLLVMContext(),
3920 { PtrToInt8Ty, PtrToInt8Ty });
3921 }
3922
3923 // Generate statics list:
3924 llvm::Constant *statics = NULLPtr;
3925 if (!ConstantStrings.empty()) {
3926 llvm::GlobalVariable *fileStatics = [&] {
3927 ConstantInitBuilder builder(CGM);
3928 auto staticsStruct = builder.beginStruct();
3929
3930 StringRef stringClass = CGM.getLangOpts().ObjCConstantStringClass;
3931 if (stringClass.empty()) stringClass = "NXConstantString";
3932 staticsStruct.add(MakeConstantString(stringClass,
3933 ".objc_static_class_name"));
3934
3935 auto array = staticsStruct.beginArray();
3936 array.addAll(ConstantStrings);
3937 array.add(NULLPtr);
3938 array.finishAndAddTo(staticsStruct);
3939
3940 return staticsStruct.finishAndCreateGlobal(".objc_statics",
3941 CGM.getPointerAlign());
3942 }();
3943
3944 ConstantInitBuilder builder(CGM);
3945 auto allStaticsArray = builder.beginArray(fileStatics->getType());
3946 allStaticsArray.add(fileStatics);
3947 allStaticsArray.addNullPointer(fileStatics->getType());
3948
3949 statics = allStaticsArray.finishAndCreateGlobal(".objc_statics_ptr",
3950 CGM.getPointerAlign());
3951 }
3952
3953 // Array of classes, categories, and constant objects.
3954
3955 SmallVector<llvm::GlobalAlias*, 16> selectorAliases;
3956 unsigned selectorCount;
3957
3958 // Pointer to an array of selectors used in this module.
3959 llvm::GlobalVariable *selectorList = [&] {
3960 ConstantInitBuilder builder(CGM);
3961 auto selectors = builder.beginArray(selStructTy);
3962 auto &table = SelectorTable; // MSVC workaround
3963 std::vector<Selector> allSelectors;
3964 for (auto &entry : table)
3965 allSelectors.push_back(entry.first);
3966 llvm::sort(allSelectors);
3967
3968 for (auto &untypedSel : allSelectors) {
3969 std::string selNameStr = untypedSel.getAsString();
3970 llvm::Constant *selName = ExportUniqueString(selNameStr, ".objc_sel_name");
3971
3972 for (TypedSelector &sel : table[untypedSel]) {
3973 llvm::Constant *selectorTypeEncoding = NULLPtr;
3974 if (!sel.first.empty())
3975 selectorTypeEncoding =
3976 MakeConstantString(sel.first, ".objc_sel_types");
3977
3978 auto selStruct = selectors.beginStruct(selStructTy);
3979 selStruct.add(selName);
3980 selStruct.add(selectorTypeEncoding);
3981 selStruct.finishAndAddTo(selectors);
3982
3983 // Store the selector alias for later replacement
3984 selectorAliases.push_back(sel.second);
3985 }
3986 }
3987
3988 // Remember the number of entries in the selector table.
3989 selectorCount = selectors.size();
3990
3991 // NULL-terminate the selector list. This should not actually be required,
3992 // because the selector list has a length field. Unfortunately, the GCC
3993 // runtime decides to ignore the length field and expects a NULL terminator,
3994 // and GCC cooperates with this by always setting the length to 0.
3995 auto selStruct = selectors.beginStruct(selStructTy);
3996 selStruct.add(NULLPtr);
3997 selStruct.add(NULLPtr);
3998 selStruct.finishAndAddTo(selectors);
3999
4000 return selectors.finishAndCreateGlobal(".objc_selector_list",
4001 CGM.getPointerAlign());
4002 }();
4003
4004 // Now that all of the static selectors exist, create pointers to them.
4005 for (unsigned i = 0; i < selectorCount; ++i) {
4006 llvm::Constant *idxs[] = {
4007 Zeros[0],
4008 llvm::ConstantInt::get(Int32Ty, i)
4009 };
4010 // FIXME: We're generating redundant loads and stores here!
4011 llvm::Constant *selPtr = llvm::ConstantExpr::getGetElementPtr(
4012 selectorList->getValueType(), selectorList, idxs);
4013 selectorAliases[i]->replaceAllUsesWith(selPtr);
4014 selectorAliases[i]->eraseFromParent();
4015 }
4016
4017 llvm::GlobalVariable *symtab = [&] {
4018 ConstantInitBuilder builder(CGM);
4019 auto symtab = builder.beginStruct();
4020
4021 // Number of static selectors
4022 symtab.addInt(LongTy, selectorCount);
4023
4024 symtab.add(selectorList);
4025
4026 // Number of classes defined.
4027 symtab.addInt(CGM.Int16Ty, Classes.size());
4028 // Number of categories defined
4029 symtab.addInt(CGM.Int16Ty, Categories.size());
4030
4031 // Create an array of classes, then categories, then static object instances
4032 auto classList = symtab.beginArray(PtrToInt8Ty);
4033 classList.addAll(Classes);
4034 classList.addAll(Categories);
4035 // NULL-terminated list of static object instances (mainly constant strings)
4036 classList.add(statics);
4037 classList.add(NULLPtr);
4038 classList.finishAndAddTo(symtab);
4039
4040 // Construct the symbol table.
4041 return symtab.finishAndCreateGlobal("", CGM.getPointerAlign());
4042 }();
4043
4044 // The symbol table is contained in a module which has some version-checking
4045 // constants
4046 llvm::Constant *module = [&] {
4047 llvm::Type *moduleEltTys[] = {
4048 LongTy, LongTy, PtrToInt8Ty, symtab->getType(), IntTy
4049 };
4050 llvm::StructType *moduleTy = llvm::StructType::get(
4051 CGM.getLLVMContext(),
4052 ArrayRef(moduleEltTys).drop_back(unsigned(RuntimeVersion < 10)));
4053
4054 ConstantInitBuilder builder(CGM);
4055 auto module = builder.beginStruct(moduleTy);
4056 // Runtime version, used for ABI compatibility checking.
4057 module.addInt(LongTy, RuntimeVersion);
4058 // sizeof(ModuleTy)
4059 module.addInt(LongTy, CGM.getDataLayout().getTypeStoreSize(moduleTy));
4060
4061 // The path to the source file where this module was declared
4062 SourceManager &SM = CGM.getContext().getSourceManager();
4063 OptionalFileEntryRef mainFile = SM.getFileEntryRefForID(SM.getMainFileID());
4064 std::string path =
4065 (mainFile->getDir().getName() + "/" + mainFile->getName()).str();
4066 module.add(MakeConstantString(path, ".objc_source_file_name"));
4067 module.add(symtab);
4068
4069 if (RuntimeVersion >= 10) {
4070 switch (CGM.getLangOpts().getGC()) {
4071 case LangOptions::GCOnly:
4072 module.addInt(IntTy, 2);
4073 break;
4074 case LangOptions::NonGC:
4075 if (CGM.getLangOpts().ObjCAutoRefCount)
4076 module.addInt(IntTy, 1);
4077 else
4078 module.addInt(IntTy, 0);
4079 break;
4080 case LangOptions::HybridGC:
4081 module.addInt(IntTy, 1);
4082 break;
4083 }
4084 }
4085
4086 return module.finishAndCreateGlobal("", CGM.getPointerAlign());
4087 }();
4088
4089 // Create the load function calling the runtime entry point with the module
4090 // structure
4091 llvm::Function * LoadFunction = llvm::Function::Create(
4092 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), false),
4093 llvm::GlobalValue::InternalLinkage, ".objc_load_function",
4094 &TheModule);
4095 llvm::BasicBlock *EntryBB =
4096 llvm::BasicBlock::Create(VMContext, "entry", LoadFunction);
4097 CGBuilderTy Builder(CGM, VMContext);
4098 Builder.SetInsertPoint(EntryBB);
4099
4100 llvm::FunctionType *FT =
4101 llvm::FunctionType::get(Builder.getVoidTy(), module->getType(), true);
4102 llvm::FunctionCallee Register =
4103 CGM.CreateRuntimeFunction(FT, "__objc_exec_class");
4104 Builder.CreateCall(Register, module);
4105
4106 if (!ClassAliases.empty()) {
4107 llvm::Type *ArgTypes[2] = {PtrTy, PtrToInt8Ty};
4108 llvm::FunctionType *RegisterAliasTy =
4109 llvm::FunctionType::get(Builder.getVoidTy(),
4110 ArgTypes, false);
4111 llvm::Function *RegisterAlias = llvm::Function::Create(
4112 RegisterAliasTy,
4113 llvm::GlobalValue::ExternalWeakLinkage, "class_registerAlias_np",
4114 &TheModule);
4115 llvm::BasicBlock *AliasBB =
4116 llvm::BasicBlock::Create(VMContext, "alias", LoadFunction);
4117 llvm::BasicBlock *NoAliasBB =
4118 llvm::BasicBlock::Create(VMContext, "no_alias", LoadFunction);
4119
4120 // Branch based on whether the runtime provided class_registerAlias_np()
4121 llvm::Value *HasRegisterAlias = Builder.CreateICmpNE(RegisterAlias,
4122 llvm::Constant::getNullValue(RegisterAlias->getType()));
4123 Builder.CreateCondBr(HasRegisterAlias, AliasBB, NoAliasBB);
4124
4125 // The true branch (has alias registration function):
4126 Builder.SetInsertPoint(AliasBB);
4127 // Emit alias registration calls:
4128 for (std::vector<ClassAliasPair>::iterator iter = ClassAliases.begin();
4129 iter != ClassAliases.end(); ++iter) {
4130 llvm::Constant *TheClass =
4131 TheModule.getGlobalVariable("_OBJC_CLASS_" + iter->first, true);
4132 if (TheClass) {
4133 Builder.CreateCall(RegisterAlias,
4134 {TheClass, MakeConstantString(iter->second)});
4135 }
4136 }
4137 // Jump to end:
4138 Builder.CreateBr(NoAliasBB);
4139
4140 // Missing alias registration function, just return from the function:
4141 Builder.SetInsertPoint(NoAliasBB);
4142 }
4143 Builder.CreateRetVoid();
4144
4145 return LoadFunction;
4146}
4147
4148llvm::Function *CGObjCGNU::GenerateMethod(const ObjCMethodDecl *OMD,
4149 const ObjCContainerDecl *CD) {
4150 CodeGenTypes &Types = CGM.getTypes();
4151 llvm::FunctionType *MethodTy =
4153
4154 bool isDirect = OMD->isDirectMethod();
4155 std::string FunctionName =
4156 getSymbolNameForMethod(OMD, /*include category*/ !isDirect);
4157
4158 if (!isDirect)
4159 return llvm::Function::Create(MethodTy,
4160 llvm::GlobalVariable::InternalLinkage,
4161 FunctionName, &TheModule);
4162
4163 auto *COMD = OMD->getCanonicalDecl();
4164 auto I = DirectMethodDefinitions.find(COMD);
4165 llvm::Function *OldFn = nullptr, *Fn = nullptr;
4166
4167 if (I == DirectMethodDefinitions.end()) {
4168 auto *F =
4169 llvm::Function::Create(MethodTy, llvm::GlobalVariable::ExternalLinkage,
4170 FunctionName, &TheModule);
4171 DirectMethodDefinitions.insert(std::make_pair(COMD, F));
4172 return F;
4173 }
4174
4175 // Objective-C allows for the declaration and implementation types
4176 // to differ slightly.
4177 //
4178 // If we're being asked for the Function associated for a method
4179 // implementation, a previous value might have been cached
4180 // based on the type of the canonical declaration.
4181 //
4182 // If these do not match, then we'll replace this function with
4183 // a new one that has the proper type below.
4184 if (!OMD->getBody() || COMD->getReturnType() == OMD->getReturnType())
4185 return I->second;
4186
4187 OldFn = I->second;
4188 Fn = llvm::Function::Create(MethodTy, llvm::GlobalValue::ExternalLinkage, "",
4189 &CGM.getModule());
4190 Fn->takeName(OldFn);
4191 OldFn->replaceAllUsesWith(Fn);
4192 OldFn->eraseFromParent();
4193
4194 // Replace the cached function in the map.
4195 I->second = Fn;
4196 return Fn;
4197}
4198
4199void CGObjCGNU::GenerateDirectMethodPrologue(CodeGenFunction &CGF,
4200 llvm::Function *Fn,
4201 const ObjCMethodDecl *OMD,
4202 const ObjCContainerDecl *CD) {
4203 // GNU runtime doesn't support direct calls at this time
4204}
4205
4206llvm::FunctionCallee CGObjCGNU::GetPropertyGetFunction() {
4207 return GetPropertyFn;
4208}
4209
4210llvm::FunctionCallee CGObjCGNU::GetPropertySetFunction() {
4211 return SetPropertyFn;
4212}
4213
4214llvm::FunctionCallee CGObjCGNU::GetOptimizedPropertySetFunction(bool atomic,
4215 bool copy) {
4216 return nullptr;
4217}
4218
4219llvm::FunctionCallee CGObjCGNU::GetGetStructFunction() {
4220 return GetStructPropertyFn;
4221}
4222
4223llvm::FunctionCallee CGObjCGNU::GetSetStructFunction() {
4224 return SetStructPropertyFn;
4225}
4226
4227llvm::FunctionCallee CGObjCGNU::GetCppAtomicObjectGetFunction() {
4228 return nullptr;
4229}
4230
4231llvm::FunctionCallee CGObjCGNU::GetCppAtomicObjectSetFunction() {
4232 return nullptr;
4233}
4234
4235llvm::FunctionCallee CGObjCGNU::EnumerationMutationFunction() {
4236 return EnumerationMutationFn;
4237}
4238
4239void CGObjCGNU::EmitSynchronizedStmt(CodeGenFunction &CGF,
4240 const ObjCAtSynchronizedStmt &S) {
4241 EmitAtSynchronizedStmt(CGF, S, SyncEnterFn, SyncExitFn);
4242}
4243
4244
4245void CGObjCGNU::EmitTryStmt(CodeGenFunction &CGF,
4246 const ObjCAtTryStmt &S) {
4247 // Unlike the Apple non-fragile runtimes, which also uses
4248 // unwind-based zero cost exceptions, the GNU Objective C runtime's
4249 // EH support isn't a veneer over C++ EH. Instead, exception
4250 // objects are created by objc_exception_throw and destroyed by
4251 // the personality function; this avoids the need for bracketing
4252 // catch handlers with calls to __blah_begin_catch/__blah_end_catch
4253 // (or even _Unwind_DeleteException), but probably doesn't
4254 // interoperate very well with foreign exceptions.
4255 //
4256 // In Objective-C++ mode, we actually emit something equivalent to the C++
4257 // exception handler.
4258 EmitTryCatchStmt(CGF, S, EnterCatchFn, ExitCatchFn, ExceptionReThrowFn);
4259}
4260
4261void CGObjCGNU::EmitThrowStmt(CodeGenFunction &CGF,
4262 const ObjCAtThrowStmt &S,
4263 bool ClearInsertionPoint) {
4264 llvm::Value *ExceptionAsObject;
4265 bool isRethrow = false;
4266
4267 if (const Expr *ThrowExpr = S.getThrowExpr()) {
4268 llvm::Value *Exception = CGF.EmitObjCThrowOperand(ThrowExpr);
4269 ExceptionAsObject = Exception;
4270 } else {
4271 assert((!CGF.ObjCEHValueStack.empty() && CGF.ObjCEHValueStack.back()) &&
4272 "Unexpected rethrow outside @catch block.");
4273 ExceptionAsObject = CGF.ObjCEHValueStack.back();
4274 isRethrow = true;
4275 }
4276 if (isRethrow && (usesSEHExceptions || usesCxxExceptions)) {
4277 // For SEH, ExceptionAsObject may be undef, because the catch handler is
4278 // not passed it for catchalls and so it is not visible to the catch
4279 // funclet. The real thrown object will still be live on the stack at this
4280 // point and will be rethrown. If we are explicitly rethrowing the object
4281 // that was passed into the `@catch` block, then this code path is not
4282 // reached and we will instead call `objc_exception_throw` with an explicit
4283 // argument.
4284 llvm::CallBase *Throw = CGF.EmitRuntimeCallOrInvoke(ExceptionReThrowFn);
4285 Throw->setDoesNotReturn();
4286 } else {
4287 ExceptionAsObject = CGF.Builder.CreateBitCast(ExceptionAsObject, IdTy);
4288 llvm::CallBase *Throw =
4289 CGF.EmitRuntimeCallOrInvoke(ExceptionThrowFn, ExceptionAsObject);
4290 Throw->setDoesNotReturn();
4291 }
4292 CGF.Builder.CreateUnreachable();
4293 if (ClearInsertionPoint)
4294 CGF.Builder.ClearInsertionPoint();
4295}
4296
4297llvm::Value * CGObjCGNU::EmitObjCWeakRead(CodeGenFunction &CGF,
4298 Address AddrWeakObj) {
4299 CGBuilderTy &B = CGF.Builder;
4300 return B.CreateCall(
4301 WeakReadFn, EnforceType(B, AddrWeakObj.emitRawPointer(CGF), PtrToIdTy));
4302}
4303
4304void CGObjCGNU::EmitObjCWeakAssign(CodeGenFunction &CGF,
4305 llvm::Value *src, Address dst) {
4306 CGBuilderTy &B = CGF.Builder;
4307 src = EnforceType(B, src, IdTy);
4308 llvm::Value *dstVal = EnforceType(B, dst.emitRawPointer(CGF), PtrToIdTy);
4309 B.CreateCall(WeakAssignFn, {src, dstVal});
4310}
4311
4312void CGObjCGNU::EmitObjCGlobalAssign(CodeGenFunction &CGF,
4313 llvm::Value *src, Address dst,
4314 bool threadlocal) {
4315 CGBuilderTy &B = CGF.Builder;
4316 src = EnforceType(B, src, IdTy);
4317 llvm::Value *dstVal = EnforceType(B, dst.emitRawPointer(CGF), PtrToIdTy);
4318 // FIXME. Add threadloca assign API
4319 assert(!threadlocal && "EmitObjCGlobalAssign - Threal Local API NYI");
4320 B.CreateCall(GlobalAssignFn, {src, dstVal});
4321}
4322
4323void CGObjCGNU::EmitObjCIvarAssign(CodeGenFunction &CGF,
4324 llvm::Value *src, Address dst,
4325 llvm::Value *ivarOffset) {
4326 CGBuilderTy &B = CGF.Builder;
4327 src = EnforceType(B, src, IdTy);
4328 llvm::Value *dstVal = EnforceType(B, dst.emitRawPointer(CGF), IdTy);
4329 B.CreateCall(IvarAssignFn, {src, dstVal, ivarOffset});
4330}
4331
4332void CGObjCGNU::EmitObjCStrongCastAssign(CodeGenFunction &CGF,
4333 llvm::Value *src, Address dst) {
4334 CGBuilderTy &B = CGF.Builder;
4335 src = EnforceType(B, src, IdTy);
4336 llvm::Value *dstVal = EnforceType(B, dst.emitRawPointer(CGF), PtrToIdTy);
4337 B.CreateCall(StrongCastAssignFn, {src, dstVal});
4338}
4339
4340void CGObjCGNU::EmitGCMemmoveCollectable(CodeGenFunction &CGF,
4341 Address DestPtr,
4342 Address SrcPtr,
4343 llvm::Value *Size) {
4344 CGBuilderTy &B = CGF.Builder;
4345 llvm::Value *DestPtrVal = EnforceType(B, DestPtr.emitRawPointer(CGF), PtrTy);
4346 llvm::Value *SrcPtrVal = EnforceType(B, SrcPtr.emitRawPointer(CGF), PtrTy);
4347
4348 B.CreateCall(MemMoveFn, {DestPtrVal, SrcPtrVal, Size});
4349}
4350
4351llvm::GlobalVariable *CGObjCGNU::ObjCIvarOffsetVariable(
4352 const ObjCInterfaceDecl *ID,
4353 const ObjCIvarDecl *Ivar) {
4354 const std::string Name = GetIVarOffsetVariableName(ID, Ivar);
4355 // Emit the variable and initialize it with what we think the correct value
4356 // is. This allows code compiled with non-fragile ivars to work correctly
4357 // when linked against code which isn't (most of the time).
4358 llvm::GlobalVariable *IvarOffsetPointer = TheModule.getNamedGlobal(Name);
4359 if (!IvarOffsetPointer)
4360 IvarOffsetPointer = new llvm::GlobalVariable(
4361 TheModule, llvm::PointerType::getUnqual(VMContext), false,
4362 llvm::GlobalValue::ExternalLinkage, nullptr, Name);
4363 return IvarOffsetPointer;
4364}
4365
4366LValue CGObjCGNU::EmitObjCValueForIvar(CodeGenFunction &CGF,
4367 QualType ObjectTy,
4368 llvm::Value *BaseValue,
4369 const ObjCIvarDecl *Ivar,
4370 unsigned CVRQualifiers) {
4371 const ObjCInterfaceDecl *ID =
4372 ObjectTy->castAs<ObjCObjectType>()->getInterface();
4373 return EmitValueForIvarAtOffset(CGF, ID, BaseValue, Ivar, CVRQualifiers,
4374 EmitIvarOffset(CGF, ID, Ivar));
4375}
4376
4378 const ObjCInterfaceDecl *OID,
4379 const ObjCIvarDecl *OIVD) {
4380 for (const ObjCIvarDecl *next = OID->all_declared_ivar_begin(); next;
4381 next = next->getNextIvar()) {
4382 if (OIVD == next)
4383 return OID;
4384 }
4385
4386 // Otherwise check in the super class.
4387 if (const ObjCInterfaceDecl *Super = OID->getSuperClass())
4388 return FindIvarInterface(Context, Super, OIVD);
4389
4390 return nullptr;
4391}
4392
4393llvm::Value *CGObjCGNU::EmitIvarOffset(CodeGenFunction &CGF,
4394 const ObjCInterfaceDecl *Interface,
4395 const ObjCIvarDecl *Ivar) {
4396 if (CGM.getLangOpts().ObjCRuntime.isNonFragile()) {
4398
4399 // The MSVC linker cannot have a single global defined as LinkOnceAnyLinkage
4400 // and ExternalLinkage, so create a reference to the ivar global and rely on
4401 // the definition being created as part of GenerateClass.
4402 if (RuntimeVersion < 10 ||
4403 CGF.CGM.getTarget().getTriple().isKnownWindowsMSVCEnvironment())
4404 return CGF.Builder.CreateZExtOrBitCast(
4406 Int32Ty,
4408 llvm::PointerType::getUnqual(VMContext),
4409 ObjCIvarOffsetVariable(Interface, Ivar),
4410 CGF.getPointerAlign(), "ivar"),
4412 PtrDiffTy);
4413 std::string name = "__objc_ivar_offset_value_" +
4414 Interface->getNameAsString() +"." + Ivar->getNameAsString();
4415 CharUnits Align = CGM.getIntAlign();
4416 llvm::Value *Offset = TheModule.getGlobalVariable(name);
4417 if (!Offset) {
4418 auto GV = new llvm::GlobalVariable(TheModule, IntTy,
4419 false, llvm::GlobalValue::LinkOnceAnyLinkage,
4420 llvm::Constant::getNullValue(IntTy), name);
4421 GV->setAlignment(Align.getAsAlign());
4422 Offset = GV;
4423 }
4424 Offset = CGF.Builder.CreateAlignedLoad(IntTy, Offset, Align);
4425 if (Offset->getType() != PtrDiffTy)
4426 Offset = CGF.Builder.CreateZExtOrBitCast(Offset, PtrDiffTy);
4427 return Offset;
4428 }
4429 uint64_t Offset = ComputeIvarBaseOffset(CGF.CGM, Interface, Ivar);
4430 return llvm::ConstantInt::get(PtrDiffTy, Offset, /*isSigned*/true);
4431}
4432
4433CGObjCRuntime *
4435 auto Runtime = CGM.getLangOpts().ObjCRuntime;
4436 switch (Runtime.getKind()) {
4438 if (Runtime.getVersion() >= VersionTuple(2, 0))
4439 return new CGObjCGNUstep2(CGM);
4440 return new CGObjCGNUstep(CGM);
4441
4442 case ObjCRuntime::GCC:
4443 return new CGObjCGCC(CGM);
4444
4445 case ObjCRuntime::ObjFW:
4446 return new CGObjCObjFW(CGM);
4447
4450 case ObjCRuntime::iOS:
4452 llvm_unreachable("these runtimes are not GNU runtimes");
4453 }
4454 llvm_unreachable("bad runtime");
4455}
Defines the clang::ASTContext interface.
#define V(N, I)
static const ObjCInterfaceDecl * FindIvarInterface(ASTContext &Context, const ObjCInterfaceDecl *OID, const ObjCIvarDecl *OIVD)
static bool isNamed(const NamedDecl *ND, const char(&Str)[Len])
Definition Decl.cpp:3298
TokenType getType() const
Returns the token's type, e.g.
#define SM(sm)
Defines the SourceManager interface.
Defines the Objective-C statement AST node classes.
__device__ __2f16 b
__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 ...
Definition ASTContext.h:188
SourceManager & getSourceManager()
Definition ASTContext.h:801
TranslationUnitDecl * getTranslationUnitDecl() const
CharUnits getTypeAlignInChars(QualType T) const
Return the ABI-specified alignment of a (complete) type T, in characters.
CanQualType LongTy
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.
IdentifierTable & Idents
Definition ASTContext.h:740
const ASTRecordLayout & getASTObjCInterfaceLayout(const ObjCInterfaceDecl *D) const
Get or compute information about the layout of the specified Objective-C interface.
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
CanQualType BoolTy
QualType getObjCSelType() const
Retrieve the type that corresponds to the predefined Objective-C 'SEL' type.
CanQualType IntTy
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...
QualType getSizeType() const
Return the unique type for "size_t" (C99 7.17), defined in <stddef.h>.
const TargetInfo & getTargetInfo() const
Definition ASTContext.h:859
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.
llvm::Align getAsAlign() const
getAsAlign - Returns Quantity as a valid llvm::Align, Beware llvm::Align assumes power of two 8-bit b...
Definition CharUnits.h:189
QuantityType getQuantity() const
getQuantity - Get the raw integer representation of this quantity.
Definition CharUnits.h:185
static CharUnits fromQuantity(QuantityType Quantity)
fromQuantity - Construct a CharUnits quantity from a raw integer type.
Definition CharUnits.h:63
llvm::Value * emitRawPointer(CodeGenFunction &CGF) const
Return the pointer contained in this class after authenticating it and adding offset to it if necessa...
Definition Address.h:253
llvm::StoreInst * CreateStore(llvm::Value *Val, Address Addr, bool IsVolatile=false)
Definition CGBuilder.h:140
llvm::LoadInst * CreateLoad(Address Addr, const llvm::Twine &Name="")
Definition CGBuilder.h:112
llvm::LoadInst * CreateAlignedLoad(llvm::Type *Ty, llvm::Value *Addr, CharUnits Align, const llvm::Twine &Name="")
Definition CGBuilder.h:132
virtual llvm::Constant * getAddrOfRTTIDescriptor(QualType Ty)=0
virtual CatchTypeInfo getCatchAllTypeInfo()
Definition CGCXXABI.cpp:333
Implements runtime-specific code generation functions.
void add(RValue rvalue, QualType type)
Definition CGCall.h:302
void addFrom(const CallArgList &other)
Add all the arguments from another CallArgList to this one.
Definition CGCall.h:311
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::CallBase * EmitRuntimeCallOrInvoke(llvm::FunctionCallee callee, ArrayRef< llvm::Value * > args, const Twine &name="")
Emits a call or invoke instruction to the given runtime function.
Definition CGCall.cpp:5059
llvm::BasicBlock * createBasicBlock(const Twine &name="", llvm::Function *parent=nullptr, llvm::BasicBlock *before=nullptr)
createBasicBlock - Create an LLVM basic block.
llvm::Value * EmitObjCThrowOperand(const Expr *expr)
Definition CGObjC.cpp:3542
void EmitBranchThroughCleanup(JumpDest Dest)
EmitBranchThroughCleanup - Emit a branch from the current insert block through the normal cleanup han...
const Decl * CurCodeDecl
CurCodeDecl - This is the inner-most code context, which includes blocks.
JumpDest ReturnBlock
ReturnBlock - Unified return block.
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...
Definition CGExpr.cpp:151
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,...
Definition CGCall.cpp:5215
llvm::Value * LoadObjCSelf()
LoadObjCSelf - Load the value of self.
Definition CGObjC.cpp:1788
llvm::CallInst * EmitNounwindRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
llvm::CallInst * EmitRuntimeCall(llvm::FunctionCallee callee, const Twine &name="")
SmallVector< llvm::Value *, 8 > ObjCEHValueStack
ObjCEHValueStack - Stack of Objective-C exception values, used for rethrows.
void EmitVarDecl(const VarDecl &D)
EmitVarDecl - Emit a local variable declaration.
Definition CGDecl.cpp:202
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()
void EmitBlock(llvm::BasicBlock *BB, bool IsFinished=false)
EmitBlock - Emit the given block.
Definition CGStmt.cpp:652
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.
Definition CGCall.cpp:1668
const LangOptions & getLangOpts() const
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
const llvm::Triple & getTriple() const
bool ReturnTypeHasInReg(const CGFunctionInfo &FI)
Return true iff the given type has inreg set.
Definition CGCall.cpp:1658
ASTContext & getContext() const
bool ReturnTypeUsesSRet(const CGFunctionInfo &FI)
Return true iff the given type uses 'sret' when used as a return type.
Definition CGCall.cpp:1653
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, StringRef GlobalName=".str")
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::FunctionType * GetFunctionType(const CGFunctionInfo &Info)
GetFunctionType - Get the LLVM function type for.
Definition CGCall.cpp:1701
llvm::Type * ConvertTypeForMem(QualType T)
ConvertTypeForMem - Convert type T into a llvm::Type.
const CGFunctionInfo & arrangeObjCMethodDeclaration(const ObjCMethodDecl *MD)
Objective-C methods are C functions with some implicit parameters.
Definition CGCall.cpp:555
bool isZeroInitializable(QualType T)
IsZeroInitializable - Return whether a type can be zero-initialized (in the C++ sense) with an LLVM z...
void add(llvm::Constant *value)
Add a new value to this initializer.
void addInt(llvm::IntegerType *intTy, uint64_t value, bool isSigned=false)
Add an integer value of a specific type.
void addNullPointer(llvm::PointerType *ptrTy)
Add a null pointer of a specific type.
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...
bool isScalar() const
Definition CGValue.h:64
static RValue get(llvm::Value *V)
Definition CGValue.h:98
static RValue getComplex(llvm::Value *V1, llvm::Value *V2)
Definition CGValue.h:108
bool isAggregate() const
Definition CGValue.h:66
Address getAggregateAddress() const
getAggregateAddr() - Return the Value* of the address of the aggregate.
Definition CGValue.h:83
llvm::Value * getScalarVal() const
getScalarVal() - Return the Value* of this scalar value.
Definition CGValue.h:71
std::pair< llvm::Value *, llvm::Value * > getComplexVal() const
getComplexVal - Return the real/imag components of this complex value.
Definition CGValue.h:78
llvm::Value * getPointer() const
Definition Address.h:66
lookup_result lookup(DeclarationName Name) const
lookup - Find the declarations (if any) with the given Name in this context.
static void add(Kind k)
Definition DeclBase.cpp:226
bool isWeakImported() const
Determine whether this is a weak-imported symbol.
Definition DeclBase.cpp:848
bool isUsed(bool CheckUsedAttr=true) const
Whether any (re-)declaration of the entity was used, meaning that a definition is required.
Definition DeclBase.cpp:553
bool hasAttr() const
Definition DeclBase.h:577
StringRef getName() const
The name of this FileEntry.
Definition FileEntry.h:61
DirectoryEntryRef getDir() const
Definition FileEntry.h:78
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.
Definition Decl.h:294
Visibility getVisibility() const
Determines the visibility of this entity.
Definition Decl.h:443
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...
Definition Decl.h:316
const Expr * getThrowExpr() const
Definition StmtObjC.h:370
const ObjCProtocolList & getReferencedProtocols() const
Definition DeclObjC.h:2396
ObjCCategoryDecl * getCategoryDecl() const
const ObjCInterfaceDecl * getClassInterface() const
Definition DeclObjC.h:2793
classmeth_iterator classmeth_end() const
Definition DeclObjC.h:1058
classmeth_iterator classmeth_begin() const
Definition DeclObjC.h:1054
instmeth_range instance_methods() const
Definition DeclObjC.h:1033
instmeth_iterator instmeth_end() const
Definition DeclObjC.h:1041
instmeth_iterator instmeth_begin() const
Definition DeclObjC.h:1037
prop_range properties() const
Definition DeclObjC.h:967
classmeth_range class_methods() const
Definition DeclObjC.h:1050
propimpl_range property_impls() const
Definition DeclObjC.h:2513
const ObjCInterfaceDecl * getClassInterface() const
Definition DeclObjC.h:2486
Represents an ObjC class declaration.
Definition DeclObjC.h:1154
all_protocol_iterator all_referenced_protocol_end() const
Definition DeclObjC.h:1435
all_protocol_range all_referenced_protocols() const
Definition DeclObjC.h:1417
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
Definition DeclObjC.h:1359
all_protocol_iterator all_referenced_protocol_begin() const
Definition DeclObjC.h:1422
ObjCInterfaceDecl * getSuperClass() const
Definition DeclObjC.cpp:349
ObjCInterfaceDecl * getDefinition()
Retrieve the definition of this class, or NULL if this class has been forward-declared (with @class) ...
Definition DeclObjC.h:1542
known_extensions_range known_extensions() const
Definition DeclObjC.h:1762
ObjCInterfaceDecl * getDecl() const
Get the declaration of this interface.
Definition Type.cpp:951
ObjCIvarDecl - Represents an ObjC instance variable.
Definition DeclObjC.h:1952
AccessControl getAccessControl() const
Definition DeclObjC.h:2000
ObjCInterfaceDecl * getContainingInterface()
Return the class interface that this ivar is logically contained in; this is either the interface whe...
ObjCIvarDecl * getNextIvar()
Definition DeclObjC.h:1987
ImplicitParamDecl * getSelfDecl() const
Definition DeclObjC.h:418
Stmt * getBody() const override
Retrieve the body of this method, if it has one.
Definition DeclObjC.cpp:906
ObjCMethodDecl * getCanonicalDecl() override
Retrieves the "canonical" declaration of the given declaration.
bool isDirectMethod() const
True if the method is tagged as objc_direct.
Definition DeclObjC.cpp:868
Selector getSelector() const
Definition DeclObjC.h:327
ImplicitParamDecl * getCmdDecl() const
Definition DeclObjC.h:420
QualType getReturnType() const
Definition DeclObjC.h:329
bool isClassMethod() const
Definition DeclObjC.h:434
const ObjCObjectType * getObjectType() const
Gets the type pointed to by this ObjC pointer.
Definition TypeBase.h:7998
const ObjCInterfaceType * getInterfaceType() const
If this pointer points to an Objective C @interface type, gets the type for that interface.
Definition Type.cpp:1840
ObjCMethodDecl * getGetterMethodDecl() const
Definition DeclObjC.h:901
ObjCMethodDecl * getSetterMethodDecl() const
Definition DeclObjC.h:904
QualType getType() const
Definition DeclObjC.h:804
ObjCProtocolDecl * getDefinition()
Retrieve the definition of this protocol, if any.
Definition DeclObjC.h:2250
bool isNonRuntimeProtocol() const
This is true iff the protocol is tagged with the objc_non_runtime_protocol attribute.
protocol_iterator protocol_begin() const
Definition DeclObjC.h:2165
protocol_range protocols() const
Definition DeclObjC.h:2161
protocol_iterator protocol_end() const
Definition DeclObjC.h:2172
Kind getKind() const
Definition ObjCRuntime.h:77
const VersionTuple & getVersion() const
Definition ObjCRuntime.h:78
bool isNonFragile() const
Does this runtime follow the set of implied behaviors for a "non-fragile" ABI?
Definition ObjCRuntime.h:82
Kind
The basic Objective-C runtimes that we know about.
Definition ObjCRuntime.h:31
@ MacOSX
'macosx' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the non-fragile AB...
Definition ObjCRuntime.h:35
@ FragileMacOSX
'macosx-fragile' is the Apple-provided NeXT-derived runtime on Mac OS X platforms that use the fragil...
Definition ObjCRuntime.h:40
@ GNUstep
'gnustep' is the modern non-fragile GNUstep runtime.
Definition ObjCRuntime.h:56
@ ObjFW
'objfw' is the Objective-C runtime included in ObjFW
Definition ObjCRuntime.h:59
@ iOS
'ios' is the Apple-provided NeXT-derived runtime on iOS or the iOS simulator; it is always non-fragil...
Definition ObjCRuntime.h:45
@ GCC
'gcc' is the Objective-C runtime shipped with GCC, implementing a fragile Objective-C ABI
Definition ObjCRuntime.h:53
@ WatchOS
'watchos' is a variant of iOS for Apple's watchOS.
Definition ObjCRuntime.h:49
A (possibly-)qualified type.
Definition TypeBase.h:937
@ OCL_Strong
Assigning into this object requires the old value to be released and the new value to be retained.
Definition TypeBase.h:361
@ OCL_ExplicitNone
This object can be modified without requiring retains or releases.
Definition TypeBase.h:354
@ OCL_None
There is no lifetime qualification on this type.
Definition TypeBase.h:350
@ OCL_Weak
Reading or writing from this object requires a barrier call.
Definition TypeBase.h:364
@ OCL_Autoreleasing
Assigning into this object requires a lifetime extension.
Definition TypeBase.h:367
std::string getAsString() const
Derive the full selector name (e.g.
bool containsNonAscii() const
Definition Expr.h:1926
unsigned getLength() const
Definition Expr.h:1911
uint32_t getCodeUnit(size_t i) const
Definition Expr.h:1884
StringRef getString() const
Definition Expr.h:1869
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.
Definition TargetInfo.h:486
static DeclContext * castToDeclContext(const TranslationUnitDecl *D)
Definition Decl.h:150
bool isVoidType() const
Definition TypeBase.h:8936
const T * castAs() const
Member-template castAs<specific type>.
Definition TypeBase.h:9226
bool isObjCQualifiedIdType() const
Definition TypeBase.h:8770
QualType getPointeeType() const
If this is a pointer, ObjC object pointer, or block pointer, this returns the respective pointee.
Definition Type.cpp:752
bool isIntegralOrEnumerationType() const
Determine whether this type is an integral or enumeration type.
Definition TypeBase.h:9054
bool isObjCIdType() const
Definition TypeBase.h:8782
const T * getAs() const
Member-template getAs<specific type>'.
Definition TypeBase.h:9159
bool hasPointerRepresentation() const
Whether this type is represented natively as a pointer.
Definition TypeBase.h:9100
QualType getType() const
Definition Decl.h:722
@ Decl
The l-value was an access to a declared entity or something equivalently strong, like the address of ...
Definition CGValue.h:145
CGObjCRuntime * CreateGNUObjCRuntime(CodeGenModule &CGM)
Creates an instance of an Objective-C runtime class.
StringRef getName(const HeaderType T)
Definition HeaderFile.h:38
constexpr size_t align(size_t Size)
Aligns a size to the pointer alignment.
Definition PrimType.h:185
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.
CanQual< Type > CanQualType
Represents a canonical, potentially-qualified type.
bool isa(CodeGen::Address addr)
Definition Address.h:330
CustomizableOptional< FileEntryRef > OptionalFileEntryRef
Definition FileEntry.h:208
@ Private
'private' clause, allowed on 'parallel', 'serial', 'loop', 'parallel loop', and 'serial loop' constru...
nullptr
This class represents a compute construct, representing a 'Kind' of ‘parallel’, 'serial',...
@ Result
The result type of a method or function.
Definition TypeBase.h:905
Selector GetNullarySelector(StringRef name, ASTContext &Ctx)
Utility function for constructing a nullary selector.
@ Type
The name was classified as a type.
Definition Sema.h:562
const FunctionProtoType * T
U cast(CodeGen::Address addr)
Definition Address.h:327
@ Interface
The "__interface" keyword introduces the elaborated-type-specifier.
Definition TypeBase.h:5886
@ Class
The "class" keyword introduces the elaborated-type-specifier.
Definition TypeBase.h:5892
@ HiddenVisibility
Objects with "hidden" visibility are not seen by the dynamic linker.
Definition Visibility.h:37
unsigned long uint64_t
unsigned int uint32_t
const half4 dst(half4 Src0, half4 Src1)
int const char * function
Definition c++config.h:31