llvm/lib/IR/Mangler.cpp

   1 //===-- Mangler.cpp - Self-contained c/asm llvm name mangler --------------===//
   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 // Unified name mangler for assembly backends.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "llvm/IR/Mangler.h"
  14 #include "llvm/ADT/SmallString.h"
  15 #include "llvm/ADT/StringExtras.h"
  16 #include "llvm/ADT/Triple.h"
  17 #include "llvm/ADT/Twine.h"
  18 #include "llvm/IR/DataLayout.h"
  19 #include "llvm/IR/DerivedTypes.h"
  20 #include "llvm/IR/Function.h"
  21 #include "llvm/IR/Module.h"
  22 #include "llvm/Support/raw_ostream.h"
  23 using namespace llvm;
  24
  25 namespace {
  26 enum ManglerPrefixTy {
  27   Default,      ///< Emit default string before each symbol.
  28   Private,      ///< Emit "private" prefix before each symbol.
  29   LinkerPrivate ///< Emit "linker private" prefix before each symbol.
  30 };
  31 }
  32
  33 static void getNameWithPrefixImpl(raw_ostream &OS, const Twine &GVName,
  34                                   ManglerPrefixTy PrefixTy,
  35                                   const DataLayout &DL, char Prefix) {
  36   SmallString<256> TmpData;
  37   StringRef Name = GVName.toStringRef(TmpData);
  38   assert(!Name.empty() && "getNameWithPrefix requires non-empty name");
  39
  40   // No need to do anything special if the global has the special "do not
  41   // mangle" flag in the name.
  42   if (Name[0] == '\1') {
  43     OS << Name.substr(1);
  44     return;
  45   }
  46
  47   if (DL.doNotMangleLeadingQuestionMark() && Name[0] == '?')
  48     Prefix = '\0';
  49
  50   if (PrefixTy == Private)
  51     OS << DL.getPrivateGlobalPrefix();
  52   else if (PrefixTy == LinkerPrivate)
  53     OS << DL.getLinkerPrivateGlobalPrefix();
  54
  55   if (Prefix != '\0')
  56     OS << Prefix;
  57
  58   // If this is a simple string that doesn't need escaping, just append it.
  59   OS << Name;
  60 }
  61
  62 static void getNameWithPrefixImpl(raw_ostream &OS, const Twine &GVName,
  63                                   const DataLayout &DL,
  64                                   ManglerPrefixTy PrefixTy) {
  65   char Prefix = DL.getGlobalPrefix();
  66   return getNameWithPrefixImpl(OS, GVName, PrefixTy, DL, Prefix);
  67 }
  68
  69 void Mangler::getNameWithPrefix(raw_ostream &OS, const Twine &GVName,
  70                                 const DataLayout &DL) {
  71   return getNameWithPrefixImpl(OS, GVName, DL, Default);
  72 }
  73
  74 void Mangler::getNameWithPrefix(SmallVectorImpl<char> &OutName,
  75                                 const Twine &GVName, const DataLayout &DL) {
  76   raw_svector_ostream OS(OutName);
  77   char Prefix = DL.getGlobalPrefix();
  78   return getNameWithPrefixImpl(OS, GVName, Default, DL, Prefix);
  79 }
  80
  81 static bool hasByteCountSuffix(CallingConv::ID CC) {
  82   switch (CC) {
  83   case CallingConv::X86_FastCall:
  84   case CallingConv::X86_StdCall:
  85   case CallingConv::X86_VectorCall:
  86     return true;
  87   default:
  88     return false;
  89   }
  90 }
  91
  92 /// Microsoft fastcall and stdcall functions require a suffix on their name
  93 /// indicating the number of words of arguments they take.
  94 static void addByteCountSuffix(raw_ostream &OS, const Function *F,
  95                                const DataLayout &DL) {
  96   // Calculate arguments size total.
  97   unsigned ArgWords = 0;
  98
  99   const unsigned PtrSize = DL.getPointerSize();
 100
 101   for (const Argument &A : F->args()) {
 102     // 'Dereference' type in case of byval or inalloca parameter attribute.
 103     uint64_t AllocSize = A.hasPassPointeeByValueCopyAttr() ?
 104       A.getPassPointeeByValueCopySize(DL) :
 105       DL.getTypeAllocSize(A.getType());
 106
 107     // Size should be aligned to pointer size.
 108     ArgWords += alignTo(AllocSize, PtrSize);
 109   }
 110
 111   OS << '@' << ArgWords;
 112 }
 113
 114 void Mangler::getNameWithPrefix(raw_ostream &OS, const GlobalValue *GV,
 115                                 bool CannotUsePrivateLabel) const {
 116   ManglerPrefixTy PrefixTy = Default;
 117   if (GV->hasPrivateLinkage()) {
 118     if (CannotUsePrivateLabel)
 119       PrefixTy = LinkerPrivate;
 120     else
 121       PrefixTy = Private;
 122   }
 123
 124   const DataLayout &DL = GV->getParent()->getDataLayout();
 125   if (!GV->hasName()) {
 126     // Get the ID for the global, assigning a new one if we haven't got one
 127     // already.
 128     unsigned &ID = AnonGlobalIDs[GV];
 129     if (ID == 0)
 130       ID = AnonGlobalIDs.size();
 131
 132     // Must mangle the global into a unique ID.
 133     getNameWithPrefixImpl(OS, "__unnamed_" + Twine(ID), DL, PrefixTy);
 134     return;
 135   }
 136
 137   StringRef Name = GV->getName();
 138   char Prefix = DL.getGlobalPrefix();
 139
 140   // Mangle functions with Microsoft calling conventions specially.  Only do
 141   // this mangling for x86_64 vectorcall and 32-bit x86.
 142   const Function *MSFunc = dyn_cast<Function>(GV);
 143
 144   // Don't add byte count suffixes when '\01' or '?' are in the first
 145   // character.
 146   if (Name.startswith("\01") ||
 147       (DL.doNotMangleLeadingQuestionMark() && Name.startswith("?")))
 148     MSFunc = nullptr;
 149
 150   CallingConv::ID CC =
 151       MSFunc ? MSFunc->getCallingConv() : (unsigned)CallingConv::C;
 152   if (!DL.hasMicrosoftFastStdCallMangling() &&
 153       CC != CallingConv::X86_VectorCall)
 154     MSFunc = nullptr;
 155   if (MSFunc) {
 156     if (CC == CallingConv::X86_FastCall)
 157       Prefix = '@'; // fastcall functions have an @ prefix instead of _.
 158     else if (CC == CallingConv::X86_VectorCall)
 159       Prefix = '\0'; // vectorcall functions have no prefix.
 160   }
 161
 162   getNameWithPrefixImpl(OS, Name, PrefixTy, DL, Prefix);
 163
 164   if (!MSFunc)
 165     return;
 166
 167   // If we are supposed to add a microsoft-style suffix for stdcall, fastcall,
 168   // or vectorcall, add it.  These functions have a suffix of @N where N is the
 169   // cumulative byte size of all of the parameters to the function in decimal.
 170   if (CC == CallingConv::X86_VectorCall)
 171     OS << '@'; // vectorcall functions use a double @ suffix.
 172   FunctionType *FT = MSFunc->getFunctionType();
 173   if (hasByteCountSuffix(CC) &&
 174       // "Pure" variadic functions do not receive @0 suffix.
 175       (!FT->isVarArg() || FT->getNumParams() == 0 ||
 176        (FT->getNumParams() == 1 && MSFunc->hasStructRetAttr())))
 177     addByteCountSuffix(OS, MSFunc, DL);
 178 }
 179
 180 void Mangler::getNameWithPrefix(SmallVectorImpl<char> &OutName,
 181                                 const GlobalValue *GV,
 182                                 bool CannotUsePrivateLabel) const {
 183   raw_svector_ostream OS(OutName);
 184   getNameWithPrefix(OS, GV, CannotUsePrivateLabel);
 185 }
 186
 187 // Check if the name needs quotes to be safe for the linker to interpret.
 188 static bool canBeUnquotedInDirective(char C) {
 189   return isAlnum(C) || C == '_' || C == '$' || C == '.' || C == '@';
 190 }
 191
 192 static bool canBeUnquotedInDirective(StringRef Name) {
 193   if (Name.empty())
 194     return false;
 195
 196   // If any of the characters in the string is an unacceptable character, force
 197   // quotes.
 198   for (char C : Name) {
 199     if (!canBeUnquotedInDirective(C))
 200       return false;
 201   }
 202
 203   return true;
 204 }
 205
 206 void llvm::emitLinkerFlagsForGlobalCOFF(raw_ostream &OS, const GlobalValue *GV,
 207                                         const Triple &TT, Mangler &Mangler) {
 208   if (!GV->hasDLLExportStorageClass() || GV->isDeclaration())
 209     return;
 210
 211   if (TT.isWindowsMSVCEnvironment())
 212     OS << " /EXPORT:";
 213   else
 214     OS << " -export:";
 215
 216   bool NeedQuotes = GV->hasName() && !canBeUnquotedInDirective(GV->getName());
 217   if (NeedQuotes)
 218     OS << "\"";
 219   if (TT.isWindowsGNUEnvironment() || TT.isWindowsCygwinEnvironment()) {
 220     std::string Flag;
 221     raw_string_ostream FlagOS(Flag);
 222     Mangler.getNameWithPrefix(FlagOS, GV, false);
 223     FlagOS.flush();
 224     if (Flag[0] == GV->getParent()->getDataLayout().getGlobalPrefix())
 225       OS << Flag.substr(1);
 226     else
 227       OS << Flag;
 228   } else {
 229     Mangler.getNameWithPrefix(OS, GV, false);
 230   }
 231   if (NeedQuotes)
 232     OS << "\"";
 233
 234   if (!GV->getValueType()->isFunctionTy()) {
 235     if (TT.isWindowsMSVCEnvironment())
 236       OS << ",DATA";
 237     else
 238       OS << ",data";
 239   }
 240 }
 241
 242 void llvm::emitLinkerFlagsForUsedCOFF(raw_ostream &OS, const GlobalValue *GV,
 243                                       const Triple &T, Mangler &M) {
 244   if (!T.isWindowsMSVCEnvironment())
 245     return;
 246
 247   OS << " /INCLUDE:";
 248   bool NeedQuotes = GV->hasName() && !canBeUnquotedInDirective(GV->getName());
 249   if (NeedQuotes)
 250     OS << "\"";
 251   M.getNameWithPrefix(OS, GV, false);
 252   if (NeedQuotes)
 253     OS << "\"";
 254 }
 255