Bug Summary

File:clang/lib/CodeGen/CGObjCGNU.cpp
Warning:line 1239, column 43
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

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

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

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