stdint.h should use the target's types, cleanup the targets

[majnemer]

Summary

We would not choose the proper type for [u]intptr_t if we were
targeting -ffreestanding mode because we were substituting an equally
sized type, not the exact type.

An examination of Basic/Targets.cpp showed an irregular smattering of
target choices where we would get things wrong. This code has been
reoriented around Operating Systems since they are largely uniform
outside of ILP32-LLP64 differences.

This has found a few notable bugs:

• MIPS and ARM would have their size_t as int and their ptrdiff_t as long
• aarch64 on Linux had it's 64-bit type set as 'long long' instead of as long

[majnemer]

Forgot DragonFlyBSD.

[majnemer]

• Remove unused targets, fixup Minix and kFreeBSD

[t.p.northover]

I've looked over the bits I know and have access to, and it looks mostly fine to me. I don't know anything about the BSDs or anything though.

lib/Sema/SemaType.cpp

4792–4793

I think these two should probably be removed now that vectors are Long/ULong.

[majnemer]

lib/Sema/SemaType.cpp

4792–4793

I tried that and got bit by 32-bit ARM, they use long long for int64_t.

[t.p.northover]

I think these two should probably be removed now that vectors are Long/ULong.

I tried that and got bit by 32-bit ARM, they use long long for int64_t.

Ah, of course! I forgot we shared that bit of code. Sorry about that.

Tim.

[atanasyan]

As to MIPS target the patch looks good to me.

[keith.walker.arm]

The ARM changes look good to me.

[scott-0]

There are is no test of aarch64 to show that "aarch64 on Linux had it's 64-bit type set as 'long long' instead of as long" has changed.

[majnemer]

• Remove unused targets, fixup Minix and kFreeBSD
• Do a better job of matching GCC for OS-free targets
• Fix ARM for NetBSD

[majnemer]

• Add a test checking that int64_t is a signed long instead of a signed long long

[scott-0]

test/Preprocessor/init.c

253

Is it a problem that __INTPTR_TYPE__ and __INTPTR_WIDTH__ have been lost for some targets? (ARM, MIPS*, PPC*, ...)

[majnemer]

test/Preprocessor/init.c

253

INTPTR_TYPE and INTPTR_WIDTH are only defined by operating system targets in GCC's config files, I follow that convention.

[jtsoftware]

Sorry, I didn't realize I was a reviewer and hence need to respond. I guess I'm here because I tinkered with the PS3 stuff, and being with Sony, perhaps because of the deletion of the PSP and SPU stuff. I don't even know if it was done by Sony folks (the log says evocallaghan for the PSP part), or why it needs to be deleted, but I have no problem with it. Let me ask around here a bit first to see if anyone here knows about it.

-John

[alexr]

Sony hasn't used the PSP or SPU targets that were built by others. However, the PS3PPU target is in active use.

Otherwise, I can't meaningfully review this patch because the are just too many changes combined in this patch.

[majnemer]

@alexr I put all of the changes in one patch because splitting them into smaller patches risks inconsistency in the tree. Do you have a suggestion on how you would like this patch to look?

[atanasyan]

What is the state of this revision? Maybe abandon or close it.

[jtsoftware]

Sorry, I don't feel qualified to review it.

[joerg]

I've some errors in this area recently, so does this change still apply?

lib/Basic/Targets.cpp

virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
     getDarwinDefines(Builder, Opts, Triple, this->PlatformName,
                      this->PlatformMinVersion);
   }
 
 public:
   DarwinTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
     this->TLSSupported = Triple.isMacOSX() && !Triple.isMacOSXVersionLT(10, 7);
     this->MCountName = "\01mcount";
+    this->SizeType = TargetInfo::UnsignedLong;
+    this->IntPtrType = TargetInfo::SignedLong;
+    bool Is32BitArch = this->PointerWidth == 32;
+    if (Is32BitArch) {
+      this->PtrDiffType = TargetInfo::SignedInt;
+
+      this->IntMaxType = TargetInfo::SignedLongLong;
+      this->UIntMaxType = TargetInfo::UnsignedLongLong;
+    } else {
+      this->PtrDiffType = TargetInfo::SignedLong;
+
+      this->IntMaxType = TargetInfo::SignedLong;
+      this->UIntMaxType = TargetInfo::UnsignedLong;
+    }
+    this->Int64Type = TargetInfo::SignedLongLong;
   }
 
   virtual std::string isValidSectionSpecifier(StringRef SR) const {
     // Let MCSectionMachO validate this.
     StringRef Segment, Section;
     unsigned TAA, StubSize;
     bool HasTAA;
     return llvm::MCSectionMachO::ParseSectionSpecifier(SR, Segment, Section,
FreeBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
     case llvm::Triple::ppc64:
     case llvm::Triple::ppc64le:
       this->MCountName = "_mcount";
       break;
     case llvm::Triple::arm:
       this->MCountName = "__mcount";
       break;
     }
+
+    bool Is32BitArch = this->PointerWidth == 32;
+    if (Is32BitArch) {
+      this->SizeType = TargetInfo::UnsignedInt;
+      this->IntPtrType = TargetInfo::SignedInt;
+      this->PtrDiffType = TargetInfo::SignedInt;
+
+      this->Int64Type = TargetInfo::SignedLongLong;
+      this->IntMaxType = TargetInfo::SignedLongLong;
+      this->UIntMaxType = TargetInfo::UnsignedLongLong;
+    } else {
+      this->SizeType = TargetInfo::UnsignedLong;
+      this->IntPtrType = TargetInfo::SignedLong;
+      this->PtrDiffType = TargetInfo::SignedLong;
+
+      this->Int64Type = TargetInfo::SignedLong;
+      this->IntMaxType = TargetInfo::SignedLong;
+      this->UIntMaxType = TargetInfo::UnsignedLong;
+    }
   }
 };
 
 // GNU/kFreeBSD Target
 template<typename Target>
 class KFreeBSDTargetInfo : public OSTargetInfo<Target> {
 protected:
   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
if (Opts.POSIXThreads)
       Builder.defineMacro("_REENTRANT");
     if (Opts.CPlusPlus)
       Builder.defineMacro("_GNU_SOURCE");
   }
 public:
   LinuxTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
     this->UserLabelPrefix = "";
     this->WIntType = TargetInfo::UnsignedInt;
+
+    bool Is32BitArch = this->PointerWidth == 32;
+    if (Is32BitArch) {
+      this->SizeType = TargetInfo::UnsignedInt;
+      this->IntPtrType = TargetInfo::SignedInt;
+      this->PtrDiffType = TargetInfo::SignedInt;
+
+      this->Int64Type = TargetInfo::SignedLongLong;
+      this->IntMaxType = TargetInfo::SignedLongLong;
+      this->UIntMaxType = TargetInfo::UnsignedLongLong;
+    } else {
+      this->SizeType = TargetInfo::UnsignedLong;
+      this->IntPtrType = TargetInfo::SignedLong;
+      this->PtrDiffType = TargetInfo::SignedLong;
+
+      this->Int64Type = TargetInfo::SignedLong;
+      this->IntMaxType = TargetInfo::SignedLong;
+      this->UIntMaxType = TargetInfo::UnsignedLong;
+    }
   }
 
   virtual const char *getStaticInitSectionSpecifier() const {
     return ".text.startup";
   }
 };
 
 // NetBSD Target
 template<typename Target>
 class NetBSDTargetInfo : public OSTargetInfo<Target> {
 protected:
   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                             MacroBuilder &Builder) const {
     // NetBSD defines; list based off of gcc output
     Builder.defineMacro("__NetBSD__");
     Builder.defineMacro("__unix__");
     Builder.defineMacro("__ELF__");
     if (Opts.POSIXThreads)
       Builder.defineMacro("_POSIX_THREADS");
   }
 public:
   NetBSDTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
     this->UserLabelPrefix = "";
+
+    bool Is32BitArch = this->PointerWidth == 32;
+    if (Is32BitArch) {
+      this->SizeType = TargetInfo::UnsignedInt;
+      this->IntPtrType = TargetInfo::SignedInt;
+      this->PtrDiffType = TargetInfo::SignedInt;
+    } else {
+      this->SizeType = TargetInfo::UnsignedLong;
+      this->IntPtrType = TargetInfo::SignedLong;
+      this->PtrDiffType = TargetInfo::SignedLong;
+    }
+    this->Int64Type = TargetInfo::SignedLongLong;
+    this->IntMaxType = TargetInfo::SignedLongLong;
+    this->UIntMaxType = TargetInfo::UnsignedLongLong;
   }
 };
 
 // OpenBSD Target
 template<typename Target>
 class OpenBSDTargetInfo : public OSTargetInfo<Target> {
 protected:
   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
this->TLSSupported = false;
           break;
         case llvm::Triple::mips64:
         case llvm::Triple::mips64el:
         case llvm::Triple::ppc:
         case llvm::Triple::sparcv9:
           this->MCountName = "_mcount";
           break;
       }
+
+    this->SizeType = TargetInfo::UnsignedLong;
+    this->IntPtrType = TargetInfo::SignedLong;
+    this->PtrDiffType = TargetInfo::SignedLong;
+
+    this->Int64Type = TargetInfo::SignedLongLong;
+    this->IntMaxType = TargetInfo::SignedLongLong;
+    this->UIntMaxType = TargetInfo::UnsignedLongLong;
   }
 };
 
 // Bitrig Target
 template<typename Target>
 class BitrigTargetInfo : public OSTargetInfo<Target> {
 protected:
   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
                             MacroBuilder &Builder) const {
     // Bitrig defines; list based off of gcc output
 
     Builder.defineMacro("__Bitrig__");
     DefineStd(Builder, "unix", Opts);
     Builder.defineMacro("__ELF__");
     if (Opts.POSIXThreads)
       Builder.defineMacro("_REENTRANT");
   }
 public:
   BitrigTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
     this->UserLabelPrefix = "";
     this->TLSSupported = false;
     this->MCountName = "__mcount";
+
+    this->SizeType = TargetInfo::UnsignedLong;
+    this->IntPtrType = TargetInfo::SignedLong;
+    this->PtrDiffType = TargetInfo::SignedLong;
+
+    this->Int64Type = TargetInfo::SignedLongLong;
+    this->IntMaxType = TargetInfo::SignedLongLong;
+    this->UIntMaxType = TargetInfo::UnsignedLongLong;
   }
 };
 
 // PSP Target
 template<typename Target>
 class PSPTargetInfo : public OSTargetInfo<Target> {
 protected:
   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
     Builder.defineMacro("__ELF__");
     Builder.defineMacro("__svr4__");
     Builder.defineMacro("__SVR4");
   }
 public:
   AuroraUXTargetInfo(const llvm::Triple &Triple)
       : OSTargetInfo<Target>(Triple) {
     this->UserLabelPrefix = "";
-    this->WCharType = this->SignedLong;
+
     // FIXME: WIntType should be SignedLong
+    bool Is32BitArch = this->PointerWidth == 32;
+    if (Is32BitArch) {
+      this->WCharType = TargetInfo::SignedLong;
+
+      this->SizeType = TargetInfo::UnsignedInt;
+      this->IntPtrType = TargetInfo::SignedInt;
+      this->PtrDiffType = TargetInfo::SignedInt;
+
+      this->Int64Type = TargetInfo::SignedLongLong;
+      this->IntMaxType = TargetInfo::SignedLongLong;
+      this->UIntMaxType = TargetInfo::UnsignedLongLong;
+    } else {
+      this->WCharType = TargetInfo::SignedInt;
+
+      this->SizeType = TargetInfo::SignedLong;
+      this->IntPtrType = TargetInfo::SignedLong;
+      this->PtrDiffType = TargetInfo::SignedLong;
+
+      this->Int64Type = TargetInfo::SignedLong;
+      this->IntMaxType = TargetInfo::SignedLong;
+      this->UIntMaxType = TargetInfo::UnsignedLong;
+    }
   }
 };
 
 // Solaris target
 template<typename Target>
 class SolarisTargetInfo : public OSTargetInfo<Target> {
 protected:
   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,
     Builder.defineMacro("_LARGEFILE_SOURCE");
     Builder.defineMacro("_LARGEFILE64_SOURCE");
     Builder.defineMacro("__EXTENSIONS__");
     Builder.defineMacro("_REENTRANT");
   }
 public:
   SolarisTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
     this->UserLabelPrefix = "";
-    this->WCharType = this->SignedInt;
     // FIXME: WIntType should be SignedLong
+    bool Is32BitArch = this->PointerWidth == 32;
+    if (Is32BitArch) {
+      this->WCharType = TargetInfo::SignedLong;
+
+      this->SizeType = TargetInfo::UnsignedInt;
+      this->PtrDiffType = TargetInfo::SignedInt;
+
+      this->Int64Type = TargetInfo::SignedLongLong;
+      this->IntMaxType = TargetInfo::SignedLongLong;
+      this->UIntMaxType = TargetInfo::UnsignedLongLong;
+    } else {
+      this->WCharType = TargetInfo::SignedInt;
+
+      this->SizeType = TargetInfo::SignedLong;
+      this->PtrDiffType = TargetInfo::SignedLong;
+
+      this->Int64Type = TargetInfo::SignedLong;
+      this->IntMaxType = TargetInfo::SignedLong;
+      this->UIntMaxType = TargetInfo::UnsignedLong;
+    }
   }
 };
 
 // Windows target
 template<typename Target>
 class WindowsTargetInfo : public OSTargetInfo<Target> {
 protected:
   virtual void getOSDefines(const LangOptions &Opts, const llvm::Triple &Triple,

 
 namespace {
 class PPC32TargetInfo : public PPCTargetInfo {
 public:
   PPC32TargetInfo(const llvm::Triple &Triple) : PPCTargetInfo(Triple) {
     DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
                         "i64:64:64-f32:32:32-f64:64:64-v128:128:128-n32";
 
-    switch (getTriple().getOS()) {
-    case llvm::Triple::Linux:
-    case llvm::Triple::FreeBSD:
-    case llvm::Triple::NetBSD:
-      SizeType = UnsignedInt;
-      PtrDiffType = SignedInt;
-      IntPtrType = SignedInt;
-      break;
-    default:
-      break;
-    }
-
     if (getTriple().getOS() == llvm::Triple::FreeBSD) {
       LongDoubleWidth = LongDoubleAlign = 64;
       LongDoubleFormat = &llvm::APFloat::IEEEdouble;
     }
 
     // PPC32 supports atomics up to 4 bytes.
     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
   }

 namespace {
 class DarwinPPC32TargetInfo :
   public DarwinTargetInfo<PPC32TargetInfo> {
 public:
   DarwinPPC32TargetInfo(const llvm::Triple &Triple)
       : DarwinTargetInfo<PPC32TargetInfo>(Triple) {
     HasAlignMac68kSupport = true;
     BoolWidth = BoolAlign = 32; //XXX support -mone-byte-bool?
-    PtrDiffType = SignedInt;    // for http://llvm.org/bugs/show_bug.cgi?id=15726
     LongLongAlign = 32;
     SuitableAlign = 128;
     DescriptionString = "E-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
                         "i64:32:64-f32:32:32-f64:64:64-v128:128:128-n32";
   }
   virtual BuiltinVaListKind getBuiltinVaListKind() const {
     return TargetInfo::CharPtrBuiltinVaList;
   }
public:
   virtual unsigned getFloatEvalMethod() const {
     // NetBSD defaults to "double" rounding
     return 1;
   }
 };
 } // end anonymous namespace
 
 namespace {
-class OpenBSDI386TargetInfo : public OpenBSDTargetInfo<X86_32TargetInfo> {
-public:
-  OpenBSDI386TargetInfo(const llvm::Triple &Triple)
-      : OpenBSDTargetInfo<X86_32TargetInfo>(Triple) {
-    SizeType = UnsignedLong;
-    IntPtrType = SignedLong;
-    PtrDiffType = SignedLong;
-  }
-};
-} // end anonymous namespace
-
-namespace {
-class BitrigI386TargetInfo : public BitrigTargetInfo<X86_32TargetInfo> {
-public:
-  BitrigI386TargetInfo(const llvm::Triple &Triple)
-      : BitrigTargetInfo<X86_32TargetInfo>(Triple) {
-    SizeType = UnsignedLong;
-    IntPtrType = SignedLong;
-    PtrDiffType = SignedLong;
-  }
-};
-} // end anonymous namespace
-
-namespace {
 class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
 public:
   DarwinI386TargetInfo(const llvm::Triple &Triple)
       : DarwinTargetInfo<X86_32TargetInfo>(Triple) {
     LongDoubleWidth = 128;
     LongDoubleAlign = 128;
     SuitableAlign = 128;
     MaxVectorAlign = 256;
-    SizeType = UnsignedLong;
-    IntPtrType = SignedLong;
     DescriptionString = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
                         "i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-"
                         "a0:0:64-f80:128:128-n8:16:32-S128";
     HasAlignMac68kSupport = true;
   }
 
 };
 } // end anonymous namespace

 };
 } // end anonymous namespace
 
 namespace {
 class DarwinX86_64TargetInfo : public DarwinTargetInfo<X86_64TargetInfo> {
 public:
   DarwinX86_64TargetInfo(const llvm::Triple &Triple)
       : DarwinTargetInfo<X86_64TargetInfo>(Triple) {
-    Int64Type = SignedLongLong;
     MaxVectorAlign = 256;
   }
 };
 } // end anonymous namespace
 
 namespace {
-class OpenBSDX86_64TargetInfo : public OpenBSDTargetInfo<X86_64TargetInfo> {
-public:
-  OpenBSDX86_64TargetInfo(const llvm::Triple &Triple)
-      : OpenBSDTargetInfo<X86_64TargetInfo>(Triple) {
-    IntMaxType = SignedLongLong;
-    UIntMaxType = UnsignedLongLong;
-    Int64Type = SignedLongLong;
-  }
-};
-} // end anonymous namespace
-
-namespace {
-class BitrigX86_64TargetInfo : public BitrigTargetInfo<X86_64TargetInfo> {
-public:
-  BitrigX86_64TargetInfo(const llvm::Triple &Triple)
-      : BitrigTargetInfo<X86_64TargetInfo>(Triple) {
-    IntMaxType = SignedLongLong;
-    UIntMaxType = UnsignedLongLong;
-    Int64Type = SignedLongLong;
-  }
-};
-}
-
-namespace {
 class AArch64TargetInfo : public TargetInfo {
   static const char * const GCCRegNames[];
   static const TargetInfo::GCCRegAlias GCCRegAliases[];
 
   enum FPUModeEnum {
     FPUMode,
     NeonMode
   };

 
 public:
   ARMTargetInfo(const llvm::Triple &Triple)
       : TargetInfo(Triple), ABI("aapcs-linux"), CPU("arm1136j-s"),
         FPMath(FP_Default), IsAAPCS(true) {
     BigEndian = false;
     SizeType = UnsignedInt;
     PtrDiffType = SignedInt;
+    IntPtrType = SignedInt;
     // AAPCS 7.1.1, ARM-Linux ABI 2.4: type of wchar_t is unsigned int.
     WCharType = UnsignedInt;
 
     // {} in inline assembly are neon specifiers, not assembly variant
     // specifiers.
     NoAsmVariants = true;
 
     // FIXME: Should we just treat this as a feature?

 class SparcV9TargetInfo : public SparcTargetInfo {
 public:
   SparcV9TargetInfo(const llvm::Triple &Triple) : SparcTargetInfo(Triple) {
     // FIXME: Support Sparc quad-precision long double?
     DescriptionString = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-"
                         "i64:64:64-f32:32:32-f64:64:64-v64:64:64-n32:64-S128";
     // This is an LP64 platform.
     LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
-
-    // OpenBSD uses long long for int64_t and intmax_t.
-    if (getTriple().getOS() == llvm::Triple::OpenBSD) {
-      IntMaxType = SignedLongLong;
-      UIntMaxType = UnsignedLongLong;
-    } else {
-      IntMaxType = SignedLong;
-      UIntMaxType = UnsignedLong;
-    }
     Int64Type = IntMaxType;
   }
 
   virtual void getTargetDefines(const LangOptions &Opts,
                                 MacroBuilder &Builder) const {
     SparcTargetInfo::getTargetDefines(Opts, Builder);
     Builder.defineMacro("__sparcv9");
     Builder.defineMacro("__arch64__");
     // Solaris and its derivative AuroraUX don't need these variants, but the
     // BSDs do.
     if (getTriple().getOS() != llvm::Triple::Solaris &&
         getTriple().getOS() != llvm::Triple::AuroraUX) {
       Builder.defineMacro("__sparc64__");
       Builder.defineMacro("__sparc_v9__");
       Builder.defineMacro("__sparcv9__");
     }
   }
 };
 
 } // end anonymous namespace.
 
 namespace {
-class AuroraUXSparcV8TargetInfo : public AuroraUXTargetInfo<SparcV8TargetInfo> {
-public:
-  AuroraUXSparcV8TargetInfo(const llvm::Triple &Triple)
-      : AuroraUXTargetInfo<SparcV8TargetInfo>(Triple) {
-    SizeType = UnsignedInt;
-    PtrDiffType = SignedInt;
-  }
-};
-class SolarisSparcV8TargetInfo : public SolarisTargetInfo<SparcV8TargetInfo> {
-public:
-  SolarisSparcV8TargetInfo(const llvm::Triple &Triple)
-      : SolarisTargetInfo<SparcV8TargetInfo>(Triple) {
-    SizeType = UnsignedInt;
-    PtrDiffType = SignedInt;
-  }
-};
-} // end anonymous namespace.
-
-namespace {
   class SystemZTargetInfo : public TargetInfo {
     static const char *const GCCRegNames[];
 
   public:
     SystemZTargetInfo(const llvm::Triple &Triple) : TargetInfo(Triple) {
       TLSSupported = true;
       IntWidth = IntAlign = 32;
       LongWidth = LongLongWidth = LongAlign = LongLongAlign = 64;

 };
 
 class Mips32TargetInfoBase : public MipsTargetInfoBase {
 public:
   Mips32TargetInfoBase(const llvm::Triple &Triple)
       : MipsTargetInfoBase(Triple, "o32", "mips32") {
     SizeType = UnsignedInt;
     PtrDiffType = SignedInt;
+    IntPtrType = SignedInt;
     MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 32;
   }
   virtual bool setABI(const std::string &Name) {
     if ((Name == "o32") || (Name == "eabi")) {
       ABI = Name;
       return true;
     } else if (Name == "32") {
       ABI = "o32";
static TargetInfo *AllocateTarget(const llvm::Triple &Triple) {
   case llvm::Triple::r600:
     return new R600TargetInfo(Triple);
 
   case llvm::Triple::sparc:
     switch (os) {
     case llvm::Triple::Linux:
       return new LinuxTargetInfo<SparcV8TargetInfo>(Triple);
     case llvm::Triple::AuroraUX:
-      return new AuroraUXSparcV8TargetInfo(Triple);
+      return new AuroraUXTargetInfo<SparcV8TargetInfo>(Triple);
     case llvm::Triple::Solaris:
-      return new SolarisSparcV8TargetInfo(Triple);
+      return new SolarisTargetInfo<SparcV8TargetInfo>(Triple);
     case llvm::Triple::NetBSD:
       return new NetBSDTargetInfo<SparcV8TargetInfo>(Triple);
     case llvm::Triple::OpenBSD:
       return new OpenBSDTargetInfo<SparcV8TargetInfo>(Triple);
     case llvm::Triple::RTEMS:
       return new RTEMSTargetInfo<SparcV8TargetInfo>(Triple);
     default:
       return new SparcV8TargetInfo(Triple);
case llvm::Triple::AuroraUX:
       return new AuroraUXTargetInfo<X86_32TargetInfo>(Triple);
     case llvm::Triple::Linux:
       return new LinuxTargetInfo<X86_32TargetInfo>(Triple);
     case llvm::Triple::DragonFly:
       return new DragonFlyBSDTargetInfo<X86_32TargetInfo>(Triple);
     case llvm::Triple::NetBSD:
       return new NetBSDI386TargetInfo(Triple);
     case llvm::Triple::OpenBSD:
-      return new OpenBSDI386TargetInfo(Triple);
+      return new OpenBSDTargetInfo<X86_32TargetInfo>(Triple);
     case llvm::Triple::Bitrig:
-      return new BitrigI386TargetInfo(Triple);
+      return new BitrigTargetInfo<X86_32TargetInfo>(Triple);
     case llvm::Triple::FreeBSD:
       return new FreeBSDTargetInfo<X86_32TargetInfo>(Triple);
     case llvm::Triple::KFreeBSD:
       return new KFreeBSDTargetInfo<X86_32TargetInfo>(Triple);
     case llvm::Triple::Minix:
       return new MinixTargetInfo<X86_32TargetInfo>(Triple);
     case llvm::Triple::Solaris:
       return new SolarisTargetInfo<X86_32TargetInfo>(Triple);
case llvm::Triple::AuroraUX:
       return new AuroraUXTargetInfo<X86_64TargetInfo>(Triple);
     case llvm::Triple::Linux:
       return new LinuxTargetInfo<X86_64TargetInfo>(Triple);
     case llvm::Triple::DragonFly:
       return new DragonFlyBSDTargetInfo<X86_64TargetInfo>(Triple);
     case llvm::Triple::NetBSD:
       return new NetBSDTargetInfo<X86_64TargetInfo>(Triple);
     case llvm::Triple::OpenBSD:
-      return new OpenBSDX86_64TargetInfo(Triple);
+      return new OpenBSDTargetInfo<X86_64TargetInfo>(Triple);
     case llvm::Triple::Bitrig:
-      return new BitrigX86_64TargetInfo(Triple);
+      return new BitrigTargetInfo<X86_32TargetInfo>(Triple);
     case llvm::Triple::FreeBSD:
       return new FreeBSDTargetInfo<X86_64TargetInfo>(Triple);
     case llvm::Triple::KFreeBSD:
       return new KFreeBSDTargetInfo<X86_64TargetInfo>(Triple);
     case llvm::Triple::Solaris:
       return new SolarisTargetInfo<X86_64TargetInfo>(Triple);
     case llvm::Triple::MinGW32:
       return new MinGWX86_64TargetInfo(Triple);

lib/Headers/stdint.h

 
 /* prevent glibc sys/types.h from defining conflicting types */
 #ifndef __int8_t_defined  
 # define __int8_t_defined
 #endif /* __int8_t_defined */
 
 /* C99 7.18.1.4 Integer types capable of holding object pointers.
  */
-#define __stdint_join3(a,b,c) a ## b ## c
-
-#define  __intn_t(n) __stdint_join3( int, n, _t)
-#define __uintn_t(n) __stdint_join3(uint, n, _t)
-
 #ifndef _INTPTR_T
 #ifndef __intptr_t_defined
-typedef  __intn_t(__INTPTR_WIDTH__)  intptr_t;
+typedef signed __INTPTR_TYPE__ intptr_t;
 #define __intptr_t_defined
 #define _INTPTR_T
-#endif
-#endif
+#endif /* __intptr_t_defined */
+#endif /* _INTPTR_T */
 
 #ifndef _UINTPTR_T
-typedef __uintn_t(__INTPTR_WIDTH__) uintptr_t;
+typedef unsigned __INTPTR_TYPE__ uintptr_t;
 #define _UINTPTR_T
-#endif
+#endif /* _UINTPTR_T */
 
 /* C99 7.18.1.5 Greatest-width integer types.
  */
 typedef __INTMAX_TYPE__  intmax_t;
 typedef __UINTMAX_TYPE__ uintmax_t;
 
 /* C99 7.18.4 Macros for minimum-width integer constants.
  *

 # define INT_LEAST8_MAX   __INT_LEAST8_MAX
 # define UINT_LEAST8_MAX __UINT_LEAST8_MAX
 # define INT_FAST8_MIN    __INT_LEAST8_MIN
 # define INT_FAST8_MAX    __INT_LEAST8_MAX
 # define UINT_FAST8_MAX  __UINT_LEAST8_MAX
 #endif /* __INT_LEAST8_MIN */
 
 /* Some utility macros */
+#define __stdint_join3(a,b,c) a ## b ## c
 #define  __INTN_MIN(n)  __stdint_join3( INT, n, _MIN)
 #define  __INTN_MAX(n)  __stdint_join3( INT, n, _MAX)
 #define __UINTN_MAX(n)  __stdint_join3(UINT, n, _MAX)
 #define  __INTN_C(n, v) __stdint_join3( INT, n, _C(v))
 #define __UINTN_C(n, v) __stdint_join3(UINT, n, _C(v))
 
 /* C99 7.18.2.4 Limits of integer types capable of holding object pointers. */
 /* C99 7.18.3 Limits of other integer types. */

lib/Sema/SemaType.cpp

if (IsAArch64 && BTy->getKind() == BuiltinType::Double)
     return true;
 
   return BTy->getKind() == BuiltinType::SChar ||
          BTy->getKind() == BuiltinType::UChar ||
          BTy->getKind() == BuiltinType::Short ||
          BTy->getKind() == BuiltinType::UShort ||
          BTy->getKind() == BuiltinType::Int ||
          BTy->getKind() == BuiltinType::UInt ||
+         BTy->getKind() == BuiltinType::Long ||
+         BTy->getKind() == BuiltinType::ULong ||
          BTy->getKind() == BuiltinType::LongLong ||
          BTy->getKind() == BuiltinType::ULongLong ||
          BTy->getKind() == BuiltinType::Float ||
          BTy->getKind() == BuiltinType::Half;
 }
 
 /// HandleNeonVectorTypeAttr - The "neon_vector_type" and
 /// "neon_polyvector_type" attributes are used to create vector types that
 /// are mangled according to ARM's ABI.  Otherwise, these types are identical
 /// to those created with the "vector_size" attribute.  Unlike "vector_size"

test/Preprocessor/init.c

 // ARM:#define __INT16_TYPE__ short
 // ARM:#define __INT32_TYPE__ int
 // ARM:#define __INT64_C_SUFFIX__ LL
 // ARM:#define __INT64_TYPE__ long long int
 // ARM:#define __INT8_TYPE__ char
 // ARM:#define __INTMAX_MAX__ 9223372036854775807LL
 // ARM:#define __INTMAX_TYPE__ long long int
 // ARM:#define __INTMAX_WIDTH__ 64
-// ARM:#define __INTPTR_TYPE__ long int
+// ARM:#define __INTPTR_TYPE__ int
 // ARM:#define __INTPTR_WIDTH__ 32
 // ARM:#define __INT_MAX__ 2147483647
 // ARM:#define __LDBL_DENORM_MIN__ 4.9406564584124654e-324L
 // ARM:#define __LDBL_DIG__ 15
 // ARM:#define __LDBL_EPSILON__ 2.2204460492503131e-16L
 // ARM:#define __LDBL_HAS_DENORM__ 1
 // ARM:#define __LDBL_HAS_INFINITY__ 1
 // ARM:#define __LDBL_HAS_QUIET_NAN__ 1
 // ARM:#define __LDBL_MANT_DIG__ 53

 // ARMEABISOFTFP:#define __INT16_TYPE__ short
 // ARMEABISOFTFP:#define __INT32_TYPE__ int
 // ARMEABISOFTFP:#define __INT64_C_SUFFIX__ LL
 // ARMEABISOFTFP:#define __INT64_TYPE__ long long int
 // ARMEABISOFTFP:#define __INT8_TYPE__ char
 // ARMEABISOFTFP:#define __INTMAX_MAX__ 9223372036854775807LL
 // ARMEABISOFTFP:#define __INTMAX_TYPE__ long long int
 // ARMEABISOFTFP:#define __INTMAX_WIDTH__ 64
-// ARMEABISOFTFP:#define __INTPTR_TYPE__ long int
+// ARMEABISOFTFP:#define __INTPTR_TYPE__ int
 // ARMEABISOFTFP:#define __INTPTR_WIDTH__ 32
 // ARMEABISOFTFP:#define __INT_MAX__ 2147483647
 // ARMEABISOFTFP:#define __LDBL_DENORM_MIN__ 4.9406564584124654e-324L
 // ARMEABISOFTFP:#define __LDBL_DIG__ 15
 // ARMEABISOFTFP:#define __LDBL_EPSILON__ 2.2204460492503131e-16L
 // ARMEABISOFTFP:#define __LDBL_HAS_DENORM__ 1
 // ARMEABISOFTFP:#define __LDBL_HAS_INFINITY__ 1
 // ARMEABISOFTFP:#define __LDBL_HAS_QUIET_NAN__ 1

 // ARMEABIHARDFP:#define __INT16_TYPE__ short
 // ARMEABIHARDFP:#define __INT32_TYPE__ int
 // ARMEABIHARDFP:#define __INT64_C_SUFFIX__ LL
 // ARMEABIHARDFP:#define __INT64_TYPE__ long long int
 // ARMEABIHARDFP:#define __INT8_TYPE__ char
 // ARMEABIHARDFP:#define __INTMAX_MAX__ 9223372036854775807LL
 // ARMEABIHARDFP:#define __INTMAX_TYPE__ long long int
 // ARMEABIHARDFP:#define __INTMAX_WIDTH__ 64
-// ARMEABIHARDFP:#define __INTPTR_TYPE__ long int
+// ARMEABIHARDFP:#define __INTPTR_TYPE__ int
 // ARMEABIHARDFP:#define __INTPTR_WIDTH__ 32
 // ARMEABIHARDFP:#define __INT_MAX__ 2147483647
 // ARMEABIHARDFP:#define __LDBL_DENORM_MIN__ 4.9406564584124654e-324L
 // ARMEABIHARDFP:#define __LDBL_DIG__ 15
 // ARMEABIHARDFP:#define __LDBL_EPSILON__ 2.2204460492503131e-16L
 // ARMEABIHARDFP:#define __LDBL_HAS_DENORM__ 1
 // ARMEABIHARDFP:#define __LDBL_HAS_INFINITY__ 1
 // ARMEABIHARDFP:#define __LDBL_HAS_QUIET_NAN__ 1

 // MIPS32BE:#define __INT16_TYPE__ short
 // MIPS32BE:#define __INT32_TYPE__ int
 // MIPS32BE:#define __INT64_C_SUFFIX__ LL
 // MIPS32BE:#define __INT64_TYPE__ long long int
 // MIPS32BE:#define __INT8_TYPE__ char
 // MIPS32BE:#define __INTMAX_MAX__ 9223372036854775807LL
 // MIPS32BE:#define __INTMAX_TYPE__ long long int
 // MIPS32BE:#define __INTMAX_WIDTH__ 64
-// MIPS32BE:#define __INTPTR_TYPE__ long int
+// MIPS32BE:#define __INTPTR_TYPE__ int
 // MIPS32BE:#define __INTPTR_WIDTH__ 32
 // MIPS32BE:#define __INT_MAX__ 2147483647
 // MIPS32BE:#define __LDBL_DENORM_MIN__ 4.9406564584124654e-324L
 // MIPS32BE:#define __LDBL_DIG__ 15
 // MIPS32BE:#define __LDBL_EPSILON__ 2.2204460492503131e-16L
 // MIPS32BE:#define __LDBL_HAS_DENORM__ 1
 // MIPS32BE:#define __LDBL_HAS_INFINITY__ 1
 // MIPS32BE:#define __LDBL_HAS_QUIET_NAN__ 1

 // MIPS32EL:#define __INT16_TYPE__ short
 // MIPS32EL:#define __INT32_TYPE__ int
 // MIPS32EL:#define __INT64_C_SUFFIX__ LL
 // MIPS32EL:#define __INT64_TYPE__ long long int
 // MIPS32EL:#define __INT8_TYPE__ char
 // MIPS32EL:#define __INTMAX_MAX__ 9223372036854775807LL
 // MIPS32EL:#define __INTMAX_TYPE__ long long int
 // MIPS32EL:#define __INTMAX_WIDTH__ 64
-// MIPS32EL:#define __INTPTR_TYPE__ long int
+// MIPS32EL:#define __INTPTR_TYPE__ int
 // MIPS32EL:#define __INTPTR_WIDTH__ 32
 // MIPS32EL:#define __INT_MAX__ 2147483647
 // MIPS32EL:#define __LDBL_DENORM_MIN__ 4.9406564584124654e-324L
 // MIPS32EL:#define __LDBL_DIG__ 15
 // MIPS32EL:#define __LDBL_EPSILON__ 2.2204460492503131e-16L
 // MIPS32EL:#define __LDBL_HAS_DENORM__ 1
 // MIPS32EL:#define __LDBL_HAS_INFINITY__ 1
 // MIPS32EL:#define __LDBL_HAS_QUIET_NAN__ 1

test/Preprocessor/stdint.c

 //
 // ARM:typedef signed char int8_t;
 // ARM:typedef unsigned char uint8_t;
 // ARM:typedef int8_t int_least8_t;
 // ARM:typedef uint8_t uint_least8_t;
 // ARM:typedef int8_t int_fast8_t;
 // ARM:typedef uint8_t uint_fast8_t;
 //
-// ARM:typedef int32_t intptr_t;
-// ARM:typedef uint32_t uintptr_t;
+// ARM:typedef signed int intptr_t;
+// ARM:typedef unsigned int uintptr_t;
 // 
 // ARM:typedef long long int intmax_t;
 // ARM:typedef long long unsigned int uintmax_t;
 //
 // ARM:INT8_MAX_ 127
 // ARM:INT8_MIN_ (-127 -1)
 // ARM:UINT8_MAX_ 255
 // ARM:INT_LEAST8_MIN_ (-127 -1)

 //
 // I386:typedef signed char int8_t;
 // I386:typedef unsigned char uint8_t;
 // I386:typedef int8_t int_least8_t;
 // I386:typedef uint8_t uint_least8_t;
 // I386:typedef int8_t int_fast8_t;
 // I386:typedef uint8_t uint_fast8_t;
 //
-// I386:typedef int32_t intptr_t;
-// I386:typedef uint32_t uintptr_t;
+// I386:typedef signed int intptr_t;
+// I386:typedef unsigned int uintptr_t;
 //
 // I386:typedef long long int intmax_t;
 // I386:typedef long long unsigned int uintmax_t;
 //
 // I386:INT8_MAX_ 127
 // I386:INT8_MIN_ (-127 -1)
 // I386:UINT8_MAX_ 255
 // I386:INT_LEAST8_MIN_ (-127 -1)

 //
 // MSP430:typedef signed char int8_t;
 // MSP430:typedef unsigned char uint8_t;
 // MSP430:typedef int8_t int_least8_t;
 // MSP430:typedef uint8_t uint_least8_t;
 // MSP430:typedef int8_t int_fast8_t;
 // MSP430:typedef uint8_t uint_fast8_t;
 //
-// MSP430:typedef int16_t intptr_t;
-// MSP430:typedef uint16_t uintptr_t;
+// MSP430:typedef signed int intptr_t;
+// MSP430:typedef unsigned int uintptr_t;
 //
 // MSP430:typedef long long int intmax_t;
 // MSP430:typedef long long unsigned int uintmax_t;
 //
 // MSP430:INT8_MAX_ 127
 // MSP430:INT8_MIN_ (-127 -1)
 // MSP430:UINT8_MAX_ 255
 // MSP430:INT_LEAST8_MIN_ (-127 -1)

 //
 // PPC64:typedef signed char int8_t;
 // PPC64:typedef unsigned char uint8_t;
 // PPC64:typedef int8_t int_least8_t;
 // PPC64:typedef uint8_t uint_least8_t;
 // PPC64:typedef int8_t int_fast8_t;
 // PPC64:typedef uint8_t uint_fast8_t;
 //
-// PPC64:typedef int64_t intptr_t;
-// PPC64:typedef uint64_t uintptr_t;
+// PPC64:typedef signed long int intptr_t;
+// PPC64:typedef unsigned long int uintptr_t;
 //
 // PPC64:typedef long int intmax_t;
 // PPC64:typedef long unsigned int uintmax_t;
 //
 // PPC64:INT8_MAX_ 127
 // PPC64:INT8_MIN_ (-127 -1)
 // PPC64:UINT8_MAX_ 255
 // PPC64:INT_LEAST8_MIN_ (-127 -1)

 //
 // PPC:typedef signed char int8_t;
 // PPC:typedef unsigned char uint8_t;
 // PPC:typedef int8_t int_least8_t;
 // PPC:typedef uint8_t uint_least8_t;
 // PPC:typedef int8_t int_fast8_t;
 // PPC:typedef uint8_t uint_fast8_t;
 //
-// PPC:typedef int32_t intptr_t;
-// PPC:typedef uint32_t uintptr_t;
+// PPC:typedef signed long int intptr_t;
+// PPC:typedef unsigned long int uintptr_t;
 //
 // PPC:typedef long long int intmax_t;
 // PPC:typedef long long unsigned int uintmax_t;
 //
 // PPC:INT8_MAX_ 127
 // PPC:INT8_MIN_ (-127 -1)
 // PPC:UINT8_MAX_ 255
 // PPC:INT_LEAST8_MIN_ (-127 -1)

 //
 // S390X:typedef signed char int8_t;
 // S390X:typedef unsigned char uint8_t;
 // S390X:typedef int8_t int_least8_t;
 // S390X:typedef uint8_t uint_least8_t;
 // S390X:typedef int8_t int_fast8_t;
 // S390X:typedef uint8_t uint_fast8_t;
 //
-// S390X:typedef int64_t intptr_t;
-// S390X:typedef uint64_t uintptr_t;
+// S390X:typedef signed long int intptr_t;
+// S390X:typedef unsigned long int uintptr_t;
 //
 // S390X:typedef long long int intmax_t;
 // S390X:typedef long long unsigned int uintmax_t;
 //
 // S390X:INT8_MAX_ 127
 // S390X:INT8_MIN_ (-127 -1)
 // S390X:UINT8_MAX_ 255
 // S390X:INT_LEAST8_MIN_ (-127 -1)

 //
 // SPARC:typedef signed char int8_t;
 // SPARC:typedef unsigned char uint8_t;
 // SPARC:typedef int8_t int_least8_t;
 // SPARC:typedef uint8_t uint_least8_t;
 // SPARC:typedef int8_t int_fast8_t;
 // SPARC:typedef uint8_t uint_fast8_t;
 //
-// SPARC:typedef int32_t intptr_t;
-// SPARC:typedef uint32_t uintptr_t;
+// SPARC:typedef signed long int intptr_t;
+// SPARC:typedef unsigned long int uintptr_t;
 //
 // SPARC:typedef long long int intmax_t;
 // SPARC:typedef long long unsigned int uintmax_t;
 //
 // SPARC:INT8_MAX_ 127
 // SPARC:INT8_MIN_ (-127 -1)
 // SPARC:UINT8_MAX_ 255
 // SPARC:INT_LEAST8_MIN_ (-127 -1)

 //
 // TCE:typedef signed char int8_t;
 // TCE:typedef unsigned char uint8_t;
 // TCE:typedef int8_t int_least8_t;
 // TCE:typedef uint8_t uint_least8_t;
 // TCE:typedef int8_t int_fast8_t;
 // TCE:typedef uint8_t uint_fast8_t;
 //
-// TCE:typedef int32_t intptr_t;
-// TCE:typedef uint32_t uintptr_t;
+// TCE:typedef signed int intptr_t;
+// TCE:typedef unsigned int uintptr_t;
 //
 // TCE:typedef long int intmax_t;
 // TCE:typedef long unsigned int uintmax_t;
 //
 // TCE:INT8_MAX_ 127
 // TCE:INT8_MIN_ (-127 -1)
 // TCE:UINT8_MAX_ 255
 // TCE:INT_LEAST8_MIN_ (-127 -1)

 //
 // X86_64:typedef signed char int8_t;
 // X86_64:typedef unsigned char uint8_t;
 // X86_64:typedef int8_t int_least8_t;
 // X86_64:typedef uint8_t uint_least8_t;
 // X86_64:typedef int8_t int_fast8_t;
 // X86_64:typedef uint8_t uint_fast8_t;
 //
-// X86_64:typedef int64_t intptr_t;
-// X86_64:typedef uint64_t uintptr_t;
+// X86_64:typedef signed long int intptr_t;
+// X86_64:typedef unsigned long int uintptr_t;
 //
 // X86_64:typedef long int intmax_t;
 // X86_64:typedef long unsigned int uintmax_t;
 //
 // X86_64:INT8_MAX_ 127
 // X86_64:INT8_MIN_ (-127 -1)
 // X86_64:UINT8_MAX_ 255
 // X86_64:INT_LEAST8_MIN_ (-127 -1)

 //
 // XCORE:typedef signed char int8_t;
 // XCORE:typedef unsigned char uint8_t;
 // XCORE:typedef int8_t int_least8_t;
 // XCORE:typedef uint8_t uint_least8_t;
 // XCORE:typedef int8_t int_fast8_t;
 // XCORE:typedef uint8_t uint_fast8_t;
 //
-// XCORE:typedef int32_t intptr_t;
-// XCORE:typedef uint32_t uintptr_t;
+// XCORE:typedef signed long int intptr_t;
+// XCORE:typedef unsigned long int uintptr_t;
 //
 // XCORE:typedef long long int intmax_t;
 // XCORE:typedef long long unsigned int uintmax_t;
 //
 // XCORE:INT8_MAX_ 127
 // XCORE:INT8_MIN_ (-127 -1)
 // XCORE:UINT8_MAX_ 255
 // XCORE:INT_LEAST8_MIN_ (-127 -1)

 //
 //
 // stdint.h forms several macro definitions by pasting together identifiers
 // to form names (eg. int32_t is formed from int ## 32 ## _t). The following 
 // case tests that these joining operations are performed correctly even if
 // the identifiers used in the operations (int, uint, _t, INT, UINT, _MIN,
 // _MAX, and _C(v)) are themselves macros.
 //
-// RUN: %clang_cc1 -E -ffreestanding -U__UINTMAX_TYPE__ -U__INTMAX_TYPE__ -Dint=a -Duint=b -D_t=c -DINT=d -DUINT=e -D_MIN=f -D_MAX=g '-D_C(v)=h' -triple=i386-none-none %s | FileCheck -check-prefix JOIN %s
-// JOIN:typedef int32_t intptr_t;
-// JOIN:typedef uint32_t uintptr_t;
+// RUN: %clang_cc1 -E -ffreestanding -U __INTPTR_TYPE__ -U__UINTMAX_TYPE__ -U__INTMAX_TYPE__ -Dint=a -Duint=b -D_t=c -DINT=d -DUINT=e -D_MIN=f -D_MAX=g '-D_C(v)=h' -triple=i386-none-none %s | FileCheck -check-prefix JOIN %s
+// JOIN:typedef signed __INTPTR_TYPE__ intptr_t;
+// JOIN:typedef unsigned __INTPTR_TYPE__ uintptr_t;
 // JOIN:typedef __INTMAX_TYPE__ intmax_t;
 // JOIN:typedef __UINTMAX_TYPE__ uintmax_t;
 // JOIN:INTPTR_MIN_ (-2147483647 -1)
 // JOIN:INTPTR_MAX_ 2147483647
 // JOIN:UINTPTR_MAX_ 4294967295U
 // JOIN:PTRDIFF_MIN_ (-2147483647 -1)
 // JOIN:PTRDIFF_MAX_ 2147483647
 // JOIN:SIZE_MAX_ 4294967295U