Bug Summary

File:src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/lib/CodeGen/CGObjCGNU.cpp
Warning:line 1245, column 43
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CGObjCGNU.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangCodeGen/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/include -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/../include -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/obj -I /usr/src/gnu/usr.bin/clang/libclangCodeGen/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libclangCodeGen/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -stack-protector 2 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/lib/CodeGen/CGObjCGNU.cpp

/usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/clang/lib/CodeGen/CGObjCGNU.cpp

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

/usr/src/gnu/usr.bin/clang/libclangCodeGen/../../../llvm/llvm/include/llvm/ADT/Triple.h

1//===-- llvm/ADT/Triple.h - Target triple helper class ----------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef LLVM_ADT_TRIPLE_H
10#define LLVM_ADT_TRIPLE_H
11
12#include "llvm/ADT/Twine.h"
13
14// Some system headers or GCC predefined macros conflict with identifiers in
15// this file. Undefine them here.
16#undef NetBSD
17#undef mips
18#undef sparc
19
20namespace llvm {
21
22class VersionTuple;
23
24/// Triple - Helper class for working with autoconf configuration names. For
25/// historical reasons, we also call these 'triples' (they used to contain
26/// exactly three fields).
27///
28/// Configuration names are strings in the canonical form:
29/// ARCHITECTURE-VENDOR-OPERATING_SYSTEM
30/// or
31/// ARCHITECTURE-VENDOR-OPERATING_SYSTEM-ENVIRONMENT
32///
33/// This class is used for clients which want to support arbitrary
34/// configuration names, but also want to implement certain special
35/// behavior for particular configurations. This class isolates the mapping
36/// from the components of the configuration name to well known IDs.
37///
38/// At its core the Triple class is designed to be a wrapper for a triple
39/// string; the constructor does not change or normalize the triple string.
40/// Clients that need to handle the non-canonical triples that users often
41/// specify should use the normalize method.
42///
43/// See autoconf/config.guess for a glimpse into what configuration names
44/// look like in practice.
45class Triple {
46public:
47 enum ArchType {
48 UnknownArch,
49
50 arm, // ARM (little endian): arm, armv.*, xscale
51 armeb, // ARM (big endian): armeb
52 aarch64, // AArch64 (little endian): aarch64
53 aarch64_be, // AArch64 (big endian): aarch64_be
54 aarch64_32, // AArch64 (little endian) ILP32: aarch64_32
55 arc, // ARC: Synopsys ARC
56 avr, // AVR: Atmel AVR microcontroller
57 bpfel, // eBPF or extended BPF or 64-bit BPF (little endian)
58 bpfeb, // eBPF or extended BPF or 64-bit BPF (big endian)
59 csky, // CSKY: csky
60 hexagon, // Hexagon: hexagon
61 m68k, // M68k: Motorola 680x0 family
62 mips, // MIPS: mips, mipsallegrex, mipsr6
63 mipsel, // MIPSEL: mipsel, mipsallegrexe, mipsr6el
64 mips64, // MIPS64: mips64, mips64r6, mipsn32, mipsn32r6
65 mips64el, // MIPS64EL: mips64el, mips64r6el, mipsn32el, mipsn32r6el
66 msp430, // MSP430: msp430
67 ppc, // PPC: powerpc
68 ppcle, // PPCLE: powerpc (little endian)
69 ppc64, // PPC64: powerpc64, ppu
70 ppc64le, // PPC64LE: powerpc64le
71 r600, // R600: AMD GPUs HD2XXX - HD6XXX
72 amdgcn, // AMDGCN: AMD GCN GPUs
73 riscv32, // RISC-V (32-bit): riscv32
74 riscv64, // RISC-V (64-bit): riscv64
75 sparc, // Sparc: sparc
76 sparcv9, // Sparcv9: Sparcv9
77 sparcel, // Sparc: (endianness = little). NB: 'Sparcle' is a CPU variant
78 systemz, // SystemZ: s390x
79 tce, // TCE (http://tce.cs.tut.fi/): tce
80 tcele, // TCE little endian (http://tce.cs.tut.fi/): tcele
81 thumb, // Thumb (little endian): thumb, thumbv.*
82 thumbeb, // Thumb (big endian): thumbeb
83 x86, // X86: i[3-9]86
84 x86_64, // X86-64: amd64, x86_64
85 xcore, // XCore: xcore
86 nvptx, // NVPTX: 32-bit
87 nvptx64, // NVPTX: 64-bit
88 le32, // le32: generic little-endian 32-bit CPU (PNaCl)
89 le64, // le64: generic little-endian 64-bit CPU (PNaCl)
90 amdil, // AMDIL
91 amdil64, // AMDIL with 64-bit pointers
92 hsail, // AMD HSAIL
93 hsail64, // AMD HSAIL with 64-bit pointers
94 spir, // SPIR: standard portable IR for OpenCL 32-bit version
95 spir64, // SPIR: standard portable IR for OpenCL 64-bit version
96 kalimba, // Kalimba: generic kalimba
97 shave, // SHAVE: Movidius vector VLIW processors
98 lanai, // Lanai: Lanai 32-bit
99 wasm32, // WebAssembly with 32-bit pointers
100 wasm64, // WebAssembly with 64-bit pointers
101 renderscript32, // 32-bit RenderScript
102 renderscript64, // 64-bit RenderScript
103 ve, // NEC SX-Aurora Vector Engine
104 LastArchType = ve
105 };
106 enum SubArchType {
107 NoSubArch,
108
109 ARMSubArch_v8_7a,
110 ARMSubArch_v8_6a,
111 ARMSubArch_v8_5a,
112 ARMSubArch_v8_4a,
113 ARMSubArch_v8_3a,
114 ARMSubArch_v8_2a,
115 ARMSubArch_v8_1a,
116 ARMSubArch_v8,
117 ARMSubArch_v8r,
118 ARMSubArch_v8m_baseline,
119 ARMSubArch_v8m_mainline,
120 ARMSubArch_v8_1m_mainline,
121 ARMSubArch_v7,
122 ARMSubArch_v7em,
123 ARMSubArch_v7m,
124 ARMSubArch_v7s,
125 ARMSubArch_v7k,
126 ARMSubArch_v7ve,
127 ARMSubArch_v6,
128 ARMSubArch_v6m,
129 ARMSubArch_v6k,
130 ARMSubArch_v6t2,
131 ARMSubArch_v5,
132 ARMSubArch_v5te,
133 ARMSubArch_v4t,
134
135 AArch64SubArch_arm64e,
136
137 KalimbaSubArch_v3,
138 KalimbaSubArch_v4,
139 KalimbaSubArch_v5,
140
141 MipsSubArch_r6,
142
143 PPCSubArch_spe
144 };
145 enum VendorType {
146 UnknownVendor,
147
148 Apple,
149 PC,
150 SCEI,
151 Freescale,
152 IBM,
153 ImaginationTechnologies,
154 MipsTechnologies,
155 NVIDIA,
156 CSR,
157 Myriad,
158 AMD,
159 Mesa,
160 SUSE,
161 OpenEmbedded,
162 LastVendorType = OpenEmbedded
163 };
164 enum OSType {
165 UnknownOS,
166
167 Ananas,
168 CloudABI,
169 Darwin,
170 DragonFly,
171 FreeBSD,
172 Fuchsia,
173 IOS,
174 KFreeBSD,
175 Linux,
176 Lv2, // PS3
177 MacOSX,
178 NetBSD,
179 OpenBSD,
180 Solaris,
181 Win32,
182 ZOS,
183 Haiku,
184 Minix,
185 RTEMS,
186 NaCl, // Native Client
187 AIX,
188 CUDA, // NVIDIA CUDA
189 NVCL, // NVIDIA OpenCL
190 AMDHSA, // AMD HSA Runtime
191 PS4,
192 ELFIAMCU,
193 TvOS, // Apple tvOS
194 WatchOS, // Apple watchOS
195 Mesa3D,
196 Contiki,
197 AMDPAL, // AMD PAL Runtime
198 HermitCore, // HermitCore Unikernel/Multikernel
199 Hurd, // GNU/Hurd
200 WASI, // Experimental WebAssembly OS
201 Emscripten,
202 LastOSType = Emscripten
203 };
204 enum EnvironmentType {
205 UnknownEnvironment,
206
207 GNU,
208 GNUABIN32,
209 GNUABI64,
210 GNUEABI,
211 GNUEABIHF,
212 GNUX32,
213 GNUILP32,
214 CODE16,
215 EABI,
216 EABIHF,
217 Android,
218 Musl,
219 MuslEABI,
220 MuslEABIHF,
221 MuslX32,
222
223 MSVC,
224 Itanium,
225 Cygnus,
226 CoreCLR,
227 Simulator, // Simulator variants of other systems, e.g., Apple's iOS
228 MacABI, // Mac Catalyst variant of Apple's iOS deployment target.
229 LastEnvironmentType = MacABI
230 };
231 enum ObjectFormatType {
232 UnknownObjectFormat,
233
234 COFF,
235 ELF,
236 GOFF,
237 MachO,
238 Wasm,
239 XCOFF,
240 };
241
242private:
243 std::string Data;
244
245 /// The parsed arch type.
246 ArchType Arch;
247
248 /// The parsed subarchitecture type.
249 SubArchType SubArch;
250
251 /// The parsed vendor type.
252 VendorType Vendor;
253
254 /// The parsed OS type.
255 OSType OS;
256
257 /// The parsed Environment type.
258 EnvironmentType Environment;
259
260 /// The object format type.
261 ObjectFormatType ObjectFormat;
262
263public:
264 /// @name Constructors
265 /// @{
266
267 /// Default constructor is the same as an empty string and leaves all
268 /// triple fields unknown.
269 Triple()
270 : Data(), Arch(), SubArch(), Vendor(), OS(), Environment(),
271 ObjectFormat() {}
272
273 explicit Triple(const Twine &Str);
274 Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr);
275 Triple(const Twine &ArchStr, const Twine &VendorStr, const Twine &OSStr,
276 const Twine &EnvironmentStr);
277
278 bool operator==(const Triple &Other) const {
279 return Arch == Other.Arch && SubArch == Other.SubArch &&
280 Vendor == Other.Vendor && OS == Other.OS &&
281 Environment == Other.Environment &&
282 ObjectFormat == Other.ObjectFormat;
283 }
284
285 bool operator!=(const Triple &Other) const {
286 return !(*this == Other);
287 }
288
289 /// @}
290 /// @name Normalization
291 /// @{
292
293 /// normalize - Turn an arbitrary machine specification into the canonical
294 /// triple form (or something sensible that the Triple class understands if
295 /// nothing better can reasonably be done). In particular, it handles the
296 /// common case in which otherwise valid components are in the wrong order.
297 static std::string normalize(StringRef Str);
298
299 /// Return the normalized form of this triple's string.
300 std::string normalize() const { return normalize(Data); }
301
302 /// @}
303 /// @name Typed Component Access
304 /// @{
305
306 /// getArch - Get the parsed architecture type of this triple.
307 ArchType getArch() const { return Arch; }
308
309 /// getSubArch - get the parsed subarchitecture type for this triple.
310 SubArchType getSubArch() const { return SubArch; }
311
312 /// getVendor - Get the parsed vendor type of this triple.
313 VendorType getVendor() const { return Vendor; }
314
315 /// getOS - Get the parsed operating system type of this triple.
316 OSType getOS() const { return OS; }
317
318 /// hasEnvironment - Does this triple have the optional environment
319 /// (fourth) component?
320 bool hasEnvironment() const {
321 return getEnvironmentName() != "";
322 }
323
324 /// getEnvironment - Get the parsed environment type of this triple.
325 EnvironmentType getEnvironment() const { return Environment; }
326
327 /// Parse the version number from the OS name component of the
328 /// triple, if present.
329 ///
330 /// For example, "fooos1.2.3" would return (1, 2, 3).
331 ///
332 /// If an entry is not defined, it will be returned as 0.
333 void getEnvironmentVersion(unsigned &Major, unsigned &Minor,
334 unsigned &Micro) const;
335
336 /// getFormat - Get the object format for this triple.
337 ObjectFormatType getObjectFormat() const { return ObjectFormat; }
338
339 /// getOSVersion - Parse the version number from the OS name component of the
340 /// triple, if present.
341 ///
342 /// For example, "fooos1.2.3" would return (1, 2, 3).
343 ///
344 /// If an entry is not defined, it will be returned as 0.
345 void getOSVersion(unsigned &Major, unsigned &Minor, unsigned &Micro) const;
346
347 /// getOSMajorVersion - Return just the major version number, this is
348 /// specialized because it is a common query.
349 unsigned getOSMajorVersion() const {
350 unsigned Maj, Min, Micro;
351 getOSVersion(Maj, Min, Micro);
352 return Maj;
353 }
354
355 /// getMacOSXVersion - Parse the version number as with getOSVersion and then
356 /// translate generic "darwin" versions to the corresponding OS X versions.
357 /// This may also be called with IOS triples but the OS X version number is
358 /// just set to a constant 10.4.0 in that case. Returns true if successful.
359 bool getMacOSXVersion(unsigned &Major, unsigned &Minor,
360 unsigned &Micro) const;
361
362 /// getiOSVersion - Parse the version number as with getOSVersion. This should
363 /// only be called with IOS or generic triples.
364 void getiOSVersion(unsigned &Major, unsigned &Minor,
365 unsigned &Micro) const;
366
367 /// getWatchOSVersion - Parse the version number as with getOSVersion. This
368 /// should only be called with WatchOS or generic triples.
369 void getWatchOSVersion(unsigned &Major, unsigned &Minor,
370 unsigned &Micro) const;
371
372 /// @}
373 /// @name Direct Component Access
374 /// @{
375
376 const std::string &str() const { return Data; }
377
378 const std::string &getTriple() const { return Data; }
379
380 /// getArchName - Get the architecture (first) component of the
381 /// triple.
382 StringRef getArchName() const;
383
384 /// getVendorName - Get the vendor (second) component of the triple.
385 StringRef getVendorName() const;
386
387 /// getOSName - Get the operating system (third) component of the
388 /// triple.
389 StringRef getOSName() const;
390
391 /// getEnvironmentName - Get the optional environment (fourth)
392 /// component of the triple, or "" if empty.
393 StringRef getEnvironmentName() const;
394
395 /// getOSAndEnvironmentName - Get the operating system and optional
396 /// environment components as a single string (separated by a '-'
397 /// if the environment component is present).
398 StringRef getOSAndEnvironmentName() const;
399
400 /// @}
401 /// @name Convenience Predicates
402 /// @{
403
404 /// Test whether the architecture is 64-bit
405 ///
406 /// Note that this tests for 64-bit pointer width, and nothing else. Note
407 /// that we intentionally expose only three predicates, 64-bit, 32-bit, and
408 /// 16-bit. The inner details of pointer width for particular architectures
409 /// is not summed up in the triple, and so only a coarse grained predicate
410 /// system is provided.
411 bool isArch64Bit() const;
412
413 /// Test whether the architecture is 32-bit
414 ///
415 /// Note that this tests for 32-bit pointer width, and nothing else.
416 bool isArch32Bit() const;
417
418 /// Test whether the architecture is 16-bit
419 ///
420 /// Note that this tests for 16-bit pointer width, and nothing else.
421 bool isArch16Bit() const;
422
423 /// isOSVersionLT - Helper function for doing comparisons against version
424 /// numbers included in the target triple.
425 bool isOSVersionLT(unsigned Major, unsigned Minor = 0,
426 unsigned Micro = 0) const {
427 unsigned LHS[3];
428 getOSVersion(LHS[0], LHS[1], LHS[2]);
429
430 if (LHS[0] != Major)
431 return LHS[0] < Major;
432 if (LHS[1] != Minor)
433 return LHS[1] < Minor;
434 if (LHS[2] != Micro)
435 return LHS[2] < Micro;
436
437 return false;
438 }
439
440 bool isOSVersionLT(const Triple &Other) const {
441 unsigned RHS[3];
442 Other.getOSVersion(RHS[0], RHS[1], RHS[2]);
443 return isOSVersionLT(RHS[0], RHS[1], RHS[2]);
444 }
445
446 /// isMacOSXVersionLT - Comparison function for checking OS X version
447 /// compatibility, which handles supporting skewed version numbering schemes
448 /// used by the "darwin" triples.
449 bool isMacOSXVersionLT(unsigned Major, unsigned Minor = 0,
450 unsigned Micro = 0) const;
451
452 /// isMacOSX - Is this a Mac OS X triple. For legacy reasons, we support both
453 /// "darwin" and "osx" as OS X triples.
454 bool isMacOSX() const {
455 return getOS() == Triple::Darwin || getOS() == Triple::MacOSX;
456 }
457
458 /// Is this an iOS triple.
459 /// Note: This identifies tvOS as a variant of iOS. If that ever
460 /// changes, i.e., if the two operating systems diverge or their version
461 /// numbers get out of sync, that will need to be changed.
462 /// watchOS has completely different version numbers so it is not included.
463 bool isiOS() const {
464 return getOS() == Triple::IOS || isTvOS();
465 }
466
467 /// Is this an Apple tvOS triple.
468 bool isTvOS() const {
469 return getOS() == Triple::TvOS;
470 }
471
472 /// Is this an Apple watchOS triple.
473 bool isWatchOS() const {
474 return getOS() == Triple::WatchOS;
475 }
476
477 bool isWatchABI() const {
478 return getSubArch() == Triple::ARMSubArch_v7k;
479 }
480
481 bool isOSzOS() const { return getOS() == Triple::ZOS; }
482
483 /// isOSDarwin - Is this a "Darwin" OS (macOS, iOS, tvOS or watchOS).
484 bool isOSDarwin() const {
485 return isMacOSX() || isiOS() || isWatchOS();
486 }
487
488 bool isSimulatorEnvironment() const {
489 return getEnvironment() == Triple::Simulator;
490 }
491
492 bool isMacCatalystEnvironment() const {
493 return getEnvironment() == Triple::MacABI;
494 }
495
496 /// Returns true for targets that run on a macOS machine.
497 bool isTargetMachineMac() const {
498 return isMacOSX() || (isOSDarwin() && (isSimulatorEnvironment() ||
499 isMacCatalystEnvironment()));
500 }
501
502 bool isOSNetBSD() const {
503 return getOS() == Triple::NetBSD;
504 }
505
506 bool isOSOpenBSD() const {
507 return getOS() == Triple::OpenBSD;
508 }
509
510 bool isOSFreeBSD() const {
511 return getOS() == Triple::FreeBSD;
512 }
513
514 bool isOSFuchsia() const {
515 return getOS() == Triple::Fuchsia;
516 }
517
518 bool isOSDragonFly() const { return getOS() == Triple::DragonFly; }
519
520 bool isOSSolaris() const {
521 return getOS() == Triple::Solaris;
522 }
523
524 bool isOSIAMCU() const {
525 return getOS() == Triple::ELFIAMCU;
526 }
527
528 bool isOSUnknown() const { return getOS() == Triple::UnknownOS; }
529
530 bool isGNUEnvironment() const {
531 EnvironmentType Env = getEnvironment();
532 return Env == Triple::GNU || Env == Triple::GNUABIN32 ||
533 Env == Triple::GNUABI64 || Env == Triple::GNUEABI ||
534 Env == Triple::GNUEABIHF || Env == Triple::GNUX32;
535 }
536
537 bool isOSContiki() const {
538 return getOS() == Triple::Contiki;
539 }
540
541 /// Tests whether the OS is Haiku.
542 bool isOSHaiku() const {
543 return getOS() == Triple::Haiku;
544 }
545
546 /// Tests whether the OS is Windows.
547 bool isOSWindows() const {
548 return getOS() == Triple::Win32;
549 }
550
551 /// Checks if the environment is MSVC.
552 bool isKnownWindowsMSVCEnvironment() const {
553 return isOSWindows() && getEnvironment() == Triple::MSVC;
554 }
555
556 /// Checks if the environment could be MSVC.
557 bool isWindowsMSVCEnvironment() const {
558 return isKnownWindowsMSVCEnvironment() ||
559 (isOSWindows() && getEnvironment() == Triple::UnknownEnvironment);
560 }
561
562 bool isWindowsCoreCLREnvironment() const {
563 return isOSWindows() && getEnvironment() == Triple::CoreCLR;
564 }
565
566 bool isWindowsItaniumEnvironment() const {
567 return isOSWindows() && getEnvironment() == Triple::Itanium;
568 }
569
570 bool isWindowsCygwinEnvironment() const {
571 return isOSWindows() && getEnvironment() == Triple::Cygnus;
572 }
573
574 bool isWindowsGNUEnvironment() const {
575 return isOSWindows() && getEnvironment() == Triple::GNU;
576 }
577
578 /// Tests for either Cygwin or MinGW OS
579 bool isOSCygMing() const {
580 return isWindowsCygwinEnvironment() || isWindowsGNUEnvironment();
581 }
582
583 /// Is this a "Windows" OS targeting a "MSVCRT.dll" environment.
584 bool isOSMSVCRT() const {
585 return isWindowsMSVCEnvironment() || isWindowsGNUEnvironment() ||
586 isWindowsItaniumEnvironment();
587 }
588
589 /// Tests whether the OS is NaCl (Native Client)
590 bool isOSNaCl() const {
591 return getOS() == Triple::NaCl;
592 }
593
594 /// Tests whether the OS is Linux.
595 bool isOSLinux() const {
596 return getOS() == Triple::Linux;
597 }
598
599 /// Tests whether the OS is kFreeBSD.
600 bool isOSKFreeBSD() const {
601 return getOS() == Triple::KFreeBSD;
602 }
603
604 /// Tests whether the OS is Hurd.
605 bool isOSHurd() const {
606 return getOS() == Triple::Hurd;
607 }
608
609 /// Tests whether the OS is WASI.
610 bool isOSWASI() const {
611 return getOS() == Triple::WASI;
612 }
613
614 /// Tests whether the OS is Emscripten.
615 bool isOSEmscripten() const {
616 return getOS() == Triple::Emscripten;
617 }
618
619 /// Tests whether the OS uses glibc.
620 bool isOSGlibc() const {
621 return (getOS() == Triple::Linux || getOS() == Triple::KFreeBSD ||
622 getOS() == Triple::Hurd) &&
623 !isAndroid();
624 }
625
626 /// Tests whether the OS is AIX.
627 bool isOSAIX() const {
628 return getOS() == Triple::AIX;
629 }
630
631 /// Tests whether the OS uses the ELF binary format.
632 bool isOSBinFormatELF() const {
633 return getObjectFormat() == Triple::ELF;
634 }
635
636 /// Tests whether the OS uses the COFF binary format.
637 bool isOSBinFormatCOFF() const {
638 return getObjectFormat() == Triple::COFF;
17
Returning the value 1, which participates in a condition later
639 }
640
641 /// Tests whether the OS uses the GOFF binary format.
642 bool isOSBinFormatGOFF() const { return getObjectFormat() == Triple::GOFF; }
643
644 /// Tests whether the environment is MachO.
645 bool isOSBinFormatMachO() const {
646 return getObjectFormat() == Triple::MachO;
647 }
648
649 /// Tests whether the OS uses the Wasm binary format.
650 bool isOSBinFormatWasm() const {
651 return getObjectFormat() == Triple::Wasm;
652 }
653
654 /// Tests whether the OS uses the XCOFF binary format.
655 bool isOSBinFormatXCOFF() const {
656 return getObjectFormat() == Triple::XCOFF;
657 }
658
659 /// Tests whether the target is the PS4 CPU
660 bool isPS4CPU() const {
661 return getArch() == Triple::x86_64 &&
662 getVendor() == Triple::SCEI &&
663 getOS() == Triple::PS4;
664 }
665
666 /// Tests whether the target is the PS4 platform
667 bool isPS4() const {
668 return getVendor() == Triple::SCEI &&
669 getOS() == Triple::PS4;
670 }
671
672 /// Tests whether the target is Android
673 bool isAndroid() const { return getEnvironment() == Triple::Android; }
674
675 bool isAndroidVersionLT(unsigned Major) const {
676 assert(isAndroid() && "Not an Android triple!")((void)0);
677
678 unsigned Env[3];
679 getEnvironmentVersion(Env[0], Env[1], Env[2]);
680
681 // 64-bit targets did not exist before API level 21 (Lollipop).
682 if (isArch64Bit() && Env[0] < 21)
683 Env[0] = 21;
684
685 return Env[0] < Major;
686 }
687
688 /// Tests whether the environment is musl-libc
689 bool isMusl() const {
690 return getEnvironment() == Triple::Musl ||
691 getEnvironment() == Triple::MuslEABI ||
692 getEnvironment() == Triple::MuslEABIHF ||
693 getEnvironment() == Triple::MuslX32;
694 }
695
696 /// Tests whether the target is SPIR (32- or 64-bit).
697 bool isSPIR() const {
698 return getArch() == Triple::spir || getArch() == Triple::spir64;
699 }
700
701 /// Tests whether the target is NVPTX (32- or 64-bit).
702 bool isNVPTX() const {
703 return getArch() == Triple::nvptx || getArch() == Triple::nvptx64;
704 }
705
706 /// Tests whether the target is AMDGCN
707 bool isAMDGCN() const { return getArch() == Triple::amdgcn; }
708
709 bool isAMDGPU() const {
710 return getArch() == Triple::r600 || getArch() == Triple::amdgcn;
711 }
712
713 /// Tests whether the target is Thumb (little and big endian).
714 bool isThumb() const {
715 return getArch() == Triple::thumb || getArch() == Triple::thumbeb;
716 }
717
718 /// Tests whether the target is ARM (little and big endian).
719 bool isARM() const {
720 return getArch() == Triple::arm || getArch() == Triple::armeb;
721 }
722
723 /// Tests whether the target is AArch64 (little and big endian).
724 bool isAArch64() const {
725 return getArch() == Triple::aarch64 || getArch() == Triple::aarch64_be ||
726 getArch() == Triple::aarch64_32;
727 }
728
729 /// Tests whether the target is AArch64 and pointers are the size specified by
730 /// \p PointerWidth.
731 bool isAArch64(int PointerWidth) const {
732 assert(PointerWidth == 64 || PointerWidth == 32)((void)0);
733 if (!isAArch64())
734 return false;
735 return getArch() == Triple::aarch64_32 ||
736 getEnvironment() == Triple::GNUILP32
737 ? PointerWidth == 32
738 : PointerWidth == 64;
739 }
740
741 /// Tests whether the target is MIPS 32-bit (little and big endian).
742 bool isMIPS32() const {
743 return getArch() == Triple::mips || getArch() == Triple::mipsel;
744 }
745
746 /// Tests whether the target is MIPS 64-bit (little and big endian).
747 bool isMIPS64() const {
748 return getArch() == Triple::mips64 || getArch() == Triple::mips64el;
749 }
750
751 /// Tests whether the target is MIPS (little and big endian, 32- or 64-bit).
752 bool isMIPS() const {
753 return isMIPS32() || isMIPS64();
754 }
755
756 /// Tests whether the target is PowerPC (32- or 64-bit LE or BE).
757 bool isPPC() const {
758 return getArch() == Triple::ppc || getArch() == Triple::ppc64 ||
759 getArch() == Triple::ppcle || getArch() == Triple::ppc64le;
760 }
761
762 /// Tests whether the target is 32-bit PowerPC (little and big endian).
763 bool isPPC32() const {
764 return getArch() == Triple::ppc || getArch() == Triple::ppcle;
765 }
766
767 /// Tests whether the target is 64-bit PowerPC (little and big endian).
768 bool isPPC64() const {
769 return getArch() == Triple::ppc64 || getArch() == Triple::ppc64le;
770 }
771
772 /// Tests whether the target is RISC-V (32- and 64-bit).
773 bool isRISCV() const {
774 return getArch() == Triple::riscv32 || getArch() == Triple::riscv64;
775 }
776
777 /// Tests whether the target is SystemZ.
778 bool isSystemZ() const {
779 return getArch() == Triple::systemz;
780 }
781
782 /// Tests whether the target is x86 (32- or 64-bit).
783 bool isX86() const {
784 return getArch() == Triple::x86 || getArch() == Triple::x86_64;
785 }
786
787 /// Tests whether the target is VE
788 bool isVE() const {
789 return getArch() == Triple::ve;
790 }
791
792 /// Tests whether the target is wasm (32- and 64-bit).
793 bool isWasm() const {
794 return getArch() == Triple::wasm32 || getArch() == Triple::wasm64;
795 }
796
797 // Tests whether the target is CSKY
798 bool isCSKY() const {
799 return getArch() == Triple::csky;
800 }
801
802 /// Tests whether the target is the Apple "arm64e" AArch64 subarch.
803 bool isArm64e() const {
804 return getArch() == Triple::aarch64 &&
805 getSubArch() == Triple::AArch64SubArch_arm64e;
806 }
807
808 /// Tests whether the target is X32.
809 bool isX32() const {
810 EnvironmentType Env = getEnvironment();
811 return Env == Triple::GNUX32 || Env == Triple::MuslX32;
812 }
813
814 /// Tests whether the target supports comdat
815 bool supportsCOMDAT() const {
816 return !(isOSBinFormatMachO() || isOSBinFormatXCOFF());
817 }
818
819 /// Tests whether the target uses emulated TLS as default.
820 bool hasDefaultEmulatedTLS() const {
821 return isAndroid() || isOSOpenBSD() || isWindowsCygwinEnvironment();
822 }
823
824 /// Tests whether the target uses -data-sections as default.
825 bool hasDefaultDataSections() const {
826 return isOSBinFormatXCOFF() || isWasm();
827 }
828
829 /// Tests if the environment supports dllimport/export annotations.
830 bool hasDLLImportExport() const { return isOSWindows() || isPS4CPU(); }
831
832 /// @}
833 /// @name Mutators
834 /// @{
835
836 /// setArch - Set the architecture (first) component of the triple
837 /// to a known type.
838 void setArch(ArchType Kind);
839
840 /// setVendor - Set the vendor (second) component of the triple to a
841 /// known type.
842 void setVendor(VendorType Kind);
843
844 /// setOS - Set the operating system (third) component of the triple
845 /// to a known type.
846 void setOS(OSType Kind);
847
848 /// setEnvironment - Set the environment (fourth) component of the triple
849 /// to a known type.
850 void setEnvironment(EnvironmentType Kind);
851
852 /// setObjectFormat - Set the object file format
853 void setObjectFormat(ObjectFormatType Kind);
854
855 /// setTriple - Set all components to the new triple \p Str.
856 void setTriple(const Twine &Str);
857
858 /// setArchName - Set the architecture (first) component of the
859 /// triple by name.
860 void setArchName(StringRef Str);
861
862 /// setVendorName - Set the vendor (second) component of the triple
863 /// by name.
864 void setVendorName(StringRef Str);
865
866 /// setOSName - Set the operating system (third) component of the
867 /// triple by name.
868 void setOSName(StringRef Str);
869
870 /// setEnvironmentName - Set the optional environment (fourth)
871 /// component of the triple by name.
872 void setEnvironmentName(StringRef Str);
873
874 /// setOSAndEnvironmentName - Set the operating system and optional
875 /// environment components with a single string.
876 void setOSAndEnvironmentName(StringRef Str);
877
878 /// @}
879 /// @name Helpers to build variants of a particular triple.
880 /// @{
881
882 /// Form a triple with a 32-bit variant of the current architecture.
883 ///
884 /// This can be used to move across "families" of architectures where useful.
885 ///
886 /// \returns A new triple with a 32-bit architecture or an unknown
887 /// architecture if no such variant can be found.
888 llvm::Triple get32BitArchVariant() const;
889
890 /// Form a triple with a 64-bit variant of the current architecture.
891 ///
892 /// This can be used to move across "families" of architectures where useful.
893 ///
894 /// \returns A new triple with a 64-bit architecture or an unknown
895 /// architecture if no such variant can be found.
896 llvm::Triple get64BitArchVariant() const;
897
898 /// Form a triple with a big endian variant of the current architecture.
899 ///
900 /// This can be used to move across "families" of architectures where useful.
901 ///
902 /// \returns A new triple with a big endian architecture or an unknown
903 /// architecture if no such variant can be found.
904 llvm::Triple getBigEndianArchVariant() const;
905
906 /// Form a triple with a little endian variant of the current architecture.
907 ///
908 /// This can be used to move across "families" of architectures where useful.
909 ///
910 /// \returns A new triple with a little endian architecture or an unknown
911 /// architecture if no such variant can be found.
912 llvm::Triple getLittleEndianArchVariant() const;
913
914 /// Get the (LLVM) name of the minimum ARM CPU for the arch we are targeting.
915 ///
916 /// \param Arch the architecture name (e.g., "armv7s"). If it is an empty
917 /// string then the triple's arch name is used.
918 StringRef getARMCPUForArch(StringRef Arch = StringRef()) const;
919
920 /// Tests whether the target triple is little endian.
921 ///
922 /// \returns true if the triple is little endian, false otherwise.
923 bool isLittleEndian() const;
924
925 /// Test whether target triples are compatible.
926 bool isCompatibleWith(const Triple &Other) const;
927
928 /// Merge target triples.
929 std::string merge(const Triple &Other) const;
930
931 /// Some platforms have different minimum supported OS versions that
932 /// varies by the architecture specified in the triple. This function
933 /// returns the minimum supported OS version for this triple if one an exists,
934 /// or an invalid version tuple if this triple doesn't have one.
935 VersionTuple getMinimumSupportedOSVersion() const;
936
937 /// @}
938 /// @name Static helpers for IDs.
939 /// @{
940
941 /// getArchTypeName - Get the canonical name for the \p Kind architecture.
942 static StringRef getArchTypeName(ArchType Kind);
943
944 /// getArchTypePrefix - Get the "prefix" canonical name for the \p Kind
945 /// architecture. This is the prefix used by the architecture specific
946 /// builtins, and is suitable for passing to \see
947 /// Intrinsic::getIntrinsicForGCCBuiltin().
948 ///
949 /// \return - The architecture prefix, or 0 if none is defined.
950 static StringRef getArchTypePrefix(ArchType Kind);
951
952 /// getVendorTypeName - Get the canonical name for the \p Kind vendor.
953 static StringRef getVendorTypeName(VendorType Kind);
954
955 /// getOSTypeName - Get the canonical name for the \p Kind operating system.
956 static StringRef getOSTypeName(OSType Kind);
957
958 /// getEnvironmentTypeName - Get the canonical name for the \p Kind
959 /// environment.
960 static StringRef getEnvironmentTypeName(EnvironmentType Kind);
961
962 /// @}
963 /// @name Static helpers for converting alternate architecture names.
964 /// @{
965
966 /// getArchTypeForLLVMName - The canonical type for the given LLVM
967 /// architecture name (e.g., "x86").
968 static ArchType getArchTypeForLLVMName(StringRef Str);
969
970 /// @}
971
972 /// Returns a canonicalized OS version number for the specified OS.
973 static VersionTuple getCanonicalVersionForOS(OSType OSKind,
974 const VersionTuple &Version);
975};
976
977} // End llvm namespace
978
979
980#endif