[ObjC] type method metadata `_imp`, messenger routine at callsite with program address space

[mhjacobson]

Summary

On targets with non-default program address space (e.g., Harvard architectures), clang crashes (example backtrace below) when emitting Objective-C method metadata, because the address of the method IMP cannot be bitcast to i8*. It similarly crashes at messenger callsite with a failed bitcast.

Define the _imp field instead as i8 addrspace(1)* (or whatever the target's program address space is). And in getMessageSendInfo(), create signatureType by specifying the program address space.

Add a regression test using the AVR target. Test failed previously and passes now. Checked codegen of the test for x86_64-apple-darwin19.6.0 and saw no difference, as expected.

Backtrace (when emitting method metadata):

Assertion failed: (CastInst::castIsValid(Instruction::BitCast, C, DstTy) && "Invalid constantexpr bitcast!"), function getBitCast, file /Users/matt/src/llvm/llvm/lib/IR/Constants.cpp, line 2224.

...

7  libsystem_c.dylib        0x00007fff6ec09ac6 err + 0
8  clang-14                 0x0000000101800518 llvm::ConstantExpr::getBitCast(llvm::Constant*, llvm::Type*, bool) + 120
9  clang-14                 0x000000010394ca70 clang::CodeGen::ConstantAggregateBuilderBase::addBitCast(llvm::Constant*, llvm::Type*) + 48
10 clang-14                 0x0000000103999ac2 (anonymous namespace)::CGObjCNonFragileABIMac::emitMethodConstant(clang::CodeGen::ConstantArrayBuilder&, clang::ObjCMethodDecl const*, bool) + 402
11 clang-14                 0x0000000103999102 (anonymous namespace)::CGObjCNonFragileABIMac::emitMethodList(llvm::Twine, (anonymous namespace)::(anonymous namespace)::MethodListType, llvm::ArrayRef<clang::ObjCMethodDecl const*>) + 1074
12 clang-14                 0x000000010399a4c0 (anonymous namespace)::CGObjCNonFragileABIMac::BuildClassRoTInitializer(unsigned int, unsigned int, unsigned int, clang::ObjCImplementationDecl const*) + 1376
13 clang-14                 0x0000000103990b9b (anonymous namespace)::CGObjCNonFragileABIMac::GenerateClass(clang::ObjCImplementationDecl const*) + 1995
14 clang-14                 0x0000000103bb87d1 clang::CodeGen::CodeGenModule::EmitTopLevelDecl(clang::Decl*) + 2065
15 clang-14                 0x0000000103db5bf2 (anonymous namespace)::CodeGeneratorImpl::HandleTopLevelDecl(clang::DeclGroupRef) + 146
16 clang-14                 0x0000000103b61014 clang::BackendConsumer::HandleTopLevelDecl(clang::DeclGroupRef) + 228
17 clang-14                 0x00000001070d7425 clang::ParseAST(clang::Sema&, bool, bool) + 533

[mhjacobson]

Ping. Is there anyone more suited to reviewing this patch?

[dylanmckay]

LGTM, nice work.

[rjmccall]

Well, I don't envy you the amount of work you're going to have to do to get ObjC working on a Harvard architecture, but this patch LGTM as progress.

Is AVR really going to be using the Darwin ObjC runtime, though? Are you planning to fork an Apple source drop?

[mhjacobson]

Well, I'm hoping it doesn't prove to be too much work. 🙂 With this fix and D112049, most things are working quite well, though I'm sure I'll uncover more interesting things as I go.

As for the runtime, I've built my own: https://github.com/mhjacobson/avr-objc. It conforms to the Mac OS X non-fragile-ivars ABI.

By the way, I don't have write privs to LLVM, so assuming this is good to go, could someone commit this for me? Thanks for all your help!

[mhjacobson]

Happy new year! If this change is acceptable, could someone please merge it for me? (And if not, could someone point out what needs more work?) Thanks for your help!

clang/lib/CodeGen/CGObjCMac.cpp

private:
   }
 
 protected:
   CodeGen::CodeGenModule &CGM;
 
 public:
   llvm::IntegerType *ShortTy, *IntTy, *LongTy;
   llvm::PointerType *Int8PtrTy, *Int8PtrPtrTy;
+  llvm::PointerType *Int8PtrProgramASTy;
   llvm::Type *IvarOffsetVarTy;
 
   /// ObjectPtrTy - LLVM type for object handles (typeof(id))
   llvm::PointerType *ObjectPtrTy;
 
   /// PtrObjectPtrTy - LLVM type for id *
   llvm::PointerType *PtrObjectPtrTy;
 

 
 /* *** */
 
 ObjCCommonTypesHelper::ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm)
   : VMContext(cgm.getLLVMContext()), CGM(cgm), ExternalProtocolPtrTy(nullptr)
 {
   CodeGen::CodeGenTypes &Types = CGM.getTypes();
   ASTContext &Ctx = CGM.getContext();
+  unsigned ProgramAS = CGM.getDataLayout().getProgramAddressSpace();
 
   ShortTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.ShortTy));
   IntTy = CGM.IntTy;
   LongTy = cast<llvm::IntegerType>(Types.ConvertType(Ctx.LongTy));
   Int8PtrTy = CGM.Int8PtrTy;
+  Int8PtrProgramASTy = llvm::PointerType::get(CGM.Int8Ty, ProgramAS);
   Int8PtrPtrTy = CGM.Int8PtrPtrTy;
 
   // arm64 targets use "int" ivar offset variables. All others,
   // including OS X x86_64 and Windows x86_64, use "long" ivar offsets.
   if (CGM.getTarget().getTriple().getArch() == llvm::Triple::aarch64)
     IvarOffsetVarTy = IntTy;
   else
     IvarOffsetVarTy = LongTy;
ObjCCommonTypesHelper::ObjCCommonTypesHelper(CodeGen::CodeGenModule &cgm)
   PropertyListPtrTy = llvm::PointerType::getUnqual(PropertyListTy);
 
   // struct _objc_method {
   //   SEL _cmd;
   //   char *method_type;
   //   char *_imp;
   // }
   MethodTy = llvm::StructType::create("struct._objc_method", SelectorPtrTy,
-                                      Int8PtrTy, Int8PtrTy);
+                                      Int8PtrTy, Int8PtrProgramASTy);
 
   // struct _objc_cache *
   CacheTy = llvm::StructType::create(VMContext, "struct._objc_cache");
   CachePtrTy = llvm::PointerType::getUnqual(CacheTy);
 }
 
 ObjCTypesHelper::ObjCTypesHelper(CodeGen::CodeGenModule &cgm)
   : ObjCCommonTypesHelper(cgm) {
void CGObjCNonFragileABIMac::emitMethodConstant(ConstantArrayBuilder &builder,
                                                 bool forProtocol) {
   auto method = builder.beginStruct(ObjCTypes.MethodTy);
   method.addBitCast(GetMethodVarName(MD->getSelector()),
                     ObjCTypes.SelectorPtrTy);
   method.add(GetMethodVarType(MD));
 
   if (forProtocol) {
     // Protocol methods have no implementation. So, this entry is always NULL.
-    method.addNullPointer(ObjCTypes.Int8PtrTy);
+    method.addNullPointer(ObjCTypes.Int8PtrProgramASTy);
   } else {
     llvm::Function *fn = GetMethodDefinition(MD);
     assert(fn && "no definition for method?");
-    method.addBitCast(fn, ObjCTypes.Int8PtrTy);
+    method.addBitCast(fn, ObjCTypes.Int8PtrProgramASTy);
   }
 
   method.finishAndAddTo(builder);
 }
 
 /// Build meta-data for method declarations.
 ///
 /// struct _method_list_t {

clang/lib/CodeGen/CGObjCRuntime.cpp

 ///
 /// \param method - may be null
 /// \param resultType - the result type to use if there's no method
 /// \param callArgs - the actual arguments, including implicit ones
 CGObjCRuntime::MessageSendInfo
 CGObjCRuntime::getMessageSendInfo(const ObjCMethodDecl *method,
                                   QualType resultType,
                                   CallArgList &callArgs) {
+  unsigned ProgramAS = CGM.getDataLayout().getProgramAddressSpace();
+
   // If there's a method, use information from that.
   if (method) {
     const CGFunctionInfo &signature =
       CGM.getTypes().arrangeObjCMessageSendSignature(method, callArgs[0].Ty);
 
     llvm::PointerType *signatureType =
-      CGM.getTypes().GetFunctionType(signature)->getPointerTo();
+      CGM.getTypes().GetFunctionType(signature)->getPointerTo(ProgramAS);
 
     const CGFunctionInfo &signatureForCall =
       CGM.getTypes().arrangeCall(signature, callArgs);
 
     return MessageSendInfo(signatureForCall, signatureType);
   }
 
   // There's no method;  just use a default CC.
   const CGFunctionInfo &argsInfo =
     CGM.getTypes().arrangeUnprototypedObjCMessageSend(resultType, callArgs);
 
   // Derive the signature to call from that.
   llvm::PointerType *signatureType =
-    CGM.getTypes().GetFunctionType(argsInfo)->getPointerTo();
+    CGM.getTypes().GetFunctionType(argsInfo)->getPointerTo(ProgramAS);
   return MessageSendInfo(argsInfo, signatureType);
 }
 
 bool CGObjCRuntime::canMessageReceiverBeNull(CodeGenFunction &CGF,
                                              const ObjCMethodDecl *method,
                                              bool isSuper,
                                        const ObjCInterfaceDecl *classReceiver,
                                              llvm::Value *receiver) {

clang/test/CodeGen/avr/objc-method.m

+// RUN: %clang_cc1 -triple avr -emit-llvm -fobjc-runtime=macosx %s -o /dev/null
+
+__attribute__((objc_root_class))
+@interface Foo
+
+- (id)foo;
+- (id)bar;
+
+@end
+
+@implementation Foo
+
+- (id)foo {
+  return self;
+}
+
+- (id)bar {
+  return [self foo];
+}
+
+@end