move fastcall/stdcall mangling up into Mangler.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@98384 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/MC/MCAsmInfo.h

@@ -145,6 +145,11 @@ namespace llvm {
     /// which doesn't support the '.bss' directive only.
     bool UsesELFSectionDirectiveForBSS;      // Defaults to false.
     
+    /// HasMicrosoftFastStdCallMangling - True if this target uses microsoft
+    /// style mangling for functions with X86_StdCall/X86_FastCall calling
+    /// convention.
+    bool HasMicrosoftFastStdCallMangling;    // Defaults to false.
+    
     //===--- Alignment Information ----------------------------------------===//
 
     /// AlignDirective - The directive used to emit round up to an alignment
@@ -295,6 +300,10 @@ namespace llvm {
       return UsesELFSectionDirectiveForBSS;
     }
 
+    bool hasMicrosoftFastStdCallMangling() const {
+      return HasMicrosoftFastStdCallMangling;
+    }
+    
     // Accessors.
     //
     bool hasMachoZeroFillDirective() const { return HasMachoZeroFillDirective; }

lib/MC/MCAsmInfo.cpp

@@ -69,6 +69,7 @@ MCAsmInfo::MCAsmInfo() {
   DwarfRequiresFrameSection = true;
   DwarfUsesInlineInfoSection = false;
   DwarfSectionOffsetDirective = 0;
+  HasMicrosoftFastStdCallMangling = false;
 
   AsmTransCBE = 0;
 }

lib/MC/MCAsmInfoCOFF.cpp

@@ -35,4 +35,5 @@ MCAsmInfoCOFF::MCAsmInfoCOFF() {
   AbsoluteEHSectionOffsets = false;
   SupportsDebugInformation = true;
   DwarfSectionOffsetDirective = "\t.secrel32\t";
+  HasMicrosoftFastStdCallMangling = true;
 }

lib/Target/Mangler.cpp

@@ -12,9 +12,12 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Target/Mangler.h"
-#include "llvm/GlobalValue.h"
+#include "llvm/DerivedTypes.h"
+#include "llvm/Function.h"
+#include "llvm/Target/TargetData.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
+#include "llvm/Support/raw_ostream.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/Twine.h"
 using namespace llvm;
@@ -144,6 +147,26 @@ void Mangler::getNameWithPrefix(SmallVectorImpl<char> &OutName,
   return appendMangledQuotedName(OutName, Name);
 }
 
+/// AddFastCallStdCallSuffix - Microsoft fastcall and stdcall functions require
+/// a suffix on their name indicating the number of words of arguments they
+/// take.
+static void AddFastCallStdCallSuffix(SmallVectorImpl<char> &OutName,
+                                     const Function *F, const TargetData &TD) {
+  // Calculate arguments size total.
+  unsigned ArgWords = 0;
+  for (Function::const_arg_iterator AI = F->arg_begin(), AE = F->arg_end();
+       AI != AE; ++AI) {
+    const Type *Ty = AI->getType();
+    // 'Dereference' type in case of byval parameter attribute
+    if (AI->hasByValAttr())
+      Ty = cast<PointerType>(Ty)->getElementType();
+    // Size should be aligned to DWORD boundary
+    ArgWords += ((TD.getTypeAllocSize(Ty) + 3)/4)*4;
+  }
+  
+  raw_svector_ostream(OutName) << '@' << ArgWords;
+}
+
 
 /// getNameWithPrefix - Fill OutName with the name of the appropriate prefix
 /// and the specified global variable's name.  If the global variable doesn't
@@ -158,16 +181,43 @@ void Mangler::getNameWithPrefix(SmallVectorImpl<char> &OutName,
     PrefixTy = Mangler::LinkerPrivate;
   
   // If this global has a name, handle it simply.
-  if (GV->hasName())
+  if (GV->hasName()) {
-    return getNameWithPrefix(OutName, GV->getName(), PrefixTy);
+    getNameWithPrefix(OutName, GV->getName(), PrefixTy);
+  } else {
+    // Get the ID for the global, assigning a new one if we haven't got one
+    // already.
+    unsigned &ID = AnonGlobalIDs[GV];
+    if (ID == 0) ID = NextAnonGlobalID++;
   
-  // Get the ID for the global, assigning a new one if we haven't got one
+    // Must mangle the global into a unique ID.
-  // already.
+    getNameWithPrefix(OutName, "__unnamed_" + Twine(ID), PrefixTy);
-  unsigned &ID = AnonGlobalIDs[GV];
+  }
-  if (ID == 0) ID = NextAnonGlobalID++;
   
-  // Must mangle the global into a unique ID.
+  // If we are supposed to add a microsoft-style suffix for stdcall/fastcall,
-  getNameWithPrefix(OutName, "__unnamed_" + Twine(ID), PrefixTy);
+  // add it.
+  if (Context.getAsmInfo().hasMicrosoftFastStdCallMangling()) {
+    if (const Function *F = dyn_cast<Function>(GV)) {
+      CallingConv::ID CC = F->getCallingConv();
+    
+      // fastcall functions need to start with @.
+      // FIXME: This logic seems unlikely to be right.
+      if (CC == CallingConv::X86_FastCall) {
+        if (OutName[0] == '_')
+          OutName[0] = '@';
+        else
+          OutName.insert(OutName.begin(), '@');
+      }
+    
+      // fastcall and stdcall functions usually need @42 at the end to specify
+      // the argument info.
+      const FunctionType *FT = F->getFunctionType();
+      if ((CC == CallingConv::X86_FastCall || CC == CallingConv::X86_StdCall) &&
+          // "Pure" variadic functions do not receive @0 suffix.
+          (!FT->isVarArg() || FT->getNumParams() == 0 ||
+           (FT->getNumParams() == 1 && F->hasStructRetAttr())))
+        AddFastCallStdCallSuffix(OutName, F, TD);
+    }
+  }
 }
 
 /// getNameWithPrefix - Fill OutName with the name of the appropriate prefix

lib/Target/X86/AsmPrinter/X86AsmPrinter.cpp

@@ -54,14 +54,7 @@ void X86AsmPrinter::PrintPICBaseSymbol() const {
 }
 
 MCSymbol *X86AsmPrinter::GetGlobalValueSymbol(const GlobalValue *GV) const {
-  MCSymbol *Symb = Mang->getSymbol(GV);
+  return Mang->getSymbol(GV);
-  
-  if (!Subtarget->isTargetCygMing() || !isa<Function>(GV))
-    return Symb;
-  
-  return X86COFFMachineModuleInfo::
-    DecorateCygMingName(Symb, OutContext, cast<Function>(GV),
-                        *TM.getTargetData());
 }
 
 /// runOnMachineFunction - Emit the function body.

lib/Target/X86/AsmPrinter/X86MCInstLower.cpp

@@ -63,9 +63,6 @@ GetSymbolFromOperand(const MachineOperand &MO) const {
              isa<Function>(MO.getGlobal())) {
     const GlobalValue *GV = MO.getGlobal();
     MCSymbol *Sym = Mang->getSymbol(GV);
-    Sym = X86COFFMachineModuleInfo::
-      DecorateCygMingName(Sym, Ctx, cast<Function>(GV),
-                          *AsmPrinter.TM.getTargetData());
     Name.append(Sym->getName().begin(), Sym->getName().end());
   } else {    
     const GlobalValue *GV = MO.getGlobal();

lib/Target/X86/X86COFFMachineModuleInfo.cpp

@@ -26,47 +26,3 @@ using namespace llvm;
 X86COFFMachineModuleInfo::~X86COFFMachineModuleInfo() {
 }
 
-/// DecorateCygMingName - Query FunctionInfoMap and use this information for
-/// various name decorations for Cygwin and MingW.
-MCSymbol *X86COFFMachineModuleInfo::DecorateCygMingName(MCSymbol *NameSym,
-                                                        MCContext &Ctx,
-                                                        const Function *F,
-                                                        const TargetData &TD) {
-  // We don't want to decorate non-stdcall or non-fastcall functions right now
-  CallingConv::ID CC = F->getCallingConv();
-  if (CC != CallingConv::X86_StdCall && CC != CallingConv::X86_FastCall)
-    return NameSym;
-  
-  unsigned ArgWords = 0;
-  
-  // Calculate arguments sizes
-  for (Function::const_arg_iterator AI = F->arg_begin(), AE = F->arg_end();
-       AI != AE; ++AI) {
-    const Type *Ty = AI->getType();
-    
-    // 'Dereference' type in case of byval parameter attribute
-    if (AI->hasByValAttr())
-      Ty = cast<PointerType>(Ty)->getElementType();
-    
-    // Size should be aligned to DWORD boundary
-    ArgWords += ((TD.getTypeAllocSize(Ty) + 3)/4)*4;
-  }
-  
-  const FunctionType *FT = F->getFunctionType();
-  
-  SmallString<128> Name(NameSym->getName().begin(), NameSym->getName().end());
-
-  // "Pure" variadic functions do not receive @0 suffix.
-  if (!FT->isVarArg() || FT->getNumParams() == 0 ||
-      (FT->getNumParams() == 1 && F->hasStructRetAttr()))
-    raw_svector_ostream(Name) << '@' << ArgWords;
-  
-  if (CC == CallingConv::X86_FastCall) {
-    if (Name[0] == '_')
-      Name[0] = '@';
-    else
-      Name.insert(Name.begin(), '@');
-  }
-  
-  return Ctx.GetOrCreateSymbol(Name.str());
-}

lib/Target/X86/X86COFFMachineModuleInfo.h

@@ -30,9 +30,6 @@ public:
   X86COFFMachineModuleInfo(const MachineModuleInfo &) {}
   virtual ~X86COFFMachineModuleInfo();
 
-  static MCSymbol *DecorateCygMingName(MCSymbol *Name, MCContext &Ctx,
-                                       const Function *F, const TargetData &TD);
-
   void addExternalFunction(StringRef Name) {
     CygMingStubs.insert(Name);
   }