Change of UserLabelPrefix default value from "_" to ""

[andreybokhanko]

Summary

@rafael proposed (http://reviews.llvm.org/D16138#325739) to change UserLablePrefix's default from "_" to "", as latter value happens much more often. This patch implements the proposal.

Yours,

Andrey Bokhanko

Software Engineer
Intel Compiler Team
Intel

[• rafael]

Thanks for working on this, but many of the changes setting the prefix to "_" look wrong.

lib/Basic/Targets.cpp

801 ↗

(On Diff #45177)

This looks wrong, we produce a "f:" not an "_f:" when targeting powerpc-linux-gnu.

1617 ↗

(On Diff #45177)

This also looks wrong.

3659 ↗

(On Diff #45177)

This looks wrong.

3991 ↗

(On Diff #45177)

This looks wrong.

4530 ↗

(On Diff #45177)

This looks wrong.

5308 ↗

(On Diff #45177)

This looks wrong.

5834 ↗

(On Diff #45177)

This looks wrong.

6136 ↗

(On Diff #45177)

This looks wrong.

6296 ↗

(On Diff #45177)

This looks wrong.

6393 ↗

(On Diff #45177)

This looks wrong.

6496 ↗

(On Diff #45177)

This looks wrong.

[andreybokhanko]

@rafael, all these changes are driven by tests.

It seems you mean OS targeting, which is handled in other TargetInfo classes (LinuxTargetInfo in Linux case).

lib/Basic/Targets.cpp

801 ↗

(On Diff #45177)

Is this commented out, tools/clang/test/Preprocessor/init.c:5216 fails. As can be seen in the test, PPC603E target expects UserLabelPrefix to be equal to "_" in freestanding mode.

As for powerpc-linux-gnu target, UserLabelPrefix is set to "" at lib/Basic/Target.cpp:416 (LinuxTargetInfo constructor).

1617 ↗

(On Diff #45177)

Same as above -- NVPTX target expects UserLabelPrefix to be "_" in freestanding mode (tools/clang/test/Preprocessor/init.c:4853). Linux target is covered in LinuxTargetInfo constructor.

[• rafael]

I am pretty sure the cases in init.c are wrong as the assembly itself
doesn't use a '_'.

Having said that, it is probably a good thing to do this in two steps.
So this patch LGTM on the condition that you also open a bug to audit
the cases where we define USER_LABEL_PREFIX to _ in init.c and CC
whoever added those.

Thanks,
Rafael

[andreybokhanko]

Rafael, thanks for the review!

In D16295#329929, @rafael wrote:

I am pretty sure the cases in init.c are wrong as the assembly itself
doesn't use a '_'.

Having said that, it is probably a good thing to do this in two steps.
So this patch LGTM on the condition that you also open a bug to audit
the cases where we define USER_LABEL_PREFIX to _ in init.c and CC
whoever added those.

Done. https://llvm.org/bugs/show_bug.cgi?id=26255

Yours,
Andrey

cfe/trunk/lib/Basic/TargetInfo.cpp

TargetInfo::TargetInfo(const llvm::Triple &T) : TargetOpts(), Triple(T) {
   UseBitFieldTypeAlignment = true;
   UseZeroLengthBitfieldAlignment = false;
   ZeroLengthBitfieldBoundary = 0;
   HalfFormat = &llvm::APFloat::IEEEhalf;
   FloatFormat = &llvm::APFloat::IEEEsingle;
   DoubleFormat = &llvm::APFloat::IEEEdouble;
   LongDoubleFormat = &llvm::APFloat::IEEEdouble;
   DataLayoutString = nullptr;
-  UserLabelPrefix = "_";
+  UserLabelPrefix = "";
   MCountName = "mcount";
   RegParmMax = 0;
   SSERegParmMax = 0;
   HasAlignMac68kSupport = false;
   HasBuiltinMSVaList = false;
 
   // Default to no types using fpret.
   RealTypeUsesObjCFPRet = 0;

cfe/trunk/lib/Basic/Targets.cpp

void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
     // CloudABI uses ISO/IEC 10646:2012 for wchar_t, char16_t and char32_t.
     Builder.defineMacro("__STDC_ISO_10646__", "201206L");
     Builder.defineMacro("__STDC_UTF_16__");
     Builder.defineMacro("__STDC_UTF_32__");
   }
 
 public:
   CloudABITargetInfo(const llvm::Triple &Triple)
-      : OSTargetInfo<Target>(Triple) {
-    this->UserLabelPrefix = "";
-  }
+      : OSTargetInfo<Target>(Triple) {}
 };
 
 static void getDarwinDefines(MacroBuilder &Builder, const LangOptions &Opts,
                              const llvm::Triple &Triple,
                              StringRef &PlatformName,
                              VersionTuple &PlatformMinVersion) {
   Builder.defineMacro("__APPLE_CC__", "6000");
   Builder.defineMacro("__APPLE__");
else if (Triple.isiOS()) {
       else if (Triple.getArch() == llvm::Triple::x86 ||
                Triple.getArch() == llvm::Triple::arm ||
                Triple.getArch() == llvm::Triple::thumb)
         this->TLSSupported = !Triple.isOSVersionLT(9);
     } else if (Triple.isWatchOS())
       this->TLSSupported = !Triple.isOSVersionLT(2);
 
     this->MCountName = "\01mcount";
+    this->UserLabelPrefix = "_";
   }
 
   std::string isValidSectionSpecifier(StringRef SR) const override {
     // Let MCSectionMachO validate this.
     StringRef Segment, Section;
     unsigned TAA, StubSize;
     bool HasTAA;
     return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
     Builder.defineMacro("__ELF__");
     Builder.defineMacro("__KPRINTF_ATTRIBUTE__");
     Builder.defineMacro("__tune_i386__");
     DefineStd(Builder, "unix", Opts);
   }
 public:
   DragonFlyBSDTargetInfo(const llvm::Triple &Triple)
       : OSTargetInfo<Target>(Triple) {
-    this->UserLabelPrefix = "";
-
     switch (Triple.getArch()) {
     default:
     case llvm::Triple::x86:
     case llvm::Triple::x86_64:
       this->MCountName = ".mcount";
       break;
     }
   }
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
     // of wchar_t *literals*, which are not locale-dependent. However,
     // FreeBSD systems apparently depend on us getting this wrong, and
     // setting this to 1 is conforming even if all the basic source
     // character literals have the same encoding as char and wchar_t.
     Builder.defineMacro("__STDC_MB_MIGHT_NEQ_WC__", "1");
   }
 public:
   FreeBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
-    this->UserLabelPrefix = "";
-
     switch (Triple.getArch()) {
     default:
     case llvm::Triple::x86:
     case llvm::Triple::x86_64:
       this->MCountName = ".mcount";
       break;
     case llvm::Triple::mips:
     case llvm::Triple::mipsel:
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
     Builder.defineMacro("__ELF__");
     if (Opts.POSIXThreads)
       Builder.defineMacro("_REENTRANT");
     if (Opts.CPlusPlus)
       Builder.defineMacro("_GNU_SOURCE");
   }
 public:
   KFreeBSDTargetInfo(const llvm::Triple &Triple)
-      : OSTargetInfo<Target>(Triple) {
-    this->UserLabelPrefix = "";
-  }
+      : OSTargetInfo<Target>(Triple) {}
 };
 
 // Minix Target
 template<typename Target>
 class MinixTargetInfo : public OSTargetInfo<Target> {
 protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     // Minix defines
 
     Builder.defineMacro("__minix", "3");
     Builder.defineMacro("_EM_WSIZE", "4");
     Builder.defineMacro("_EM_PSIZE", "4");
     Builder.defineMacro("_EM_SSIZE", "2");
     Builder.defineMacro("_EM_LSIZE", "4");
     Builder.defineMacro("_EM_FSIZE", "4");
     Builder.defineMacro("_EM_DSIZE", "8");
     Builder.defineMacro("__ELF__");
     DefineStd(Builder, "unix", Opts);
   }
 public:
-  MinixTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
-    this->UserLabelPrefix = "";
-  }
+  MinixTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {}
 };
 
 // Linux target
 template<typename Target>
 class LinuxTargetInfo : public OSTargetInfo<Target> {
 protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
     case llvm::Triple::thumb:
     case llvm::Triple::thumbeb:
       Builder.defineMacro("__ARM_DWARF_EH__");
       break;
     }
   }
 public:
   NetBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
-    this->UserLabelPrefix = "";
     this->MCountName = "_mcount";
   }
 };
 
 // OpenBSD Target
 template<typename Target>
 class OpenBSDTargetInfo : public OSTargetInfo<Target> {
 protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     // OpenBSD defines; list based off of gcc output
 
     Builder.defineMacro("__OpenBSD__");
     DefineStd(Builder, "unix", Opts);
     Builder.defineMacro("__ELF__");
     if (Opts.POSIXThreads)
       Builder.defineMacro("_REENTRANT");
   }
 public:
   OpenBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
-    this->UserLabelPrefix = "";
     this->TLSSupported = false;
 
       switch (Triple.getArch()) {
         default:
         case llvm::Triple::x86:
         case llvm::Triple::x86_64:
         case llvm::Triple::arm:
         case llvm::Triple::sparc:
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
     case llvm::Triple::thumb:
     case llvm::Triple::thumbeb:
       Builder.defineMacro("__ARM_DWARF_EH__");
       break;
     }
   }
 public:
   BitrigTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
-    this->UserLabelPrefix = "";
     this->MCountName = "__mcount";
   }
 };
 
 // PSP Target
 template<typename Target>
 class PSPTargetInfo : public OSTargetInfo<Target> {
 protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     // PSP defines; list based on the output of the pspdev gcc toolchain.
     Builder.defineMacro("PSP");
     Builder.defineMacro("_PSP");
     Builder.defineMacro("__psp__");
     Builder.defineMacro("__ELF__");
   }
 public:
-  PSPTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
-    this->UserLabelPrefix = "";
-  }
+  PSPTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {}
 };
 
 // PS3 PPU Target
 template<typename Target>
 class PS3PPUTargetInfo : public OSTargetInfo<Target> {
 protected:
   void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                     MacroBuilder &Builder) const override {
     // PS3 PPU defines.
     Builder.defineMacro("__PPC__");
     Builder.defineMacro("__PPU__");
     Builder.defineMacro("__CELLOS_LV2__");
     Builder.defineMacro("__ELF__");
     Builder.defineMacro("__LP32__");
     Builder.defineMacro("_ARCH_PPC64");
     Builder.defineMacro("__powerpc64__");
   }
 public:
   PS3PPUTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
-    this->UserLabelPrefix = "";
     this->LongWidth = this->LongAlign = 32;
     this->PointerWidth = this->PointerAlign = 32;
     this->IntMaxType = TargetInfo::SignedLongLong;
     this->Int64Type = TargetInfo::SignedLongLong;
     this->SizeType = TargetInfo::UnsignedInt;
     this->DataLayoutString = "E-m:e-p:32:32-i64:64-n32:64";
   }
 };
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
     Builder.defineMacro("__PS4__");
   }
 public:
   PS4OSTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
     this->WCharType = this->UnsignedShort;
 
     // On PS4, TLS variable cannot be aligned to more than 32 bytes (256 bits).
     this->MaxTLSAlign = 256;
-    this->UserLabelPrefix = "";
 
     switch (Triple.getArch()) {
     default:
     case llvm::Triple::x86_64:
       this->MCountName = ".mcount";
       break;
     }
   }
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
 
     DefineStd(Builder, "unix", Opts);
     Builder.defineMacro("__ELF__");
     Builder.defineMacro("__native_client__");
   }
 
 public:
   NaClTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
-    this->UserLabelPrefix = "";
     this->LongAlign = 32;
     this->LongWidth = 32;
     this->PointerAlign = 32;
     this->PointerWidth = 32;
     this->IntMaxType = TargetInfo::SignedLongLong;
     this->Int64Type = TargetInfo::SignedLongLong;
     this->DoubleAlign = 64;
     this->LongDoubleWidth = 64;
class WebAssemblyOSTargetInfo : public OSTargetInfo<Target> {
   const char *getStaticInitSectionSpecifier() const final {
     return ".text.__startup";
   }
 
 public:
   explicit WebAssemblyOSTargetInfo(const llvm::Triple &Triple)
       : OSTargetInfo<Target>(Triple) {
     this->MCountName = "__mcount";
-    this->UserLabelPrefix = "";
     this->TheCXXABI.set(TargetCXXABI::WebAssembly);
   }
 };
 
 //===----------------------------------------------------------------------===//
 // Specific target implementations.
 //===----------------------------------------------------------------------===//
 
public:
   PPCTargetInfo(const llvm::Triple &Triple)
     : TargetInfo(Triple), HasVSX(false), HasP8Vector(false),
       HasP8Crypto(false), HasDirectMove(false), HasQPX(false), HasHTM(false),
       HasBPERMD(false), HasExtDiv(false) {
     BigEndian = (Triple.getArch() != llvm::Triple::ppc64le);
     SimdDefaultAlign = 128;
     LongDoubleWidth = LongDoubleAlign = 128;
     LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble;
+    UserLabelPrefix = "_";
   }
 
   /// \brief Flags for architecture specific defines.
   typedef enum {
     ArchDefineNone  = 0,
     ArchDefineName  = 1 << 0, // <name> is substituted for arch name.
     ArchDefinePpcgr = 1 << 1,
     ArchDefinePpcsq = 1 << 2,
NVPTXTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
     LongWidth = LongAlign = 64;
     AddrSpaceMap = &NVPTXAddrSpaceMap;
     UseAddrSpaceMapMangling = true;
     // Define available target features
     // These must be defined in sorted order!
     NoAsmVariants = true;
     // Set the default GPU to sm20
     GPU = GK_SM20;
+    UserLabelPrefix = "_";
   }
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override {
     Builder.defineMacro("__PTX__");
     Builder.defineMacro("__NVPTX__");
     if (Opts.CUDAIsDevice) {
       // Set __CUDA_ARCH__ for the GPU specified.
       std::string CUDAArchCode;
X86_32TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) {
     RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
                              (1 << TargetInfo::Double) |
                              (1 << TargetInfo::LongDouble));
 
     // x86-32 has atomics up to 8 bytes
     // FIXME: Check that we actually have cmpxchg8b before setting
     // MaxAtomicInlineWidth. (cmpxchg8b is an i586 instruction.)
     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
+
+    UserLabelPrefix = "_";
   }
   BuiltinVaListKind getBuiltinVaListKind() const override {
     return TargetInfo::CharPtrBuiltinVaList;
   }
 
   int getEHDataRegisterNumber(unsigned RegNo) const override {
     if (RegNo == 0) return 0;
     if (RegNo == 1) return 2;

 // x86-32 Haiku target
 class HaikuX86_32TargetInfo : public X86_32TargetInfo {
 public:
   HaikuX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
     SizeType = UnsignedLong;
     IntPtrType = SignedLong;
     PtrDiffType = SignedLong;
     ProcessIDType = SignedLong;
-    this->UserLabelPrefix = "";
     this->TLSSupported = false;
   }
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override {
     X86_32TargetInfo::getTargetDefines(Opts, Builder);
     Builder.defineMacro("__INTEL__");
     Builder.defineMacro("__HAIKU__");
   }
void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
     // RTEMS defines; list based off of gcc output
 
     Builder.defineMacro("__rtems__");
     Builder.defineMacro("__ELF__");
   }
 
 public:
   RTEMSTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
-    this->UserLabelPrefix = "";
-
     switch (Triple.getArch()) {
     default:
     case llvm::Triple::x86:
       // this->MCountName = ".mcount";
       break;
     case llvm::Triple::mips:
     case llvm::Triple::mipsel:
     case llvm::Triple::ppc:

 
 // x86-32 RTEMS target
 class RTEMSX86_32TargetInfo : public X86_32TargetInfo {
 public:
   RTEMSX86_32TargetInfo(const llvm::Triple &Triple) : X86_32TargetInfo(Triple) {
     SizeType = UnsignedLong;
     IntPtrType = SignedLong;
     PtrDiffType = SignedLong;
-    this->UserLabelPrefix = "";
   }
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override {
     X86_32TargetInfo::getTargetDefines(Opts, Builder);
     Builder.defineMacro("__INTEL__");
     Builder.defineMacro("__rtems__");
   }
 };
X86_64TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) {
     ComplexLongDoubleUsesFP2Ret = true;
 
     // Make __builtin_ms_va_list available.
     HasBuiltinMSVaList = true;
 
     // x86-64 has atomics up to 16 bytes.
     MaxAtomicPromoteWidth = 128;
     MaxAtomicInlineWidth = 128;
+
+    UserLabelPrefix = "_";
   }
   BuiltinVaListKind getBuiltinVaListKind() const override {
     return TargetInfo::X86_64ABIBuiltinVaList;
   }
 
   int getEHDataRegisterNumber(unsigned RegNo) const override {
     if (RegNo == 0) return 0;
     if (RegNo == 1) return 1;
WindowsX86_64TargetInfo(const llvm::Triple &Triple)
     WCharType = UnsignedShort;
     LongWidth = LongAlign = 32;
     DoubleAlign = LongLongAlign = 64;
     IntMaxType = SignedLongLong;
     Int64Type = SignedLongLong;
     SizeType = UnsignedLongLong;
     PtrDiffType = SignedLongLong;
     IntPtrType = SignedLongLong;
-    this->UserLabelPrefix = "";
   }
 
   void getTargetDefines(const LangOptions &Opts,
                                 MacroBuilder &Builder) const override {
     WindowsTargetInfo<X86_64TargetInfo>::getTargetDefines(Opts, Builder);
     Builder.defineMacro("_WIN64");
   }
 
ARMTargetInfo(const llvm::Triple &Triple, bool IsBigEndian)
     // ARM has atomics up to 8 bytes
     setAtomic();
 
     // Do force alignment of members that follow zero length bitfields.  If
     // the alignment of the zero-length bitfield is greater than the member
     // that follows it, `bar', `bar' will be aligned as the  type of the
     // zero length bitfield.
     UseZeroLengthBitfieldAlignment = true;
+
+    UserLabelPrefix = "_";
   }
 
   StringRef getABI() const override { return ABI; }
 
   bool setABI(const std::string &Name) override {
     ABI = Name;
 
     // The defaults (above) are for AAPCS, check if we need to change them.

 class WindowsARMTargetInfo : public WindowsTargetInfo<ARMleTargetInfo> {
   const llvm::Triple Triple;
 public:
   WindowsARMTargetInfo(const llvm::Triple &Triple)
     : WindowsTargetInfo<ARMleTargetInfo>(Triple), Triple(Triple) {
     TLSSupported = false;
     WCharType = UnsignedShort;
     SizeType = UnsignedInt;
-    UserLabelPrefix = "";
   }
   void getVisualStudioDefines(const LangOptions &Opts,
                               MacroBuilder &Builder) const {
     WindowsTargetInfo<ARMleTargetInfo>::getVisualStudioDefines(Opts, Builder);
 
     // FIXME: this is invalid for WindowsCE
     Builder.defineMacro("_M_ARM_NT", "1");
     Builder.defineMacro("_M_ARMT", "_M_ARM");
AArch64TargetInfo(const llvm::Triple &Triple)
     // contributes to the alignment of the containing aggregate in the same way
     // a plain (non bit-field) member of that type would, without exception for
     // zero-sized or anonymous bit-fields."
     assert(UseBitFieldTypeAlignment && "bitfields affect type alignment");
     UseZeroLengthBitfieldAlignment = true;
 
     // AArch64 targets default to using the ARM C++ ABI.
     TheCXXABI.set(TargetCXXABI::GenericAArch64);
+
+    UserLabelPrefix = "_";
   }
 
   StringRef getABI() const override { return ABI; }
   bool setABI(const std::string &Name) override {
     if (Name != "aapcs" && Name != "darwinpcs")
       return false;
 
     ABI = Name;

 
 // Shared base class for SPARC v8 (32-bit) and SPARC v9 (64-bit).
 class SparcTargetInfo : public TargetInfo {
   static const TargetInfo::GCCRegAlias GCCRegAliases[];
   static const char * const GCCRegNames[];
   bool SoftFloat;
 public:
   SparcTargetInfo(const llvm::Triple &Triple)
-      : TargetInfo(Triple), SoftFloat(false) {}
+      : TargetInfo(Triple), SoftFloat(false) {
+    UserLabelPrefix = "_";
+  }
 
   bool handleTargetFeatures(std::vector<std::string> &Features,
                             DiagnosticsEngine &Diags) override {
     // The backend doesn't actually handle soft float yet, but in case someone
     // is using the support for the front end continue to support it.
     auto Feature = std::find(Features.begin(), Features.end(), "+soft-float");
     if (Feature != Features.end()) {
       SoftFloat = true;
SystemZTargetInfo(const llvm::Triple &Triple)
     PointerWidth = PointerAlign = 64;
     LongDoubleWidth = 128;
     LongDoubleAlign = 64;
     LongDoubleFormat = &llvm::APFloat::IEEEquad;
     DefaultAlignForAttributeAligned = 64;
     MinGlobalAlign = 16;
     DataLayoutString = "E-m:e-i1:8:16-i8:8:16-i64:64-f128:64-a:8:16-n32:64";
     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 64;
+    UserLabelPrefix = "_";
   }
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override {
     Builder.defineMacro("__s390__");
     Builder.defineMacro("__s390x__");
     Builder.defineMacro("__zarch__");
     Builder.defineMacro("__LONG_DOUBLE_128__");
     if (HasTransactionalExecution)
MSP430TargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
     PointerAlign = 16;
     SuitableAlign = 16;
     SizeType = UnsignedInt;
     IntMaxType = SignedLongLong;
     IntPtrType = SignedInt;
     PtrDiffType = SignedInt;
     SigAtomicType = SignedLong;
     DataLayoutString = "e-m:e-p:16:16-i32:16:32-a:16-n8:16";
+    UserLabelPrefix = "_";
   }
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override {
     Builder.defineMacro("MSP430");
     Builder.defineMacro("__MSP430__");
     // FIXME: defines for different 'flavours' of MCU
   }
   ArrayRef<Builtin::Info> getTargetBuiltins() const override {
TCETargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
     LongDoubleAlign = 32;
     FloatFormat = &llvm::APFloat::IEEEsingle;
     DoubleFormat = &llvm::APFloat::IEEEsingle;
     LongDoubleFormat = &llvm::APFloat::IEEEsingle;
     DataLayoutString = "E-p:32:32-i8:8:32-i16:16:32-i64:32"
                        "-f64:32-v64:32-v128:32-a:0:32-n32";
     AddrSpaceMap = &TCEOpenCLAddrSpaceMap;
     UseAddrSpaceMapMangling = true;
+    UserLabelPrefix = "_";
   }
 
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override {
     DefineStd(Builder, "tce", Opts);
     Builder.defineMacro("__TCE__");
     Builder.defineMacro("__TCE_V1__");
   }

 
 public:
   MipsTargetInfoBase(const llvm::Triple &Triple, const std::string &ABIStr,
                      const std::string &CPUStr)
       : TargetInfo(Triple), CPU(CPUStr), IsMips16(false), IsMicromips(false),
         IsNan2008(false), IsSingleFloat(false), FloatABI(HardFloat),
         DspRev(NoDSP), HasMSA(false), HasFP64(false), ABI(ABIStr) {
     TheCXXABI.set(TargetCXXABI::GenericMIPS);
+    UserLabelPrefix = "_";
   }
 
   bool isNaN2008Default() const {
     return CPU == "mips32r6" || CPU == "mips64r6";
   }
 
   bool isFP64Default() const {
     return CPU == "mips32r6" || ABI == "n32" || ABI == "n64" || ABI == "64";
void getTargetDefines(const LangOptions &Opts,
     Mips64TargetInfoBase::getTargetDefines(Opts, Builder);
   }
 };
 
 class PNaClTargetInfo : public TargetInfo {
 public:
   PNaClTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
     BigEndian = false;
-    this->UserLabelPrefix = "";
     this->LongAlign = 32;
     this->LongWidth = 32;
     this->PointerAlign = 32;
     this->PointerWidth = 32;
     this->IntMaxType = TargetInfo::SignedLongLong;
     this->Int64Type = TargetInfo::SignedLongLong;
     this->DoubleAlign = 64;
     this->LongDoubleWidth = 64;