[gnustep-objc] Make the GNUstep v2 ABI work for Windows DLLs.

[theraven]

Summary

Based on a patch by Dustin Howett, modified to not change the ABI for
ELF platforms.

[gnustep-objc] Use more Windows-like section names.

This also makes things more readable by PE/COFF debug tools that assume
sections fit in the first header.

Patch by Dustin Howett!

[theraven]

This review is mostly so that @DHowett-MSFT can check that I didn't break his patches too badly in the cleanup and test that they still do allow building Objective-C DLLs on Windows.

[DHowett-MSFT]

This looks great, and takes up the parts of my patch that I cared about. Thank you for doing this.
My primary concern is that the patch includes my "early init" changes -- while I support it and think it's the right solution, especially where it reduces double indirection on class pointers, there may be issues left to iron out.

clang/lib/CodeGen/CGObjCGNU.cpp

188

Should this be SymbolPrefix() or something more like MangleSymbol(StringRef sym)? I know that right now we only need to prepend _ or ._, but is it more future-proof to make it generic?

1540

We may be able to reduce the duplication here (aside: it is very cool that Phabricator shows duplicated lines) by capturing auto sectionVec = &SectionsBaseNames; and switching which is in use based on bin format.

[theraven]

clang/lib/CodeGen/CGObjCGNU.cpp

188

I have refactored this, and then tried adding a $ instead of the . for mangling. On further testing, the latest link.exe from VS 2017 no longer complains about symbols starting with a dot, so I'm inclined to revert that part of it entirely (lld-link.exe was always happy). I'd prefer to minimise differences between COFF and ELF and this means that we have different section names, but aside from needing the extra global initialisation on COFF, everything else is the same.

1540

I thought about that and didn't do it because if the two arrays are different lengths, they're different types. But, of course, they're the same length and if they're ever different lengths in the future then that's probably a bug.

[DHowett-MSFT]

clang/lib/CodeGen/CGObjCGNU.cpp

188

The issue I had with symbols starting with . was in .DEF files specifically.

Linking a shared object containing:

@.exp_with_dot = dllexport global i32 0, align 4

without a def file, yields:

ordinal hint RVA      name

      1    0 00012900 .exp_with_dot

However, linking the same library with a definition file:

test.def

EXPORTS
 .exp_with_dot

yields

output

test.def : fatal error LNK1242: '.exp_with_dot' is an invalid export symbol name

This still reproduces with 15.9.8, sadly. LINK version 14.16.27027.1.

[theraven]

clang/lib/CodeGen/CGObjCGNU.cpp

188

Does it work with a $ instead of a .?

[DHowett-MSFT]

clang/lib/CodeGen/CGObjCGNU.cpp

188

Hey, $ actually works!

EXPORTS
 $exp_with_dollar

ordinal hint RVA      name

      1    0 00012900 $exp_with_dollar

[DHowett-MSFT]

clang/lib/CodeGen/CGObjCGNU.cpp

1231

After we get the ObjCInterfaceDecl, we have to make sure it's the one corresponding to the @interface and not one for a forward declaration (@class).

+        // The first Interface we find may be a @class,
+        // which should only be treated as the source of
+        // truth in the absence of a true declaration.
+        const ObjCInterfaceDecl *OIDDef = OID->getDefinition();
+        if (OIDDef != nullptr)
+          OID = OIDDef;
+

Failure to do so can result in us either failing to import the CLASS_REF or, if it has been exported as CONSTANT, attempt a method dispatch against a pointer to our own import table.

[theraven]

• Address Dustin's review comments.
• [objc-gnustep] Use $ in symbol names on Windows.
• Add fix from Dustin.

[DHowett-MSFT]

clang/lib/CodeGen/CGObjCGNU.cpp

188

As of the latest revision, this now fails at runtime:

0x01342976 (0x03D8D530 0x03D8DCA0 0x04045A08 0x04045A08), llvm::Twine::str() + 0x166 bytes(s), e:\src\llvm\lib\suppor
t\twine.cpp, line 29 + 0x5F byte(s)
0x01664F99 (0x03D8D5C4 0x0000000A 0x00000000 0x03D8DCA0), `anonymous namespace'::CGObjCGNUstep2::GetClassVar() + 0xB9
 bytes(s), e:\src\llvm\tools\clang\lib\codegen\cgobjcgnu.cpp, line 1207 + 0x10 byte(s)

I believe we're running afoul of StringRef's lifetime here. I haven't had a chance to dig in.

[DHowett-MSFT]

clang/lib/CodeGen/CGObjCGNU.cpp

188

Alright, I don't completely understand why Twine is the way that it is, but here:

Twine ManglePublicSymbol(StringRef Name)

When we construct Twine(const char*, StringRef), the newly-minted Twine contains a _pointer to_ the passed-in StringRef. It's invalid immediately after ManglePublicSymbol returns. After a few layers of stack pop off, we end up with random garbage and undefined behavior.

A quick and effective fix is to switch Name to be of type const Twine&.

Twine ManglePublicSymbol(const Twine& Name)

Name ends up being a twine rvalue with a LHSType of cString, and all is right in the world.

[theraven]

• Fix ownership with Twine.

clang/lib/CodeGen/CGObjCGNU.cpp

protected:
 
   /// Helper to check if we are targeting a specific runtime version or later.
   bool isRuntime(ObjCRuntime::Kind kind, unsigned major, unsigned minor=0) {
     const ObjCRuntime &R = CGM.getLangOpts().ObjCRuntime;
     return (R.getKind() == kind) &&
       (R.getVersion() >= VersionTuple(major, minor));
   }
 
+  Twine ManglePublicSymbol(StringRef Name) {
+    return StringRef(CGM.getTriple().isOSBinFormatCOFF() ? "$_" : "._") + Name;
+  }
+
   std::string SymbolForProtocol(StringRef Name) {
-    return (StringRef("._OBJC_PROTOCOL_") + Name).str();
+    return (ManglePublicSymbol("OBJC_PROTOCOL_") + Name).str();
   }
 
   std::string SymbolForProtocolRef(StringRef Name) {
-    return (StringRef("._OBJC_REF_PROTOCOL_") + Name).str();
+    return (ManglePublicSymbol("OBJC_REF_PROTOCOL_") + Name).str();
   }
 
 
   /// Helper function that generates a constant string and returns a pointer to
   /// the start of the string.  The result of this function can be used anywhere
   /// where the C code specifies const char*.
   llvm::Constant *MakeConstantString(StringRef Str, const char *Name = "") {
     ConstantAddress Array = CGM.GetAddrOfConstantCString(Str, Name);
enum SectionKind
     ClassReferenceSection,
     CategorySection,
     ProtocolSection,
     ProtocolReferenceSection,
     ClassAliasSection,
     ConstantStringSection
   };
   static const char *const SectionsBaseNames[8];
+  static const char *const PECOFFSectionsBaseNames[8];
   template<SectionKind K>
   std::string sectionName() {
-    std::string name(SectionsBaseNames[K]);
-    if (CGM.getTriple().isOSBinFormatCOFF())
+    if (CGM.getTriple().isOSBinFormatCOFF()) {
+      std::string name(PECOFFSectionsBaseNames[K]);
       name += "$m";
       return name;
     }
+    return SectionsBaseNames[K];
+  }
   /// The GCC ABI superclass message lookup function.  Takes a pointer to a
   /// structure describing the receiver and the class, and a selector as
   /// arguments.  Returns the IMP for the corresponding method.
   LazyRuntimeFunction MsgLookupSuperFn;
   /// A flag indicating if we've emitted at least one protocol.
   /// If we haven't, then we need to emit an empty protocol, to ensure that the
   /// __start__objc_protocols and __stop__objc_protocols sections exist.
   bool EmittedProtocol = false;
   /// A flag indicating if we've emitted at least one protocol reference.
   /// If we haven't, then we need to emit an empty protocol, to ensure that the
   /// __start__objc_protocol_refs and __stop__objc_protocol_refs sections
   /// exist.
   bool EmittedProtocolRef = false;
   /// A flag indicating if we've emitted at least one class.
   /// If we haven't, then we need to emit an empty protocol, to ensure that the
   /// __start__objc_classes and __stop__objc_classes sections / exist.
   bool EmittedClass = false;
   /// Generate the name of a symbol for a reference to a class.  Accesses to
   /// classes should be indirected via this.
+
+  typedef std::pair<std::string, std::pair<llvm::Constant*, int>> EarlyInitPair;
+  std::vector<EarlyInitPair> EarlyInitList;
+
   std::string SymbolForClassRef(StringRef Name, bool isWeak) {
     if (isWeak)
-      return (StringRef("._OBJC_WEAK_REF_CLASS_") + Name).str();
+      return (ManglePublicSymbol("OBJC_WEAK_REF_CLASS_") + Name).str();
     else
-      return (StringRef("._OBJC_REF_CLASS_") + Name).str();
+      return (ManglePublicSymbol("OBJC_REF_CLASS_") + Name).str();
   }
   /// Generate the name of a class symbol.
   std::string SymbolForClass(StringRef Name) {
-    return (StringRef("._OBJC_CLASS_") + Name).str();
+    return (ManglePublicSymbol("OBJC_CLASS_") + Name).str();
   }
   void CallRuntimeFunction(CGBuilderTy &B, StringRef FunctionName,
       ArrayRef<llvm::Value*> Args) {
     SmallVector<llvm::Type *,8> Types;
     for (auto *Arg : Args)
       Types.push_back(Arg->getType());
     llvm::FunctionType *FT = llvm::FunctionType::get(B.getVoidTy(), Types,
         false);
ConstantAddress GenerateConstantString(const StringLiteral *SL) override {
     StringRef StringClass = CGM.getLangOpts().ObjCConstantStringClass;
 
     if (StringClass.empty()) StringClass = "NSConstantString";
 
     std::string Sym = SymbolForClass(StringClass);
 
     llvm::Constant *isa = TheModule.getNamedGlobal(Sym);
 
-    if (!isa)
+    if (!isa) {
       isa = new llvm::GlobalVariable(TheModule, IdTy, /* isConstant */false,
               llvm::GlobalValue::ExternalLinkage, nullptr, Sym);
-    else if (isa->getType() != PtrToIdTy)
+      if (CGM.getTriple().isOSBinFormatCOFF()) {
+        cast<llvm::GlobalValue>(isa)->setDLLStorageClass(llvm::GlobalValue::DLLImportStorageClass);
+      }
+    } else if (isa->getType() != PtrToIdTy)
       isa = llvm::ConstantExpr::getBitCast(isa, PtrToIdTy);
 
     //  struct
     //  {
     //    Class isa;
     //    uint32_t flags;
     //    uint32_t length; // Number of codepoints
     //    uint32_t size; // Number of bytes
     //    uint32_t hash;
     //    const char *data;
     //  };
 
     ConstantInitBuilder Builder(CGM);
     auto Fields = Builder.beginStruct();
+    if (!CGM.getTriple().isOSBinFormatCOFF()) {
       Fields.add(isa);
+    } else {
+      Fields.addNullPointer(PtrTy);
+    }
     // For now, all non-ASCII strings are represented as UTF-16.  As such, the
     // number of bytes is simply double the number of UTF-16 codepoints.  In
     // ASCII strings, the number of bytes is equal to the number of non-ASCII
     // codepoints.
     if (isNonASCII) {
       unsigned NumU8CodeUnits = Str.size();
       // A UTF-16 representation of a unicode string contains at most the same
       // number of code units as a UTF-8 representation.  Allocate that much
auto *ObjCStrGV =
           isNamed ? StringRef(StringName) : ".objc_string",
           Align, false, isNamed ? llvm::GlobalValue::LinkOnceODRLinkage
                                 : llvm::GlobalValue::PrivateLinkage);
     ObjCStrGV->setSection(sectionName<ConstantStringSection>());
     if (isNamed) {
       ObjCStrGV->setComdat(TheModule.getOrInsertComdat(StringName));
       ObjCStrGV->setVisibility(llvm::GlobalValue::HiddenVisibility);
     }
+    if (CGM.getTriple().isOSBinFormatCOFF()) {
+      std::pair<llvm::Constant*, int> v{ObjCStrGV, 0};
+      EarlyInitList.emplace_back(Sym, v);
+    }
     llvm::Constant *ObjCStr = llvm::ConstantExpr::getBitCast(ObjCStrGV, IdTy);
     ObjCStrings[Str] = ObjCStr;
     ConstantStrings.push_back(ObjCStr);
     return ConstantAddress(ObjCStr, Align);
   }
 
   void PushProperty(ConstantArrayBuilder &PropertiesArray,
             const ObjCPropertyDecl *property,
llvm::GlobalVariable *GetClassVar(StringRef Name, bool isWeak=false) {
     // If this is a weak symbol, then we are creating a valid definition for
     // the symbol, pointing to a weak definition of the real class pointer.  If
     // this is not a weak reference, then we are expecting another compilation
     // unit to provide the real indirection symbol.
     if (isWeak)
       ClassSymbol->setInitializer(new llvm::GlobalVariable(TheModule,
           Int8Ty, false, llvm::GlobalValue::ExternalWeakLinkage,
           nullptr, SymbolForClass(Name)));
+    else {
+      if (CGM.getTriple().isOSBinFormatCOFF()) {
+        IdentifierInfo &II = CGM.getContext().Idents.get(Name);
+        TranslationUnitDecl *TUDecl = CGM.getContext().getTranslationUnitDecl();
+        DeclContext *DC = TranslationUnitDecl::castToDeclContext(TUDecl);
+
+        const ObjCInterfaceDecl *OID = nullptr;
+        for (const auto &Result : DC->lookup(&II))
+          if ((OID = dyn_cast<ObjCInterfaceDecl>(Result)))
+            break;
+
+        // The first Interface we find may be a @class,
+        // which should only be treated as the source of
+        // truth in the absence of a true declaration.
+        const ObjCInterfaceDecl *OIDDef = OID->getDefinition();
+        if (OIDDef != nullptr)
+          OID = OIDDef;
+
+        auto Storage = llvm::GlobalValue::DefaultStorageClass;
+        if (OID->hasAttr<DLLImportAttr>())
+          Storage = llvm::GlobalValue::DLLImportStorageClass;
+        else if (OID->hasAttr<DLLExportAttr>())
+          Storage = llvm::GlobalValue::DLLExportStorageClass;
+
+        cast<llvm::GlobalValue>(ClassSymbol)->setDLLStorageClass(Storage);
+      }
+    }
     assert(ClassSymbol->getName() == SymbolName);
     return ClassSymbol;
   }
   llvm::Value *GetClassNamed(CodeGenFunction &CGF,
                              const std::string &Name,
                              bool isWeak) override {
     return CGF.Builder.CreateLoad(Address(GetClassVar(Name, isWeak),
           CGM.getPointerAlign()));
if (CGM.getTriple().isOSBinFormatCOFF()) {
         auto *Sym = new llvm::GlobalVariable(TheModule, emptyStruct,
             /*isConstant*/false,
             llvm::GlobalValue::LinkOnceODRLinkage, ZeroInit, Prefix +
             Section);
         Sym->setVisibility(llvm::GlobalValue::HiddenVisibility);
         Sym->setSection((Section + SecSuffix).str());
         Sym->setComdat(TheModule.getOrInsertComdat((Prefix +
             Section).str()));
-        Sym->setAlignment(1);
+        Sym->setAlignment(CGM.getPointerAlign().getQuantity());
         return Sym;
       };
       return { Sym("__start_", "$a"), Sym("__stop", "$z") };
     }
     auto *Start = new llvm::GlobalVariable(TheModule, PtrTy,
         /*isConstant*/false,
         llvm::GlobalValue::ExternalLinkage, nullptr, StringRef("__start_") +
         Section);
llvm::Function *ModuleInitFunction() override {
 
     llvm::BasicBlock *EntryBB =
         llvm::BasicBlock::Create(VMContext, "entry", LoadFunction);
     CGBuilderTy B(CGM, VMContext);
     B.SetInsertPoint(EntryBB);
     ConstantInitBuilder builder(CGM);
     auto InitStructBuilder = builder.beginStruct();
     InitStructBuilder.addInt(Int64Ty, 0);
-    for (auto *s : SectionsBaseNames) {
+    auto &sectionVec = CGM.getTriple().isOSBinFormatCOFF() ? PECOFFSectionsBaseNames : SectionsBaseNames;
+    for (auto *s : sectionVec) {
       auto bounds = GetSectionBounds(s);
       InitStructBuilder.add(bounds.first);
       InitStructBuilder.add(bounds.second);
-    };
+    }
     auto *InitStruct = InitStructBuilder.finishAndCreateGlobal(".objc_init",
         CGM.getPointerAlign(), false, llvm::GlobalValue::LinkOnceODRLinkage);
     InitStruct->setVisibility(llvm::GlobalValue::HiddenVisibility);
     InitStruct->setComdat(TheModule.getOrInsertComdat(".objc_init"));
 
     CallRuntimeFunction(B, "__objc_load", {InitStruct});;
     B.CreateRetVoid();
     // Make sure that the optimisers don't delete this function.
if (!CGM.getTriple().isOSBinFormatCOFF()) {
         createNullGlobal(".objc_null_constant_string", { NULLPtr, i32Zero,
             i32Zero, i32Zero, i32Zero, NULLPtr },
             sectionName<ConstantStringSection>());
       }
     }
     ConstantStrings.clear();
     Categories.clear();
     Classes.clear();
+
+    if (EarlyInitList.size() > 0) {
+      auto *Init = llvm::Function::Create(llvm::FunctionType::get(CGM.VoidTy,
+            {}), llvm::GlobalValue::InternalLinkage, ".objc_early_init",
+          &CGM.getModule());
+      llvm::IRBuilder<> b(llvm::BasicBlock::Create(CGM.getLLVMContext(), "entry",
+            Init));
+      for (const auto &lateInit : EarlyInitList) {
+        auto *global = TheModule.getGlobalVariable(lateInit.first);
+        if (global) {
+          b.CreateAlignedStore(global,
+              b.CreateStructGEP(lateInit.second.first, lateInit.second.second), CGM.getPointerAlign().getQuantity());
+        }
+      }
+      b.CreateRetVoid();
+      // We can't use the normal LLVM global initialisation array, because we
+      // need to specify that this runs early in library initialisation.
+      auto *InitVar = new llvm::GlobalVariable(CGM.getModule(), Init->getType(), 
+          /*isConstant*/true, llvm::GlobalValue::InternalLinkage,
+          Init, ".objc_early_init_ptr");
+      InitVar->setSection(".CRT$XCLb");
+      CGM.addUsedGlobal(InitVar);
+    }
     return nullptr;
   }
   /// In the v2 ABI, ivar offset variables use the type encoding in their name
   /// to trigger linker failures if the types don't match.
   std::string GetIVarOffsetVariableName(const ObjCInterfaceDecl *ID,
                                         const ObjCIvarDecl *Ivar) override {
     std::string TypeEncoding;
     CGM.getContext().getObjCEncodingForType(Ivar->getType(), TypeEncoding);
llvm::Value *EmitIvarOffset(CodeGenFunction &CGF,
     CharUnits Align = CGM.getIntAlign();
     llvm::Value *Offset = CGF.Builder.CreateAlignedLoad(IvarOffsetPointer, Align);
     if (Offset->getType() != PtrDiffTy)
       Offset = CGF.Builder.CreateZExtOrBitCast(Offset, PtrDiffTy);
     return Offset;
   }
   void GenerateClass(const ObjCImplementationDecl *OID) override {
     ASTContext &Context = CGM.getContext();
+    bool IsCOFF = CGM.getTriple().isOSBinFormatCOFF();
 
     // Get the class name
     ObjCInterfaceDecl *classDecl =
         const_cast<ObjCInterfaceDecl *>(OID->getClassInterface());
     std::string className = classDecl->getNameAsString();
     auto *classNameConstant = MakeConstantString(className);
 
     ConstantInitBuilder builder(CGM);
void GenerateClass(const ObjCImplementationDecl *OID) override {
     metaclassFields.addNullPointer(PtrTy);
     // struct reference_list *extra_data;
     metaclassFields.addNullPointer(PtrTy);
     // long abi_version;
     metaclassFields.addInt(LongTy, 0);
     // struct objc_property_list *properties
     metaclassFields.add(GeneratePropertyList(OID, classDecl, /*isClassProperty*/true));
 
-    auto *metaclass = metaclassFields.finishAndCreateGlobal("._OBJC_METACLASS_"
-        + className, CGM.getPointerAlign());
+    auto *metaclass = metaclassFields.finishAndCreateGlobal(
+        ManglePublicSymbol("OBJC_METACLASS_") + className,
+        CGM.getPointerAlign());
 
     auto classFields = builder.beginStruct();
     // struct objc_class *isa;
     classFields.add(metaclass);
     // struct objc_class *super_class;
     // Get the superclass name.
     const ObjCInterfaceDecl * SuperClassDecl =
       OID->getClassInterface()->getSuperClass();
+    llvm::Constant *SuperClass = nullptr;
     if (SuperClassDecl) {
       auto SuperClassName = SymbolForClass(SuperClassDecl->getNameAsString());
-      llvm::Constant *SuperClass = TheModule.getNamedGlobal(SuperClassName);
+      SuperClass = TheModule.getNamedGlobal(SuperClassName);
       if (!SuperClass)
       {
         SuperClass = new llvm::GlobalVariable(TheModule, PtrTy, false,
             llvm::GlobalValue::ExternalLinkage, nullptr, SuperClassName);
+        if (IsCOFF) {
+          auto Storage = llvm::GlobalValue::DefaultStorageClass;
+          if (SuperClassDecl->hasAttr<DLLImportAttr>())
+            Storage = llvm::GlobalValue::DLLImportStorageClass;
+          else if (SuperClassDecl->hasAttr<DLLExportAttr>())
+            Storage = llvm::GlobalValue::DLLExportStorageClass;
+
+          cast<llvm::GlobalValue>(SuperClass)->setDLLStorageClass(Storage);
+        }
       }
+      if (!IsCOFF)
         classFields.add(llvm::ConstantExpr::getBitCast(SuperClass, PtrTy));
+      else
+        classFields.addNullPointer(PtrTy);
     } else
       classFields.addNullPointer(PtrTy);
     // const char *name;
     classFields.add(classNameConstant);
     // long version;
     classFields.addInt(LongTy, 0);
     // unsigned long info;
     // !objc_class_flag_meta
void GenerateClass(const ObjCImplementationDecl *OID) override {
     classFields.addInt(LongTy, 0);
     // struct objc_property_list *properties
     classFields.add(GeneratePropertyList(OID, classDecl));
 
     auto *classStruct =
       classFields.finishAndCreateGlobal(SymbolForClass(className),
         CGM.getPointerAlign(), false, llvm::GlobalValue::ExternalLinkage);
 
-    if (CGM.getTriple().isOSBinFormatCOFF()) {
-      auto Storage = llvm::GlobalValue::DefaultStorageClass;
-      if (OID->getClassInterface()->hasAttr<DLLImportAttr>())
-        Storage = llvm::GlobalValue::DLLImportStorageClass;
-      else if (OID->getClassInterface()->hasAttr<DLLExportAttr>())
-        Storage = llvm::GlobalValue::DLLExportStorageClass;
-      cast<llvm::GlobalValue>(classStruct)->setDLLStorageClass(Storage);
-    }
-
     auto *classRefSymbol = GetClassVar(className);
     classRefSymbol->setSection(sectionName<ClassReferenceSection>());
     classRefSymbol->setInitializer(llvm::ConstantExpr::getBitCast(classStruct, IdTy));
 
+    if (IsCOFF) {
+      // we can't import a class struct.
+      if (OID->getClassInterface()->hasAttr<DLLExportAttr>()) {
+        cast<llvm::GlobalValue>(classStruct)->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
+        cast<llvm::GlobalValue>(classRefSymbol)->setDLLStorageClass(llvm::GlobalValue::DLLExportStorageClass);
+      }
+
+      if (SuperClass) {
+        std::pair<llvm::Constant*, int> v{classStruct, 1};
+        EarlyInitList.emplace_back(SuperClass->getName(), std::move(v));
+      }
+
+    }
+
 
     // Resolve the class aliases, if they exist.
     // FIXME: Class pointer aliases shouldn't exist!
     if (ClassPtrAlias) {
       ClassPtrAlias->replaceAllUsesWith(
           llvm::ConstantExpr::getBitCast(classStruct, IdTy));
       ClassPtrAlias->eraseFromParent();
       ClassPtrAlias = nullptr;
if (MetaClassPtrAlias) {
           llvm::ConstantExpr::getBitCast(metaclass, IdTy));
       MetaClassPtrAlias->eraseFromParent();
       MetaClassPtrAlias = nullptr;
     }
     assert(classStruct->getName() == SymbolForClass(className));
 
     auto classInitRef = new llvm::GlobalVariable(TheModule,
         classStruct->getType(), false, llvm::GlobalValue::ExternalLinkage,
-        classStruct, "._OBJC_INIT_CLASS_" + className);
+        classStruct, ManglePublicSymbol("OBJC_INIT_CLASS_") + className);
     classInitRef->setSection(sectionName<ClassSection>());
     CGM.addUsedGlobal(classInitRef);
 
     EmittedClass = true;
   }
   public:
     CGObjCGNUstep2(CodeGenModule &Mod) : CGObjCGNUstep(Mod, 10, 4, 2) {
       MsgLookupSuperFn.init(&CGM, "objc_msg_lookup_super", IMPTy,

 "__objc_class_refs",
 "__objc_cats",
 "__objc_protocols",
 "__objc_protocol_refs",
 "__objc_class_aliases",
 "__objc_constant_string"
 };
 
+const char *const CGObjCGNUstep2::PECOFFSectionsBaseNames[8] =
+{
+".objcrt$SEL",
+".objcrt$CLS",
+".objcrt$CLR",
+".objcrt$CAT",
+".objcrt$PCL",
+".objcrt$PCR",
+".objcrt$CAL",
+".objcrt$STR"
+};
+
 /// Support for the ObjFW runtime.
 class CGObjCObjFW: public CGObjCGNU {
 protected:
   /// The GCC ABI message lookup function.  Returns an IMP pointing to the
   /// method implementation for this message.
   LazyRuntimeFunction MsgLookupFn;
   /// stret lookup function.  While this does not seem to make sense at the
   /// first look, this is required to call the correct forwarding function.