blob: 54aca0c96de851cfe66aee0a0b082a74e172d978 [file] [log] [blame]
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +00001//===------- CGObjCGNU.cpp - Emit LLVM Code from ASTs for a Module --------===//
Chris Lattnera0fd5ee2008-03-01 08:50:34 +00002//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +000010// This provides Objective-C code generation targetting the GNU runtime. The
11// class in this file generates structures used by the GNU Objective-C runtime
12// library. These structures are defined in objc/objc.h and objc/objc-api.h in
13// the GNU runtime distribution.
Chris Lattnera0fd5ee2008-03-01 08:50:34 +000014//
15//===----------------------------------------------------------------------===//
16
17#include "CGObjCRuntime.h"
Chris Lattner547907c2008-06-26 04:19:03 +000018#include "CodeGenModule.h"
19#include "clang/AST/ASTContext.h"
Daniel Dunbarde300732008-08-11 04:54:23 +000020#include "clang/AST/Decl.h"
Chris Lattnera0fd5ee2008-03-01 08:50:34 +000021#include "llvm/Module.h"
22#include "llvm/Support/Compiler.h"
Chris Lattner676bf212008-04-13 07:32:11 +000023#include "llvm/Support/IRBuilder.h"
Chris Lattnera0fd5ee2008-03-01 08:50:34 +000024#include "llvm/ADT/SmallVector.h"
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +000025#include "llvm/ADT/StringMap.h"
26#include <map>
Chris Lattner547907c2008-06-26 04:19:03 +000027using namespace clang;
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +000028using llvm::dyn_cast;
29
30// The version of the runtime that this class targets. Must match the version
31// in the runtime.
32static const int RuntimeVersion = 8;
33static const int ProtocolVersion = 2;
Chris Lattnera0fd5ee2008-03-01 08:50:34 +000034
Chris Lattnera0fd5ee2008-03-01 08:50:34 +000035namespace {
Chris Lattner547907c2008-06-26 04:19:03 +000036class CGObjCGNU : public CodeGen::CGObjCRuntime {
Chris Lattnera0fd5ee2008-03-01 08:50:34 +000037private:
Chris Lattner547907c2008-06-26 04:19:03 +000038 CodeGen::CodeGenModule &CGM;
Chris Lattnera0fd5ee2008-03-01 08:50:34 +000039 llvm::Module &TheModule;
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +000040 const llvm::StructType *SelStructTy;
Chris Lattnerb326b172008-03-30 23:03:07 +000041 const llvm::Type *SelectorTy;
42 const llvm::Type *PtrToInt8Ty;
43 const llvm::Type *IMPTy;
44 const llvm::Type *IdTy;
45 const llvm::Type *IntTy;
46 const llvm::Type *PtrTy;
47 const llvm::Type *LongTy;
48 const llvm::Type *PtrToIntTy;
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +000049 std::vector<llvm::Constant*> Classes;
50 std::vector<llvm::Constant*> Categories;
51 std::vector<llvm::Constant*> ConstantStrings;
52 llvm::Function *LoadFunction;
53 llvm::StringMap<llvm::Constant*> ExistingProtocols;
54 typedef std::pair<std::string, std::string> TypedSelector;
55 std::map<TypedSelector, llvm::GlobalAlias*> TypedSelectors;
56 llvm::StringMap<llvm::GlobalAlias*> UntypedSelectors;
57 // Some zeros used for GEPs in lots of places.
58 llvm::Constant *Zeros[2];
59 llvm::Constant *NULLPtr;
60private:
61 llvm::Constant *GenerateIvarList(
62 const llvm::SmallVectorImpl<llvm::Constant *> &IvarNames,
63 const llvm::SmallVectorImpl<llvm::Constant *> &IvarTypes,
64 const llvm::SmallVectorImpl<llvm::Constant *> &IvarOffsets);
65 llvm::Constant *GenerateMethodList(const std::string &ClassName,
66 const std::string &CategoryName,
Chris Lattner578279d2008-06-26 05:08:00 +000067 const llvm::SmallVectorImpl<Selector> &MethodSels,
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +000068 const llvm::SmallVectorImpl<llvm::Constant *> &MethodTypes,
69 bool isClassMethodList);
70 llvm::Constant *GenerateProtocolList(
71 const llvm::SmallVectorImpl<std::string> &Protocols);
72 llvm::Constant *GenerateClassStructure(
73 llvm::Constant *MetaClass,
74 llvm::Constant *SuperClass,
75 unsigned info,
Chris Lattnerad9c3f32008-06-26 04:47:04 +000076 const char *Name,
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +000077 llvm::Constant *Version,
78 llvm::Constant *InstanceSize,
79 llvm::Constant *IVars,
80 llvm::Constant *Methods,
81 llvm::Constant *Protocols);
82 llvm::Constant *GenerateProtocolMethodList(
83 const llvm::SmallVectorImpl<llvm::Constant *> &MethodNames,
84 const llvm::SmallVectorImpl<llvm::Constant *> &MethodTypes);
85 llvm::Constant *MakeConstantString(const std::string &Str, const std::string
86 &Name="");
87 llvm::Constant *MakeGlobal(const llvm::StructType *Ty,
88 std::vector<llvm::Constant*> &V, const std::string &Name="");
89 llvm::Constant *MakeGlobal(const llvm::ArrayType *Ty,
90 std::vector<llvm::Constant*> &V, const std::string &Name="");
Chris Lattnera0fd5ee2008-03-01 08:50:34 +000091public:
Chris Lattner547907c2008-06-26 04:19:03 +000092 CGObjCGNU(CodeGen::CodeGenModule &cgm);
Daniel Dunbardaf4ad42008-08-12 00:12:39 +000093 virtual llvm::Constant *GenerateConstantString(const std::string &String);
Chris Lattnerfaf23db2008-08-08 19:57:58 +000094 virtual llvm::Value *GenerateMessageSend(llvm::IRBuilder<> &Builder,
Chris Lattnera0fd5ee2008-03-01 08:50:34 +000095 const llvm::Type *ReturnTy,
96 llvm::Value *Receiver,
Chris Lattner8384c142008-06-26 04:42:20 +000097 Selector Sel,
Chris Lattnera0fd5ee2008-03-01 08:50:34 +000098 llvm::Value** ArgV,
99 unsigned ArgC);
Chris Lattnerfaf23db2008-08-08 19:57:58 +0000100 virtual llvm::Value *GenerateMessageSendSuper(llvm::IRBuilder<> &Builder,
Chris Lattnerd71288e2008-06-26 04:37:12 +0000101 const llvm::Type *ReturnTy,
Chris Lattnerd71288e2008-06-26 04:37:12 +0000102 const char *SuperClassName,
103 llvm::Value *Receiver,
104 Selector Sel,
105 llvm::Value** ArgV,
106 unsigned ArgC);
Chris Lattnerfaf23db2008-08-08 19:57:58 +0000107 virtual llvm::Value *LookupClass(llvm::IRBuilder<> &Builder,
Chris Lattner8384c142008-06-26 04:42:20 +0000108 llvm::Value *ClassName);
Chris Lattnerfaf23db2008-08-08 19:57:58 +0000109 virtual llvm::Value *GetSelector(llvm::IRBuilder<> &Builder, Selector Sel);
Chris Lattnerd71288e2008-06-26 04:37:12 +0000110
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000111 virtual llvm::Function *MethodPreamble(
112 const std::string &ClassName,
113 const std::string &CategoryName,
114 const std::string &MethodName,
115 const llvm::Type *ReturnTy,
116 const llvm::Type *SelfTy,
117 const llvm::Type **ArgTy,
118 unsigned ArgC,
119 bool isClassMethod,
120 bool isVarArg);
121 virtual void GenerateCategory(const char *ClassName, const char *CategoryName,
Chris Lattner578279d2008-06-26 05:08:00 +0000122 const llvm::SmallVectorImpl<Selector> &InstanceMethodSels,
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000123 const llvm::SmallVectorImpl<llvm::Constant *> &InstanceMethodTypes,
Chris Lattner578279d2008-06-26 05:08:00 +0000124 const llvm::SmallVectorImpl<Selector> &ClassMethodSels,
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000125 const llvm::SmallVectorImpl<llvm::Constant *> &ClassMethodTypes,
126 const llvm::SmallVectorImpl<std::string> &Protocols);
127 virtual void GenerateClass(
128 const char *ClassName,
129 const char *SuperClassName,
130 const int instanceSize,
131 const llvm::SmallVectorImpl<llvm::Constant *> &IvarNames,
132 const llvm::SmallVectorImpl<llvm::Constant *> &IvarTypes,
133 const llvm::SmallVectorImpl<llvm::Constant *> &IvarOffsets,
Chris Lattner578279d2008-06-26 05:08:00 +0000134 const llvm::SmallVectorImpl<Selector> &InstanceMethodSels,
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000135 const llvm::SmallVectorImpl<llvm::Constant *> &InstanceMethodTypes,
Chris Lattner578279d2008-06-26 05:08:00 +0000136 const llvm::SmallVectorImpl<Selector> &ClassMethodSels,
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000137 const llvm::SmallVectorImpl<llvm::Constant *> &ClassMethodTypes,
138 const llvm::SmallVectorImpl<std::string> &Protocols);
Chris Lattnerfaf23db2008-08-08 19:57:58 +0000139 virtual llvm::Value *GenerateProtocolRef(llvm::IRBuilder<> &Builder,
140 const char *ProtocolName);
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000141 virtual void GenerateProtocol(const char *ProtocolName,
142 const llvm::SmallVectorImpl<std::string> &Protocols,
143 const llvm::SmallVectorImpl<llvm::Constant *> &InstanceMethodNames,
144 const llvm::SmallVectorImpl<llvm::Constant *> &InstanceMethodTypes,
145 const llvm::SmallVectorImpl<llvm::Constant *> &ClassMethodNames,
146 const llvm::SmallVectorImpl<llvm::Constant *> &ClassMethodTypes);
147 virtual llvm::Function *ModuleInitFunction();
Chris Lattnera0fd5ee2008-03-01 08:50:34 +0000148};
149} // end anonymous namespace
150
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000151
152
153static std::string SymbolNameForClass(const std::string &ClassName) {
154 return ".objc_class_" + ClassName;
155}
156
157static std::string SymbolNameForMethod(const std::string &ClassName, const
158 std::string &CategoryName, const std::string &MethodName, bool isClassMethod)
159{
160 return "._objc_method_" + ClassName +"("+CategoryName+")"+
161 (isClassMethod ? "+" : "-") + MethodName;
162}
163
Chris Lattner547907c2008-06-26 04:19:03 +0000164CGObjCGNU::CGObjCGNU(CodeGen::CodeGenModule &cgm)
165 : CGM(cgm), TheModule(CGM.getModule()) {
166 IntTy = CGM.getTypes().ConvertType(CGM.getContext().IntTy);
167 LongTy = CGM.getTypes().ConvertType(CGM.getContext().LongTy);
168
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000169 Zeros[0] = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
170 Zeros[1] = Zeros[0];
171 NULLPtr = llvm::ConstantPointerNull::get(
172 llvm::PointerType::getUnqual(llvm::Type::Int8Ty));
Chris Lattnerb326b172008-03-30 23:03:07 +0000173 // C string type. Used in lots of places.
174 PtrToInt8Ty =
175 llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
176 // Get the selector Type.
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000177 SelStructTy = llvm::StructType::get(
Chris Lattnerb326b172008-03-30 23:03:07 +0000178 PtrToInt8Ty,
179 PtrToInt8Ty,
180 NULL);
181 SelectorTy = llvm::PointerType::getUnqual(SelStructTy);
182 PtrToIntTy = llvm::PointerType::getUnqual(IntTy);
183 PtrTy = PtrToInt8Ty;
184
185 // Object type
186 llvm::PATypeHolder OpaqueObjTy = llvm::OpaqueType::get();
187 llvm::Type *OpaqueIdTy = llvm::PointerType::getUnqual(OpaqueObjTy);
188 IdTy = llvm::StructType::get(OpaqueIdTy, NULL);
189 llvm::cast<llvm::OpaqueType>(OpaqueObjTy.get())->refineAbstractTypeTo(IdTy);
190 IdTy = llvm::cast<llvm::StructType>(OpaqueObjTy.get());
191 IdTy = llvm::PointerType::getUnqual(IdTy);
192
193 // IMP type
194 std::vector<const llvm::Type*> IMPArgs;
195 IMPArgs.push_back(IdTy);
196 IMPArgs.push_back(SelectorTy);
197 IMPTy = llvm::FunctionType::get(IdTy, IMPArgs, true);
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000198}
199// This has to perform the lookup every time, since posing and related
200// techniques can modify the name -> class mapping.
Chris Lattnerfaf23db2008-08-08 19:57:58 +0000201llvm::Value *CGObjCGNU::LookupClass(llvm::IRBuilder<> &Builder,
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000202 llvm::Value *ClassName) {
203 llvm::Constant *ClassLookupFn =
204 TheModule.getOrInsertFunction("objc_lookup_class", IdTy, PtrToInt8Ty,
205 NULL);
206 return Builder.CreateCall(ClassLookupFn, ClassName);
Chris Lattnerb326b172008-03-30 23:03:07 +0000207}
208
Chris Lattnerd71288e2008-06-26 04:37:12 +0000209/// GetSelector - Return the pointer to the unique'd string for this selector.
Chris Lattnerfaf23db2008-08-08 19:57:58 +0000210llvm::Value *CGObjCGNU::GetSelector(llvm::IRBuilder<> &Builder, Selector Sel) {
Chris Lattnerd71288e2008-06-26 04:37:12 +0000211 // FIXME: uniquing on the string is wasteful, unique on Sel instead!
212 llvm::GlobalAlias *&US = UntypedSelectors[Sel.getName()];
213 if (US == 0)
214 US = new llvm::GlobalAlias(llvm::PointerType::getUnqual(SelectorTy),
215 llvm::GlobalValue::InternalLinkage,
216 ".objc_untyped_selector_alias",
217 NULL, &TheModule);
218
219 return Builder.CreateLoad(US);
220
221}
222
Chris Lattnera5b18882008-06-26 04:44:19 +0000223llvm::Constant *CGObjCGNU::MakeConstantString(const std::string &Str,
224 const std::string &Name) {
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000225 llvm::Constant * ConstStr = llvm::ConstantArray::get(Str);
226 ConstStr = new llvm::GlobalVariable(ConstStr->getType(), true,
227 llvm::GlobalValue::InternalLinkage,
228 ConstStr, Name, &TheModule);
229 return llvm::ConstantExpr::getGetElementPtr(ConstStr, Zeros, 2);
230}
231llvm::Constant *CGObjCGNU::MakeGlobal(const llvm::StructType *Ty,
232 std::vector<llvm::Constant*> &V, const std::string &Name) {
233 llvm::Constant *C = llvm::ConstantStruct::get(Ty, V);
234 return new llvm::GlobalVariable(Ty, false,
235 llvm::GlobalValue::InternalLinkage, C, Name, &TheModule);
236}
237llvm::Constant *CGObjCGNU::MakeGlobal(const llvm::ArrayType *Ty,
238 std::vector<llvm::Constant*> &V, const std::string &Name) {
239 llvm::Constant *C = llvm::ConstantArray::get(Ty, V);
240 return new llvm::GlobalVariable(Ty, false,
241 llvm::GlobalValue::InternalLinkage, C, Name, &TheModule);
242}
243
244/// Generate an NSConstantString object.
245//TODO: In case there are any crazy people still using the GNU runtime without
246//an OpenStep implementation, this should let them select their own class for
247//constant strings.
Daniel Dunbardaf4ad42008-08-12 00:12:39 +0000248llvm::Constant *CGObjCGNU::GenerateConstantString(const std::string &Str) {
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000249 std::vector<llvm::Constant*> Ivars;
250 Ivars.push_back(NULLPtr);
Chris Lattnerbac12452008-06-21 21:44:18 +0000251 Ivars.push_back(MakeConstantString(Str));
Daniel Dunbardaf4ad42008-08-12 00:12:39 +0000252 Ivars.push_back(llvm::ConstantInt::get(IntTy, Str.size()));
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000253 llvm::Constant *ObjCStr = MakeGlobal(
254 llvm::StructType::get(PtrToInt8Ty, PtrToInt8Ty, IntTy, NULL),
255 Ivars, ".objc_str");
256 ConstantStrings.push_back(
257 llvm::ConstantExpr::getBitCast(ObjCStr, PtrToInt8Ty));
258 return ObjCStr;
259}
260
261///Generates a message send where the super is the receiver. This is a message
262///send to self with special delivery semantics indicating which class's method
263///should be called.
Chris Lattnerfaf23db2008-08-08 19:57:58 +0000264llvm::Value *CGObjCGNU::GenerateMessageSendSuper(llvm::IRBuilder<> &Builder,
Chris Lattnerd71288e2008-06-26 04:37:12 +0000265 const llvm::Type *ReturnTy,
Chris Lattnerd71288e2008-06-26 04:37:12 +0000266 const char *SuperClassName,
267 llvm::Value *Receiver,
268 Selector Sel,
269 llvm::Value** ArgV,
270 unsigned ArgC) {
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000271 // TODO: This should be cached, not looked up every time.
272 llvm::Value *ReceiverClass = LookupClass(Builder,
273 MakeConstantString(SuperClassName));
Chris Lattnerd71288e2008-06-26 04:37:12 +0000274 llvm::Value *cmd = GetSelector(Builder, Sel);
Chris Lattnera0fd5ee2008-03-01 08:50:34 +0000275 std::vector<const llvm::Type*> impArgTypes;
276 impArgTypes.push_back(Receiver->getType());
Chris Lattnerb326b172008-03-30 23:03:07 +0000277 impArgTypes.push_back(SelectorTy);
Chris Lattnera0fd5ee2008-03-01 08:50:34 +0000278
279 // Avoid an explicit cast on the IMP by getting a version that has the right
280 // return type.
281 llvm::FunctionType *impType = llvm::FunctionType::get(ReturnTy, impArgTypes,
282 true);
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000283 // Construct the structure used to look up the IMP
284 llvm::StructType *ObjCSuperTy = llvm::StructType::get(Receiver->getType(),
285 IdTy, NULL);
286 llvm::Value *ObjCSuper = Builder.CreateAlloca(ObjCSuperTy);
Eli Friedman2e630542008-06-13 23:01:12 +0000287 // FIXME: volatility
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000288 Builder.CreateStore(Receiver, Builder.CreateStructGEP(ObjCSuper, 0));
289 Builder.CreateStore(ReceiverClass, Builder.CreateStructGEP(ObjCSuper, 1));
290
291 // Get the IMP
292 llvm::Constant *lookupFunction =
293 TheModule.getOrInsertFunction("objc_msg_lookup_super",
294 llvm::PointerType::getUnqual(impType),
295 llvm::PointerType::getUnqual(ObjCSuperTy),
296 SelectorTy, NULL);
297 llvm::Value *lookupArgs[] = {ObjCSuper, cmd};
298 llvm::Value *imp = Builder.CreateCall(lookupFunction, lookupArgs,
299 lookupArgs+2);
300
301 // Call the method
302 llvm::SmallVector<llvm::Value*, 8> callArgs;
303 callArgs.push_back(Receiver);
304 callArgs.push_back(cmd);
305 callArgs.insert(callArgs.end(), ArgV, ArgV+ArgC);
306 return Builder.CreateCall(imp, callArgs.begin(), callArgs.end());
307}
308
309/// Generate code for a message send expression.
Chris Lattnerfaf23db2008-08-08 19:57:58 +0000310llvm::Value *CGObjCGNU::GenerateMessageSend(llvm::IRBuilder<> &Builder,
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000311 const llvm::Type *ReturnTy,
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000312 llvm::Value *Receiver,
Chris Lattner8384c142008-06-26 04:42:20 +0000313 Selector Sel,
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000314 llvm::Value** ArgV,
315 unsigned ArgC) {
Chris Lattner8384c142008-06-26 04:42:20 +0000316 llvm::Value *cmd = GetSelector(Builder, Sel);
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000317
318 // Look up the method implementation.
319 std::vector<const llvm::Type*> impArgTypes;
320 const llvm::Type *RetTy;
321 //TODO: Revisit this when LLVM supports aggregate return types.
322 if (ReturnTy->isSingleValueType() && ReturnTy != llvm::Type::VoidTy) {
323 RetTy = ReturnTy;
324 } else {
325 // For struct returns allocate the space in the caller and pass it up to
326 // the sender.
327 RetTy = llvm::Type::VoidTy;
328 impArgTypes.push_back(llvm::PointerType::getUnqual(ReturnTy));
329 }
330 impArgTypes.push_back(Receiver->getType());
331 impArgTypes.push_back(SelectorTy);
332
333 // Avoid an explicit cast on the IMP by getting a version that has the right
334 // return type.
335 llvm::FunctionType *impType = llvm::FunctionType::get(RetTy, impArgTypes,
336 true);
Chris Lattnera0fd5ee2008-03-01 08:50:34 +0000337
338 llvm::Constant *lookupFunction =
339 TheModule.getOrInsertFunction("objc_msg_lookup",
Chris Lattnerb326b172008-03-30 23:03:07 +0000340 llvm::PointerType::getUnqual(impType),
341 Receiver->getType(), SelectorTy, NULL);
Chris Lattner7db5e942008-05-06 00:56:42 +0000342 llvm::Value *imp = Builder.CreateCall2(lookupFunction, Receiver, cmd);
343
344 // Call the method.
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000345 llvm::SmallVector<llvm::Value*, 16> Args;
346 if (!ReturnTy->isSingleValueType()) {
347 llvm::Value *Return = Builder.CreateAlloca(ReturnTy);
348 Args.push_back(Return);
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000349 }
350 Args.push_back(Receiver);
351 Args.push_back(cmd);
352 Args.insert(Args.end(), ArgV, ArgV+ArgC);
Chris Lattner6ee20e32008-06-24 17:04:18 +0000353 if (!ReturnTy->isSingleValueType()) {
354 Builder.CreateCall(imp, Args.begin(), Args.end());
355 return Args[0];
356 }
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000357 return Builder.CreateCall(imp, Args.begin(), Args.end());
Chris Lattnera0fd5ee2008-03-01 08:50:34 +0000358}
359
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000360/// Generates a MethodList. Used in construction of a objc_class and
361/// objc_category structures.
362llvm::Constant *CGObjCGNU::GenerateMethodList(const std::string &ClassName,
Chris Lattner578279d2008-06-26 05:08:00 +0000363 const std::string &CategoryName,
364 const llvm::SmallVectorImpl<Selector> &MethodSels,
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000365 const llvm::SmallVectorImpl<llvm::Constant *> &MethodTypes,
366 bool isClassMethodList) {
367 // Get the method structure type.
368 llvm::StructType *ObjCMethodTy = llvm::StructType::get(
369 PtrToInt8Ty, // Really a selector, but the runtime creates it us.
370 PtrToInt8Ty, // Method types
371 llvm::PointerType::getUnqual(IMPTy), //Method pointer
372 NULL);
373 std::vector<llvm::Constant*> Methods;
374 std::vector<llvm::Constant*> Elements;
375 for (unsigned int i = 0, e = MethodTypes.size(); i < e; ++i) {
376 Elements.clear();
Chris Lattner578279d2008-06-26 05:08:00 +0000377 llvm::Constant *C = CGM.GetAddrOfConstantString(MethodSels[i].getName());
378 Elements.push_back(llvm::ConstantExpr::getGetElementPtr(C, Zeros, 2));
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000379 Elements.push_back(
380 llvm::ConstantExpr::getGetElementPtr(MethodTypes[i], Zeros, 2));
381 llvm::Constant *Method =
382 TheModule.getFunction(SymbolNameForMethod(ClassName, CategoryName,
Chris Lattner578279d2008-06-26 05:08:00 +0000383 MethodSels[i].getName(),
Chris Lattnere7581092008-06-26 04:05:20 +0000384 isClassMethodList));
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000385 Method = llvm::ConstantExpr::getBitCast(Method,
386 llvm::PointerType::getUnqual(IMPTy));
387 Elements.push_back(Method);
388 Methods.push_back(llvm::ConstantStruct::get(ObjCMethodTy, Elements));
389 }
390
391 // Array of method structures
392 llvm::ArrayType *ObjCMethodArrayTy = llvm::ArrayType::get(ObjCMethodTy,
Chris Lattner578279d2008-06-26 05:08:00 +0000393 MethodSels.size());
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000394 llvm::Constant *MethodArray = llvm::ConstantArray::get(ObjCMethodArrayTy,
Chris Lattnerbcb3e862008-06-26 04:52:29 +0000395 Methods);
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000396
397 // Structure containing list pointer, array and array count
398 llvm::SmallVector<const llvm::Type*, 16> ObjCMethodListFields;
399 llvm::PATypeHolder OpaqueNextTy = llvm::OpaqueType::get();
400 llvm::Type *NextPtrTy = llvm::PointerType::getUnqual(OpaqueNextTy);
401 llvm::StructType *ObjCMethodListTy = llvm::StructType::get(NextPtrTy,
402 IntTy,
403 ObjCMethodArrayTy,
404 NULL);
405 // Refine next pointer type to concrete type
406 llvm::cast<llvm::OpaqueType>(
407 OpaqueNextTy.get())->refineAbstractTypeTo(ObjCMethodListTy);
408 ObjCMethodListTy = llvm::cast<llvm::StructType>(OpaqueNextTy.get());
409
410 Methods.clear();
411 Methods.push_back(llvm::ConstantPointerNull::get(
412 llvm::PointerType::getUnqual(ObjCMethodListTy)));
413 Methods.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty,
414 MethodTypes.size()));
415 Methods.push_back(MethodArray);
416
417 // Create an instance of the structure
418 return MakeGlobal(ObjCMethodListTy, Methods, ".objc_method_list");
419}
420
421/// Generates an IvarList. Used in construction of a objc_class.
422llvm::Constant *CGObjCGNU::GenerateIvarList(
423 const llvm::SmallVectorImpl<llvm::Constant *> &IvarNames,
424 const llvm::SmallVectorImpl<llvm::Constant *> &IvarTypes,
425 const llvm::SmallVectorImpl<llvm::Constant *> &IvarOffsets) {
426 // Get the method structure type.
427 llvm::StructType *ObjCIvarTy = llvm::StructType::get(
428 PtrToInt8Ty,
429 PtrToInt8Ty,
430 IntTy,
431 NULL);
432 std::vector<llvm::Constant*> Ivars;
433 std::vector<llvm::Constant*> Elements;
434 for (unsigned int i = 0, e = IvarNames.size() ; i < e ; i++) {
435 Elements.clear();
436 Elements.push_back( llvm::ConstantExpr::getGetElementPtr(IvarNames[i],
437 Zeros, 2));
438 Elements.push_back( llvm::ConstantExpr::getGetElementPtr(IvarTypes[i],
439 Zeros, 2));
440 Elements.push_back(IvarOffsets[i]);
441 Ivars.push_back(llvm::ConstantStruct::get(ObjCIvarTy, Elements));
442 }
443
444 // Array of method structures
445 llvm::ArrayType *ObjCIvarArrayTy = llvm::ArrayType::get(ObjCIvarTy,
446 IvarNames.size());
447
448
449 Elements.clear();
450 Elements.push_back(llvm::ConstantInt::get(
451 llvm::cast<llvm::IntegerType>(IntTy), (int)IvarNames.size()));
452 Elements.push_back(llvm::ConstantArray::get(ObjCIvarArrayTy, Ivars));
453 // Structure containing array and array count
454 llvm::StructType *ObjCIvarListTy = llvm::StructType::get(IntTy,
455 ObjCIvarArrayTy,
456 NULL);
457
458 // Create an instance of the structure
459 return MakeGlobal(ObjCIvarListTy, Elements, ".objc_ivar_list");
460}
461
462/// Generate a class structure
463llvm::Constant *CGObjCGNU::GenerateClassStructure(
464 llvm::Constant *MetaClass,
465 llvm::Constant *SuperClass,
466 unsigned info,
Chris Lattnerad9c3f32008-06-26 04:47:04 +0000467 const char *Name,
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000468 llvm::Constant *Version,
469 llvm::Constant *InstanceSize,
470 llvm::Constant *IVars,
471 llvm::Constant *Methods,
472 llvm::Constant *Protocols) {
473 // Set up the class structure
474 // Note: Several of these are char*s when they should be ids. This is
475 // because the runtime performs this translation on load.
476 llvm::StructType *ClassTy = llvm::StructType::get(
477 PtrToInt8Ty, // class_pointer
478 PtrToInt8Ty, // super_class
479 PtrToInt8Ty, // name
480 LongTy, // version
481 LongTy, // info
482 LongTy, // instance_size
483 IVars->getType(), // ivars
484 Methods->getType(), // methods
485 // These are all filled in by the runtime, so we pretend
486 PtrTy, // dtable
487 PtrTy, // subclass_list
488 PtrTy, // sibling_class
489 PtrTy, // protocols
490 PtrTy, // gc_object_type
491 NULL);
492 llvm::Constant *Zero = llvm::ConstantInt::get(LongTy, 0);
493 llvm::Constant *NullP =
494 llvm::ConstantPointerNull::get(llvm::cast<llvm::PointerType>(PtrTy));
495 // Fill in the structure
496 std::vector<llvm::Constant*> Elements;
497 Elements.push_back(llvm::ConstantExpr::getBitCast(MetaClass, PtrToInt8Ty));
498 Elements.push_back(SuperClass);
Chris Lattnerad9c3f32008-06-26 04:47:04 +0000499 Elements.push_back(MakeConstantString(Name, ".class_name"));
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000500 Elements.push_back(Zero);
501 Elements.push_back(llvm::ConstantInt::get(LongTy, info));
502 Elements.push_back(InstanceSize);
503 Elements.push_back(IVars);
504 Elements.push_back(Methods);
505 Elements.push_back(NullP);
506 Elements.push_back(NullP);
507 Elements.push_back(NullP);
508 Elements.push_back(llvm::ConstantExpr::getBitCast(Protocols, PtrTy));
509 Elements.push_back(NullP);
510 // Create an instance of the structure
Chris Lattner4d018542008-07-21 06:31:05 +0000511 return MakeGlobal(ClassTy, Elements, SymbolNameForClass(Name));
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000512}
513
514llvm::Constant *CGObjCGNU::GenerateProtocolMethodList(
515 const llvm::SmallVectorImpl<llvm::Constant *> &MethodNames,
516 const llvm::SmallVectorImpl<llvm::Constant *> &MethodTypes) {
517 // Get the method structure type.
518 llvm::StructType *ObjCMethodDescTy = llvm::StructType::get(
519 PtrToInt8Ty, // Really a selector, but the runtime does the casting for us.
520 PtrToInt8Ty,
521 NULL);
522 std::vector<llvm::Constant*> Methods;
523 std::vector<llvm::Constant*> Elements;
524 for (unsigned int i = 0, e = MethodTypes.size() ; i < e ; i++) {
525 Elements.clear();
526 Elements.push_back( llvm::ConstantExpr::getGetElementPtr(MethodNames[i],
527 Zeros, 2));
528 Elements.push_back(
529 llvm::ConstantExpr::getGetElementPtr(MethodTypes[i], Zeros, 2));
530 Methods.push_back(llvm::ConstantStruct::get(ObjCMethodDescTy, Elements));
531 }
532 llvm::ArrayType *ObjCMethodArrayTy = llvm::ArrayType::get(ObjCMethodDescTy,
533 MethodNames.size());
534 llvm::Constant *Array = llvm::ConstantArray::get(ObjCMethodArrayTy, Methods);
535 llvm::StructType *ObjCMethodDescListTy = llvm::StructType::get(
536 IntTy, ObjCMethodArrayTy, NULL);
537 Methods.clear();
538 Methods.push_back(llvm::ConstantInt::get(IntTy, MethodNames.size()));
539 Methods.push_back(Array);
540 return MakeGlobal(ObjCMethodDescListTy, Methods, ".objc_method_list");
541}
542// Create the protocol list structure used in classes, categories and so on
543llvm::Constant *CGObjCGNU::GenerateProtocolList(
544 const llvm::SmallVectorImpl<std::string> &Protocols) {
545 llvm::ArrayType *ProtocolArrayTy = llvm::ArrayType::get(PtrToInt8Ty,
546 Protocols.size());
547 llvm::StructType *ProtocolListTy = llvm::StructType::get(
548 PtrTy, //Should be a recurisve pointer, but it's always NULL here.
549 LongTy,//FIXME: Should be size_t
550 ProtocolArrayTy,
551 NULL);
552 std::vector<llvm::Constant*> Elements;
553 for (const std::string *iter = Protocols.begin(), *endIter = Protocols.end();
554 iter != endIter ; iter++) {
555 llvm::Constant *Ptr =
556 llvm::ConstantExpr::getBitCast(ExistingProtocols[*iter], PtrToInt8Ty);
557 Elements.push_back(Ptr);
558 }
559 llvm::Constant * ProtocolArray = llvm::ConstantArray::get(ProtocolArrayTy,
560 Elements);
561 Elements.clear();
562 Elements.push_back(NULLPtr);
563 Elements.push_back(llvm::ConstantInt::get(
564 llvm::cast<llvm::IntegerType>(LongTy), Protocols.size()));
565 Elements.push_back(ProtocolArray);
566 return MakeGlobal(ProtocolListTy, Elements, ".objc_protocol_list");
567}
568
Chris Lattnerfaf23db2008-08-08 19:57:58 +0000569llvm::Value *CGObjCGNU::GenerateProtocolRef(llvm::IRBuilder<> &Builder, const
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000570 char *ProtocolName) {
571 return ExistingProtocols[ProtocolName];
572}
573
574void CGObjCGNU::GenerateProtocol(const char *ProtocolName,
575 const llvm::SmallVectorImpl<std::string> &Protocols,
576 const llvm::SmallVectorImpl<llvm::Constant *> &InstanceMethodNames,
577 const llvm::SmallVectorImpl<llvm::Constant *> &InstanceMethodTypes,
578 const llvm::SmallVectorImpl<llvm::Constant *> &ClassMethodNames,
579 const llvm::SmallVectorImpl<llvm::Constant *> &ClassMethodTypes) {
580
581 llvm::Constant *ProtocolList = GenerateProtocolList(Protocols);
582 llvm::Constant *InstanceMethodList =
583 GenerateProtocolMethodList(InstanceMethodNames, InstanceMethodTypes);
584 llvm::Constant *ClassMethodList =
585 GenerateProtocolMethodList(ClassMethodNames, ClassMethodTypes);
586 // Protocols are objects containing lists of the methods implemented and
587 // protocols adopted.
588 llvm::StructType *ProtocolTy = llvm::StructType::get(IdTy,
589 PtrToInt8Ty,
590 ProtocolList->getType(),
591 InstanceMethodList->getType(),
592 ClassMethodList->getType(),
593 NULL);
594 std::vector<llvm::Constant*> Elements;
595 // The isa pointer must be set to a magic number so the runtime knows it's
596 // the correct layout.
597 Elements.push_back(llvm::ConstantExpr::getIntToPtr(
598 llvm::ConstantInt::get(llvm::Type::Int32Ty, ProtocolVersion), IdTy));
599 Elements.push_back(MakeConstantString(ProtocolName, ".objc_protocol_name"));
600 Elements.push_back(ProtocolList);
601 Elements.push_back(InstanceMethodList);
602 Elements.push_back(ClassMethodList);
603 ExistingProtocols[ProtocolName] =
604 llvm::ConstantExpr::getBitCast(MakeGlobal(ProtocolTy, Elements,
605 ".objc_protocol"), IdTy);
606}
607
608void CGObjCGNU::GenerateCategory(
609 const char *ClassName,
610 const char *CategoryName,
Chris Lattner578279d2008-06-26 05:08:00 +0000611 const llvm::SmallVectorImpl<Selector> &InstanceMethodSels,
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000612 const llvm::SmallVectorImpl<llvm::Constant *> &InstanceMethodTypes,
Chris Lattner578279d2008-06-26 05:08:00 +0000613 const llvm::SmallVectorImpl<Selector> &ClassMethodSels,
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000614 const llvm::SmallVectorImpl<llvm::Constant *> &ClassMethodTypes,
615 const llvm::SmallVectorImpl<std::string> &Protocols) {
616 std::vector<llvm::Constant*> Elements;
617 Elements.push_back(MakeConstantString(CategoryName));
618 Elements.push_back(MakeConstantString(ClassName));
619 // Instance method list
620 Elements.push_back(llvm::ConstantExpr::getBitCast(GenerateMethodList(
Chris Lattner578279d2008-06-26 05:08:00 +0000621 ClassName, CategoryName, InstanceMethodSels, InstanceMethodTypes,
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000622 false), PtrTy));
623 // Class method list
624 Elements.push_back(llvm::ConstantExpr::getBitCast(GenerateMethodList(
Chris Lattner578279d2008-06-26 05:08:00 +0000625 ClassName, CategoryName, ClassMethodSels, ClassMethodTypes, true),
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000626 PtrTy));
627 // Protocol list
628 Elements.push_back(llvm::ConstantExpr::getBitCast(
629 GenerateProtocolList(Protocols), PtrTy));
630 Categories.push_back(llvm::ConstantExpr::getBitCast(
631 MakeGlobal(llvm::StructType::get(PtrToInt8Ty, PtrToInt8Ty, PtrTy,
632 PtrTy, PtrTy, NULL), Elements), PtrTy));
633}
634void CGObjCGNU::GenerateClass(
635 const char *ClassName,
636 const char *SuperClassName,
637 const int instanceSize,
638 const llvm::SmallVectorImpl<llvm::Constant *> &IvarNames,
639 const llvm::SmallVectorImpl<llvm::Constant *> &IvarTypes,
640 const llvm::SmallVectorImpl<llvm::Constant *> &IvarOffsets,
Chris Lattner578279d2008-06-26 05:08:00 +0000641 const llvm::SmallVectorImpl<Selector> &InstanceMethodSels,
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000642 const llvm::SmallVectorImpl<llvm::Constant *> &InstanceMethodTypes,
Chris Lattner578279d2008-06-26 05:08:00 +0000643 const llvm::SmallVectorImpl<Selector> &ClassMethodSels,
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000644 const llvm::SmallVectorImpl<llvm::Constant *> &ClassMethodTypes,
645 const llvm::SmallVectorImpl<std::string> &Protocols) {
646 // Get the superclass pointer.
647 llvm::Constant *SuperClass;
648 if (SuperClassName) {
649 SuperClass = MakeConstantString(SuperClassName, ".super_class_name");
650 } else {
651 SuperClass = llvm::ConstantPointerNull::get(
652 llvm::cast<llvm::PointerType>(PtrToInt8Ty));
653 }
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000654 // Empty vector used to construct empty method lists
655 llvm::SmallVector<llvm::Constant*, 1> empty;
656 // Generate the method and instance variable lists
657 llvm::Constant *MethodList = GenerateMethodList(ClassName, "",
Chris Lattner578279d2008-06-26 05:08:00 +0000658 InstanceMethodSels, InstanceMethodTypes, false);
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000659 llvm::Constant *ClassMethodList = GenerateMethodList(ClassName, "",
Chris Lattner578279d2008-06-26 05:08:00 +0000660 ClassMethodSels, ClassMethodTypes, true);
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000661 llvm::Constant *IvarList = GenerateIvarList(IvarNames, IvarTypes,
662 IvarOffsets);
663 //Generate metaclass for class methods
664 llvm::Constant *MetaClassStruct = GenerateClassStructure(NULLPtr,
Chris Lattner4d018542008-07-21 06:31:05 +0000665 NULLPtr, 0x2L, /*name*/"", 0, Zeros[0], GenerateIvarList(
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000666 empty, empty, empty), ClassMethodList, NULLPtr);
667 // Generate the class structure
668 llvm::Constant *ClassStruct = GenerateClassStructure(MetaClassStruct,
Chris Lattnerad9c3f32008-06-26 04:47:04 +0000669 SuperClass, 0x1L, ClassName, 0,
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000670 llvm::ConstantInt::get(llvm::Type::Int32Ty, instanceSize), IvarList,
671 MethodList, GenerateProtocolList(Protocols));
672 // Add class structure to list to be added to the symtab later
673 ClassStruct = llvm::ConstantExpr::getBitCast(ClassStruct, PtrToInt8Ty);
674 Classes.push_back(ClassStruct);
675}
676
677llvm::Function *CGObjCGNU::ModuleInitFunction() {
678 // Only emit an ObjC load function if no Objective-C stuff has been called
679 if (Classes.empty() && Categories.empty() && ConstantStrings.empty() &&
680 ExistingProtocols.empty() && TypedSelectors.empty() &&
Anton Korobeynikovb41e4972008-06-01 15:14:46 +0000681 UntypedSelectors.empty())
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000682 return NULL;
Eli Friedman7719bc82008-06-01 16:00:02 +0000683
684 // Name the ObjC types to make the IR a bit easier to read
685 TheModule.addTypeName(".objc_selector", SelectorTy);
686 TheModule.addTypeName(".objc_id", IdTy);
687 TheModule.addTypeName(".objc_imp", IMPTy);
688
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000689 std::vector<llvm::Constant*> Elements;
690 // Generate statics list:
691 llvm::ArrayType *StaticsArrayTy = llvm::ArrayType::get(PtrToInt8Ty,
692 ConstantStrings.size() + 1);
693 ConstantStrings.push_back(NULLPtr);
694 Elements.push_back(MakeConstantString("NSConstantString",
695 ".objc_static_class_name"));
696 Elements.push_back(llvm::ConstantArray::get(StaticsArrayTy, ConstantStrings));
697 llvm::StructType *StaticsListTy =
698 llvm::StructType::get(PtrToInt8Ty, StaticsArrayTy, NULL);
Chris Lattneref843042008-06-26 04:10:42 +0000699 llvm::Type *StaticsListPtrTy = llvm::PointerType::getUnqual(StaticsListTy);
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000700 llvm::Constant *Statics =
701 MakeGlobal(StaticsListTy, Elements, ".objc_statics");
Chris Lattner60eaae82008-06-24 17:01:28 +0000702 llvm::ArrayType *StaticsListArrayTy =
Chris Lattneref843042008-06-26 04:10:42 +0000703 llvm::ArrayType::get(StaticsListPtrTy, 2);
Chris Lattner60eaae82008-06-24 17:01:28 +0000704 Elements.clear();
705 Elements.push_back(Statics);
Chris Lattneref843042008-06-26 04:10:42 +0000706 Elements.push_back(llvm::Constant::getNullValue(StaticsListPtrTy));
Chris Lattner60eaae82008-06-24 17:01:28 +0000707 Statics = MakeGlobal(StaticsListArrayTy, Elements, ".objc_statics_ptr");
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000708 Statics = llvm::ConstantExpr::getBitCast(Statics, PtrTy);
709 // Array of classes, categories, and constant objects
710 llvm::ArrayType *ClassListTy = llvm::ArrayType::get(PtrToInt8Ty,
711 Classes.size() + Categories.size() + 2);
Chris Lattneref843042008-06-26 04:10:42 +0000712 llvm::StructType *SymTabTy = llvm::StructType::get(LongTy, SelectorTy,
713 llvm::Type::Int16Ty,
714 llvm::Type::Int16Ty,
715 ClassListTy, NULL);
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000716
717 Elements.clear();
718 // Pointer to an array of selectors used in this module.
719 std::vector<llvm::Constant*> Selectors;
720 for (std::map<TypedSelector, llvm::GlobalAlias*>::iterator
721 iter = TypedSelectors.begin(), iterEnd = TypedSelectors.end();
722 iter != iterEnd ; ++iter) {
Chris Lattneref843042008-06-26 04:10:42 +0000723 Elements.push_back(MakeConstantString(iter->first.first, ".objc_sel_name"));
724 Elements.push_back(MakeConstantString(iter->first.second,
725 ".objc_sel_types"));
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000726 Selectors.push_back(llvm::ConstantStruct::get(SelStructTy, Elements));
727 Elements.clear();
728 }
729 for (llvm::StringMap<llvm::GlobalAlias*>::iterator
730 iter = UntypedSelectors.begin(), iterEnd = UntypedSelectors.end();
Chris Lattneref843042008-06-26 04:10:42 +0000731 iter != iterEnd; ++iter) {
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000732 Elements.push_back(
Chris Lattneref843042008-06-26 04:10:42 +0000733 MakeConstantString(iter->getKeyData(), ".objc_sel_name"));
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000734 Elements.push_back(NULLPtr);
735 Selectors.push_back(llvm::ConstantStruct::get(SelStructTy, Elements));
736 Elements.clear();
737 }
738 Elements.push_back(NULLPtr);
739 Elements.push_back(NULLPtr);
740 Selectors.push_back(llvm::ConstantStruct::get(SelStructTy, Elements));
741 Elements.clear();
742 // Number of static selectors
743 Elements.push_back(llvm::ConstantInt::get(LongTy, Selectors.size() ));
744 llvm::Constant *SelectorList = MakeGlobal(
745 llvm::ArrayType::get(SelStructTy, Selectors.size()), Selectors,
746 ".objc_selector_list");
747 Elements.push_back(llvm::ConstantExpr::getBitCast(SelectorList, SelectorTy));
748
749 // Now that all of the static selectors exist, create pointers to them.
750 int index = 0;
751 for (std::map<TypedSelector, llvm::GlobalAlias*>::iterator
752 iter=TypedSelectors.begin(), iterEnd =TypedSelectors.end();
753 iter != iterEnd; ++iter) {
754 llvm::Constant *Idxs[] = {Zeros[0],
755 llvm::ConstantInt::get(llvm::Type::Int32Ty, index++), Zeros[0]};
756 llvm::GlobalVariable *SelPtr = new llvm::GlobalVariable(SelectorTy, true,
757 llvm::GlobalValue::InternalLinkage,
758 llvm::ConstantExpr::getGetElementPtr(SelectorList, Idxs, 2),
759 ".objc_sel_ptr", &TheModule);
760 (*iter).second->setAliasee(SelPtr);
761 }
762 for (llvm::StringMap<llvm::GlobalAlias*>::iterator
763 iter=UntypedSelectors.begin(), iterEnd = UntypedSelectors.end();
764 iter != iterEnd; iter++) {
765 llvm::Constant *Idxs[] = {Zeros[0],
766 llvm::ConstantInt::get(llvm::Type::Int32Ty, index++), Zeros[0]};
767 llvm::GlobalVariable *SelPtr = new llvm::GlobalVariable(SelectorTy, true,
768 llvm::GlobalValue::InternalLinkage,
769 llvm::ConstantExpr::getGetElementPtr(SelectorList, Idxs, 2),
770 ".objc_sel_ptr", &TheModule);
771 (*iter).second->setAliasee(SelPtr);
772 }
773 // Number of classes defined.
774 Elements.push_back(llvm::ConstantInt::get(llvm::Type::Int16Ty,
775 Classes.size()));
776 // Number of categories defined
777 Elements.push_back(llvm::ConstantInt::get(llvm::Type::Int16Ty,
778 Categories.size()));
779 // Create an array of classes, then categories, then static object instances
780 Classes.insert(Classes.end(), Categories.begin(), Categories.end());
781 // NULL-terminated list of static object instances (mainly constant strings)
782 Classes.push_back(Statics);
783 Classes.push_back(NULLPtr);
784 llvm::Constant *ClassList = llvm::ConstantArray::get(ClassListTy, Classes);
785 Elements.push_back(ClassList);
786 // Construct the symbol table
787 llvm::Constant *SymTab= MakeGlobal(SymTabTy, Elements);
788
789 // The symbol table is contained in a module which has some version-checking
790 // constants
791 llvm::StructType * ModuleTy = llvm::StructType::get(LongTy, LongTy,
792 PtrToInt8Ty, llvm::PointerType::getUnqual(SymTabTy), NULL);
793 Elements.clear();
794 // Runtime version used for compatibility checking.
795 Elements.push_back(llvm::ConstantInt::get(LongTy, RuntimeVersion));
796 //FIXME: Should be sizeof(ModuleTy)
797 Elements.push_back(llvm::ConstantInt::get(LongTy, 16));
798 //FIXME: Should be the path to the file where this module was declared
799 Elements.push_back(NULLPtr);
800 Elements.push_back(SymTab);
801 llvm::Value *Module = MakeGlobal(ModuleTy, Elements);
802
803 // Create the load function calling the runtime entry point with the module
804 // structure
805 std::vector<const llvm::Type*> VoidArgs;
806 llvm::Function * LoadFunction = llvm::Function::Create(
807 llvm::FunctionType::get(llvm::Type::VoidTy, VoidArgs, false),
808 llvm::GlobalValue::InternalLinkage, ".objc_load_function",
809 &TheModule);
810 llvm::BasicBlock *EntryBB = llvm::BasicBlock::Create("entry", LoadFunction);
Chris Lattnerfaf23db2008-08-08 19:57:58 +0000811 llvm::IRBuilder<> Builder;
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000812 Builder.SetInsertPoint(EntryBB);
813 llvm::Value *Register = TheModule.getOrInsertFunction("__objc_exec_class",
814 llvm::Type::VoidTy, llvm::PointerType::getUnqual(ModuleTy), NULL);
815 Builder.CreateCall(Register, Module);
816 Builder.CreateRetVoid();
817 return LoadFunction;
818}
Chris Lattnerb326b172008-03-30 23:03:07 +0000819llvm::Function *CGObjCGNU::MethodPreamble(
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000820 const std::string &ClassName,
821 const std::string &CategoryName,
822 const std::string &MethodName,
Chris Lattnerb326b172008-03-30 23:03:07 +0000823 const llvm::Type *ReturnTy,
824 const llvm::Type *SelfTy,
825 const llvm::Type **ArgTy,
826 unsigned ArgC,
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000827 bool isClassMethod,
Chris Lattnerb326b172008-03-30 23:03:07 +0000828 bool isVarArg) {
829 std::vector<const llvm::Type*> Args;
Chris Lattner6ee20e32008-06-24 17:04:18 +0000830 if (!ReturnTy->isSingleValueType() && ReturnTy != llvm::Type::VoidTy) {
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000831 Args.push_back(llvm::PointerType::getUnqual(ReturnTy));
832 ReturnTy = llvm::Type::VoidTy;
833 }
Chris Lattnerb326b172008-03-30 23:03:07 +0000834 Args.push_back(SelfTy);
835 Args.push_back(SelectorTy);
836 Args.insert(Args.end(), ArgTy, ArgTy+ArgC);
837
838 llvm::FunctionType *MethodTy = llvm::FunctionType::get(ReturnTy,
839 Args,
840 isVarArg);
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000841 std::string FunctionName = SymbolNameForMethod(ClassName, CategoryName,
842 MethodName, isClassMethod);
843
Gabor Greif815e2c12008-04-06 20:42:52 +0000844 llvm::Function *Method = llvm::Function::Create(MethodTy,
Chris Lattnerb326b172008-03-30 23:03:07 +0000845 llvm::GlobalValue::InternalLinkage,
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000846 FunctionName,
Chris Lattnerb326b172008-03-30 23:03:07 +0000847 &TheModule);
Chris Lattnerb326b172008-03-30 23:03:07 +0000848 llvm::Function::arg_iterator AI = Method->arg_begin();
Anton Korobeynikovcd5d08d2008-06-01 14:13:53 +0000849 // Name the struct return argument.
850 // FIXME: This is probably the wrong test.
851 if (!ReturnTy->isFirstClassType() && ReturnTy != llvm::Type::VoidTy) {
852 AI->setName("agg.result");
853 ++AI;
854 }
Chris Lattnerb326b172008-03-30 23:03:07 +0000855 AI->setName("self");
856 ++AI;
857 AI->setName("_cmd");
858 return Method;
859}
860
Daniel Dunbar8c85fac2008-08-11 02:45:11 +0000861CodeGen::CGObjCRuntime *CodeGen::CreateGNUObjCRuntime(CodeGen::CodeGenModule &CGM){
Chris Lattner547907c2008-06-26 04:19:03 +0000862 return new CGObjCGNU(CGM);
Chris Lattnera0fd5ee2008-03-01 08:50:34 +0000863}