[x32] Add X32 support to driver

[pavel.v.chupin]

Summary

This is minimal change for frontend required to have "hello world" compiled
and working on x32 target (x86_64-linux-gnux32).
Note that this patch for backend is also required:
http://reviews.llvm.org/D4181

[compnerd]

lib/Basic/Targets.cpp

3262

I think chaining the assignment here similar to above might be nicer.

3273

The two data layouts are identical except for the pointer size. Can you factor that out so that its more obvious and less redundant please?

lib/Driver/ToolChains.cpp

2977

Can you add a check that arch is x86_64? Right now, you could make up ppc64---gnux32 if Im not mistaken.

lib/Driver/Tools.cpp

6730

Can you do this inside the x86_64 case? Or is there a reason to make this its own case?

6928

Can you extend this to check the arch?

7040

Here as well.

[pavel.v.chupin]

Thanks for review. See next patchset.

lib/Basic/Targets.cpp

3262

Done

3273

DescriptionString is C-style string so next patchset change seems the best what can be done here.

lib/Driver/ToolChains.cpp

2977

Done

lib/Driver/Tools.cpp

6730

Done

6928

Done

7040

Done.

[pavel.v.chupin]

Changes after last review

[pavel.v.chupin]

Fix couple minor formatting issues

[atanasyan]

Could you add tests to check this new functionality?

[chandlerc]

More importantly, this should wait for the llvmdev discussion much like the
other x32 patchset.

[pavel.v.chupin]

llvmdev thread: http://lists.cs.uiuc.edu/pipermail/llvmdev/2014-July/074451.html
I'll add test.

[pavel.v.chupin]

Added tests.
Redesigned findBiarchMultilibs for 3 arch (32,x32,64) support to pass more
tests.

[pavel.v.chupin]

Hi, it seems llvmdev discussion started week ago is over with some good comments made.
Can you please review this patch so we can proceed with these 2 patches merge and continue work on the next ones?

Please let me know if you think anything else is required to proceed here.
Thanks.

[atanasyan]

LGTM

lib/Driver/ToolChains.cpp

1971

s/isX32/IsX32/

[zinovy.nis]

Closed by commit rL212725 (authored by @zinovy.nis).

lib/Basic/Targets.cpp

 };
 } // end anonymous namespace
 
 namespace {
 // x86-64 generic target
 class X86_64TargetInfo : public X86TargetInfo {
 public:
   X86_64TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) {
-    LongWidth = LongAlign = PointerWidth = PointerAlign = 64;
+    const bool IsX32{getTriple().getEnvironment() == llvm::Triple::GNUX32};
+    LongWidth = LongAlign = PointerWidth = PointerAlign = IsX32 ? 32 : 64;
     LongDoubleWidth = 128;
     LongDoubleAlign = 128;
     LargeArrayMinWidth = 128;
     LargeArrayAlign = 128;
     SuitableAlign = 128;
+    if (IsX32) {
+      SizeType = UnsignedInt;
+      PtrDiffType = SignedInt;
+      IntPtrType = SignedInt;
+    } else {
       IntMaxType = SignedLong;
       UIntMaxType = UnsignedLong;
       Int64Type = SignedLong;
+    }
     RegParmMax = 6;
 
-    DescriptionString = "e-m:e-i64:64-f80:128-n8:16:32:64-S128";
+    DescriptionString = (IsX32)
+                            ? "e-m:e-p:32:32-i64:64-f80:128-n8:16:32:64-S128"
+                            : "e-m:e-i64:64-f80:128-n8:16:32:64-S128";
 
     // Use fpret only for long double.
     RealTypeUsesObjCFPRet = (1 << TargetInfo::LongDouble);
 
     // Use fp2ret for _Complex long double.
     ComplexLongDoubleUsesFP2Ret = true;
 
     // x86-64 has atomics up to 16 bytes.

lib/Driver/ToolChains.cpp

Multilib Alt64 = Multilib()
     .flag("-m32").flag("+m64");
   Multilib Alt32 = Multilib()
     .gccSuffix("/32")
     .includeSuffix("/32")
     .flag("+m32").flag("-m64");
 
   FilterNonExistent NonExistent(Path);
 
+  // For x32 case enforce single lib support for now.
+  // In fact there can be 3 libs support like in GCC controlled by
+  // flags -m32/-m64/-mx32.
+  if (TargetTriple.getEnvironment() == llvm::Triple::GNUX32) {
+    Multilib Altx32 = Multilib()
+                          .gccSuffix("/x32")
+                          .includeSuffix("/x32")
+                          .flag("+mx32")
+                          .flag("-m64")
+                          .flag("-m32");
+
+    Result.Multilibs.push_back(Altx32);
+    Result.Multilibs.FilterOut(NonExistent);
+
+    Multilib::flags_list Flags;
+    addMultilibFlag(true, "mx32", Flags);
+    Result.BiarchSibling = Alt64;
+
+    return Result.Multilibs.select(Flags, Result.SelectedMultilib);
+  }
   // Decide whether the default multilib is 32bit, correcting for
   // when the default multilib and the alternate appear backwards
   bool DefaultIs32Bit;
   if (TargetTriple.isArch32Bit() && !NonExistent(Alt32))
     DefaultIs32Bit = false;
   else if (TargetTriple.isArch64Bit() && !NonExistent(Alt64))
     DefaultIs32Bit = true;
   else {
     if (NeedsBiarchSuffix)
       DefaultIs32Bit = TargetTriple.isArch64Bit();
     else
       DefaultIs32Bit = TargetTriple.isArch32Bit();
   }
 
if (TargetTriple.getEnvironment() == llvm::Triple::GNUEABIHF) {
         return "armeb-linux-gnueabi";
     }
     return TargetTriple.str();
   case llvm::Triple::x86:
     if (llvm::sys::fs::exists(SysRoot + "/lib/i386-linux-gnu"))
       return "i386-linux-gnu";
     return TargetTriple.str();
   case llvm::Triple::x86_64:
-    if (llvm::sys::fs::exists(SysRoot + "/lib/x86_64-linux-gnu"))
+    if (llvm::sys::fs::exists(SysRoot + "/lib/x86_64-linux-gnu") &&
+        TargetTriple.getEnvironment() != llvm::Triple::GNUX32)
       return "x86_64-linux-gnu";
     return TargetTriple.str();
   case llvm::Triple::arm64:
   case llvm::Triple::aarch64:
     if (llvm::sys::fs::exists(SysRoot + "/lib/aarch64-linux-gnu"))
       return "aarch64-linux-gnu";
     return TargetTriple.str();
   case llvm::Triple::arm64_be:
static StringRef getOSLibDir(const llvm::Triple &Triple, const ArgList &Args) {
   //
   // FIXME: This is a bit of a hack. We should really unify this code for
   // reasoning about oslibdir spellings with the lib dir spellings in the
   // GCCInstallationDetector, but that is a more significant refactoring.
   if (Triple.getArch() == llvm::Triple::x86 ||
       Triple.getArch() == llvm::Triple::ppc)
     return "lib32";
 
+  if (Triple.getEnvironment() == llvm::Triple::GNUX32)
+    return "libx32";
+
   return Triple.isArch32Bit() ? "lib" : "lib64";
 }
 
 Linux::Linux(const Driver &D, const llvm::Triple &Triple, const ArgList &Args)
   : Generic_ELF(D, Triple, Args) {
   GCCInstallation.init(D, Triple, Args);
   Multilibs = GCCInstallation.getMultilibs();
   llvm::Triple::ArchType Arch = Triple.getArch();

lib/Driver/Tools.cpp

void gnutools::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
   bool NeedsKPIC = false;
 
   // Add --32/--64 to make sure we get the format we want.
   // This is incomplete
   if (getToolChain().getArch() == llvm::Triple::x86) {
     CmdArgs.push_back("--32");
   } else if (getToolChain().getArch() == llvm::Triple::x86_64) {
     CmdArgs.push_back("--64");
+  } else if (getToolChain().getTriple().getEnvironment() ==
+             llvm::Triple::GNUX32) {
+    CmdArgs.push_back("--x32");
   } else if (getToolChain().getArch() == llvm::Triple::ppc) {
     CmdArgs.push_back("-a32");
     CmdArgs.push_back("-mppc");
     CmdArgs.push_back("-many");
   } else if (getToolChain().getArch() == llvm::Triple::ppc64) {
     CmdArgs.push_back("-a64");
     CmdArgs.push_back("-mppc64");
     CmdArgs.push_back("-many");
static StringRef getLinuxDynamicLinker(const ArgList &Args,
   } else if (ToolChain.getArch() == llvm::Triple::ppc)
     return "/lib/ld.so.1";
   else if (ToolChain.getArch() == llvm::Triple::ppc64 ||
            ToolChain.getArch() == llvm::Triple::ppc64le ||
            ToolChain.getArch() == llvm::Triple::systemz)
     return "/lib64/ld64.so.1";
   else if (ToolChain.getArch() == llvm::Triple::sparcv9)
     return "/lib64/ld-linux.so.2";
+  else if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUX32)
+    return "/libx32/ld-linux-x32.so.2";
   else
     return "/lib64/ld-linux-x86-64.so.2";
 }
 
 static void AddRunTimeLibs(const ToolChain &TC, const Driver &D,
                       ArgStringList &CmdArgs, const ArgList &Args) {
   // Make use of compiler-rt if --rtlib option is used
   ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(Args);
void gnutools::Link::ConstructJob(Compilation &C, const JobAction &JA,
   else if (ToolChain.getArch() == llvm::Triple::mips64el) {
     if (mips::hasMipsAbiArg(Args, "n32"))
       CmdArgs.push_back("elf32ltsmipn32");
     else
       CmdArgs.push_back("elf64ltsmip");
   }
   else if (ToolChain.getArch() == llvm::Triple::systemz)
     CmdArgs.push_back("elf64_s390");
+  else if (ToolChain.getTriple().getEnvironment() == llvm::Triple::GNUX32)
+    CmdArgs.push_back("elf32_x86_64");
   else
     CmdArgs.push_back("elf_x86_64");
 
   if (Args.hasArg(options::OPT_static)) {
     if (ToolChain.getArch() == llvm::Triple::arm ||
         ToolChain.getArch() == llvm::Triple::armeb ||
         ToolChain.getArch() == llvm::Triple::thumb ||
         ToolChain.getArch() == llvm::Triple::thumbeb)