[X86] Add -malign-double support

[phosek]

Summary

The -malign-double flag causes i64 and f64 types to have alignment 8
instead of 4. On x86-64, -malign-double is enabled by default.

[jfb]

include/clang/Basic/TargetInfo.h

816

I don't understand what this is for.

lib/Basic/Targets.cpp

3572

This refactoring is orthogonal to aligned double? Could you do it in its own patch?

[phosek]

Superseded by http://reviews.llvm.org/D19734

include/clang/Basic/TargetInfo.h

public:
   /// \brief Determine whether the given target has the given feature.
   virtual bool hasFeature(StringRef Feature) const {
     return false;
   }
 
   // \brief Validate the contents of the __builtin_cpu_supports(const char*)
   // argument.
   virtual bool validateCpuSupports(StringRef Name) const { return false; }
-  
+  /// Handle arguments passed to LLVM's option processing.
+  ///
+  /// \return False on error.
+  virtual bool handleLLVMArgs(std::vector<std::string> &Args) {
+    return true;
+  }
+  
   // \brief Returns maximal number of args passed in registers.
   unsigned getRegParmMax() const {
     assert(RegParmMax < 7 && "RegParmMax value is larger than AST can handle");
     return RegParmMax;
   }
 
   /// \brief Whether the target supports thread-local storage.
   bool isTLSSupported() const {

include/clang/Basic/TargetOptions.h

public:
   /// \brief The list of target specific features to enable or disable, as written on the command line.
   std::vector<std::string> FeaturesAsWritten;
 
   /// The list of target specific features to enable or disable -- this should
   /// be a list of strings starting with by '+' or '-'.
   std::vector<std::string> Features;
   
   std::vector<std::string> Reciprocals;
+
+  /// \brief A list of arguments to forward to LLVM's option processing; this
+  /// should only be used for debugging and experimental features.
+  std::vector<std::string> LLVMArgs;
 };
 
 }  // end namespace clang
 
 #endif

include/clang/Driver/Options.td

 def mno_fma : Flag<["-"], "mno-fma">, Group<m_x86_Features_Group>;
 def mno_xop : Flag<["-"], "mno-xop">, Group<m_x86_Features_Group>;
 def mno_f16c : Flag<["-"], "mno-f16c">, Group<m_x86_Features_Group>;
 def mno_rtm : Flag<["-"], "mno-rtm">, Group<m_x86_Features_Group>;
 def mno_prfchw : Flag<["-"], "mno-prfchw">, Group<m_x86_Features_Group>;
 def mno_rdseed : Flag<["-"], "mno-rdseed">, Group<m_x86_Features_Group>;
 def mno_adx : Flag<["-"], "mno-adx">, Group<m_x86_Features_Group>;
 def mno_sha : Flag<["-"], "mno-sha">, Group<m_x86_Features_Group>;
+def malign_double : Flag<["-"], "malign-double">,  Group<m_Group>;
 
 def munaligned_access : Flag<["-"], "munaligned-access">, Group<m_arm_Features_Group>,
   HelpText<"Allow memory accesses to be unaligned (AArch32/AArch64 only)">;
 def mno_unaligned_access : Flag<["-"], "mno-unaligned-access">, Group<m_arm_Features_Group>,
   HelpText<"Force all memory accesses to be aligned (AArch32/AArch64 only)">;
 def mstrict_align : Flag<["-"], "mstrict-align">, Alias<mno_unaligned_access>, Flags<[CC1Option,HelpHidden]>,
   HelpText<"Force all memory accesses to be aligned (same as mno-unaligned-access)">;
 def mno_thumb : Flag<["-"], "mno-thumb">, Group<m_arm_Features_Group>;

lib/Basic/Targets.cpp

NaClTargetInfo(const llvm::Triple &Triple) : OSTargetInfo<Target>(Triple) {
     this->SizeType = TargetInfo::UnsignedInt;
     this->PtrDiffType = TargetInfo::SignedInt;
     this->IntPtrType = TargetInfo::SignedInt;
     // RegParmMax is inherited from the underlying architecture
     this->LongDoubleFormat = &llvm::APFloat::IEEEdouble;
     if (Triple.getArch() == llvm::Triple::arm) {
       // Handled in ARM's setABI().
     } else if (Triple.getArch() == llvm::Triple::x86) {
-      this->DataLayoutString = "e-m:e-p:32:32-i64:64-n8:16:32-S128";
+      // Handled in X86_32's setDataLayoutString.
     } else if (Triple.getArch() == llvm::Triple::x86_64) {
       this->DataLayoutString = "e-m:e-p:32:32-i64:64-n8:16:32:64-S128";
     } else if (Triple.getArch() == llvm::Triple::mipsel) {
       // Handled on mips' setDataLayoutString.
     } else {
       assert(Triple.getArch() == llvm::Triple::le32);
       this->DataLayoutString = "e-p:32:32-i64:64";
     }
case 'u': // second from top of floating point stack.
     return std::string("{st(1)}"); // second from top of floating point stack.
   default:
     return std::string(1, *Constraint);
   }
 }
 
 // X86-32 generic target
 class X86_32TargetInfo : public X86TargetInfo {
+  virtual void setDataLayoutString() {
+    if (getTriple().isOSNaCl())
+      DataLayoutString = "e-m:e-p:32:32-i64:64-n8:16:32-S128";
+    else if (HasAlignedDouble)
+      DataLayoutString = "e-m:e-p:32:32-i64:64-f80:32-n8:16:32-S128";
+    else
+      DataLayoutString = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128";
+  }
+  bool HasAlignedDouble;
 public:
   X86_32TargetInfo(const llvm::Triple &Triple) : X86TargetInfo(Triple) {
     DoubleAlign = LongLongAlign = 32;
     LongDoubleWidth = 96;
     LongDoubleAlign = 32;
     SuitableAlign = 128;
-    DataLayoutString = "e-m:e-p:32:32-f64:32:64-f80:32-n8:16:32-S128";
     SizeType = UnsignedInt;
     PtrDiffType = SignedInt;
     IntPtrType = SignedInt;
     RegParmMax = 3;
 
     // Use fpret for all types.
     RealTypeUsesObjCFPRet = ((1 << TargetInfo::Float) |
                              (1 << TargetInfo::Double) |
bool validateOperandSize(StringRef Constraint,
     case 'D':
       return Size <= 32;
     case 'A':
       return Size <= 64;
     }
 
     return X86TargetInfo::validateOperandSize(Constraint, Size);
   }
+
+  bool handleLLVMArgs(std::vector<std::string> &Args) override {
+    HasAlignedDouble = false;
+    auto it = std::find(Args.begin(), Args.end(), "-malign-double");
+    if (it != Args.end()) {
+      HasAlignedDouble = true;
+    }
+    setDataLayoutString();
+    return true;
+  }
 };
 
 class NetBSDI386TargetInfo : public NetBSDTargetInfo<X86_32TargetInfo> {
 public:
   NetBSDI386TargetInfo(const llvm::Triple &Triple)
       : NetBSDTargetInfo<X86_32TargetInfo>(Triple) {}
 
   unsigned getFloatEvalMethod() const override {
BitrigI386TargetInfo(const llvm::Triple &Triple)
       : BitrigTargetInfo<X86_32TargetInfo>(Triple) {
     SizeType = UnsignedLong;
     IntPtrType = SignedLong;
     PtrDiffType = SignedLong;
   }
 };
 
 class DarwinI386TargetInfo : public DarwinTargetInfo<X86_32TargetInfo> {
+  void setDataLayoutString() override {
+    DataLayoutString = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128";
+  }
 public:
   DarwinI386TargetInfo(const llvm::Triple &Triple)
       : DarwinTargetInfo<X86_32TargetInfo>(Triple) {
     LongDoubleWidth = 128;
     LongDoubleAlign = 128;
     SuitableAlign = 128;
     SizeType = UnsignedLong;
     IntPtrType = SignedLong;
-    DataLayoutString = "e-m:o-p:32:32-f64:32:64-f80:128-n8:16:32-S128";
     HasAlignMac68kSupport = true;
   }
 
   bool handleTargetFeatures(std::vector<std::string> &Features,
                             DiagnosticsEngine &Diags) override {
     if (!DarwinTargetInfo<X86_32TargetInfo>::handleTargetFeatures(Features,
                                                                   Diags))
       return false;
     // We now know the features we have: we can decide how to align vectors.
     MaxVectorAlign =
         hasFeature("avx512f") ? 512 : hasFeature("avx") ? 256 : 128;
     return true;
   }
 };
 
 // x86-32 Windows target
 class WindowsX86_32TargetInfo : public WindowsTargetInfo<X86_32TargetInfo> {
-public:
-  WindowsX86_32TargetInfo(const llvm::Triple &Triple)
-      : WindowsTargetInfo<X86_32TargetInfo>(Triple) {
-    WCharType = UnsignedShort;
-    DoubleAlign = LongLongAlign = 64;
+  void setDataLayoutString() override {
     bool IsWinCOFF =
         getTriple().isOSWindows() && getTriple().isOSBinFormatCOFF();
     DataLayoutString = IsWinCOFF
                            ? "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
                            : "e-m:e-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32";
   }
+public:
+  WindowsX86_32TargetInfo(const llvm::Triple &Triple)
+      : WindowsTargetInfo<X86_32TargetInfo>(Triple) {
+    WCharType = UnsignedShort;
+    DoubleAlign = LongLongAlign = 64;
+  }
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override {
     WindowsTargetInfo<X86_32TargetInfo>::getTargetDefines(Opts, Builder);
   }
 };
 
 // x86-32 Windows Visual Studio target
 class MicrosoftX86_32TargetInfo : public WindowsX86_32TargetInfo {
void getTargetDefines(const LangOptions &Opts,
     DefineStd(Builder, "WINNT", Opts);
     Builder.defineMacro("_X86_");
     addMinGWDefines(Opts, Builder);
   }
 };
 
 // x86-32 Cygwin target
 class CygwinX86_32TargetInfo : public X86_32TargetInfo {
+  void setDataLayoutString() override {
+    DataLayoutString = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32";
+  }
 public:
   CygwinX86_32TargetInfo(const llvm::Triple &Triple)
       : X86_32TargetInfo(Triple) {
     TLSSupported = false;
     WCharType = UnsignedShort;
     DoubleAlign = LongLongAlign = 64;
-    DataLayoutString = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32";
   }
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override {
     X86_32TargetInfo::getTargetDefines(Opts, Builder);
     Builder.defineMacro("_X86_");
     Builder.defineMacro("__CYGWIN__");
     Builder.defineMacro("__CYGWIN32__");
     addCygMingDefines(Opts, Builder);
TargetInfo::CreateTargetInfo(DiagnosticsEngine &Diags,
   // Add the features to the compile options.
   Opts->Features.clear();
   for (const auto &F : Features)
     Opts->Features.push_back((F.getValue() ? "+" : "-") + F.getKey().str());
 
   if (!Target->handleTargetFeatures(Opts->Features, Diags))
     return nullptr;
 
+  if (!Target->handleLLVMArgs(Opts->LLVMArgs))
+    return nullptr;
+
   return Target.release();
 }

lib/Driver/Tools.cpp

if (Arg *A = Args.getLastArg(options::OPT_masm_EQ)) {
     if (Value == "intel" || Value == "att") {
       CmdArgs.push_back("-mllvm");
       CmdArgs.push_back(Args.MakeArgString("-x86-asm-syntax=" + Value));
     } else {
       getToolChain().getDriver().Diag(diag::err_drv_unsupported_option_argument)
           << A->getOption().getName() << Value;
     }
   }
+
+  if (Args.getLastArg(options::OPT_malign_double)) {
+    CmdArgs.push_back("-mllvm");
+    CmdArgs.push_back("-malign-double");
+  }
 }
 
 void Clang::AddHexagonTargetArgs(const ArgList &Args,
                                  ArgStringList &CmdArgs) const {
   CmdArgs.push_back("-mqdsp6-compat");
   CmdArgs.push_back("-Wreturn-type");
 
   if (const char *v =

lib/Frontend/CompilerInvocation.cpp

static void ParseTargetArgs(TargetOptions &Opts, ArgList &Args) {
   using namespace options;
   Opts.ABI = Args.getLastArgValue(OPT_target_abi);
   Opts.CPU = Args.getLastArgValue(OPT_target_cpu);
   Opts.FPMath = Args.getLastArgValue(OPT_mfpmath);
   Opts.FeaturesAsWritten = Args.getAllArgValues(OPT_target_feature);
   Opts.LinkerVersion = Args.getLastArgValue(OPT_target_linker_version);
   Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple));
   Opts.Reciprocals = Args.getAllArgValues(OPT_mrecip_EQ);
+  Opts.LLVMArgs = Args.getAllArgValues(OPT_mllvm);
   // Use the default target triple if unspecified.
   if (Opts.Triple.empty())
     Opts.Triple = llvm::sys::getDefaultTargetTriple();
 }
 
 bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res,
                                         const char *const *ArgBegin,
                                         const char *const *ArgEnd,

test/Driver/malign-double.c

+// RUN: %clang -v -c -malign-double %s -target i686-unknown-linux 2>&1 \
+// RUN:   | FileCheck --check-prefix=CHECK-I686 %s
+
+// CHECK-I686: -cc1
+// CHECK-I686: -mllvm -malign-double
+// CHECK-I686-NOT: backend data layout {{'[^']+'}} does not match expected target description {{'[^']+'}}
+
+// RUN: %clang -v -c -malign-double %s -target x86_64-unknown-linux 2>&1 \
+// RUN:   | FileCheck --check-prefix=CHECK-X86_64 %s
+
+// CHECK-X86_64: -cc1
+// CHECK-X86_64: -mllvm -malign-double
+
+// RUN: not %clang -v -c -mno-align-double %s -target i686-unknown-linux 2>&1 \
+// RUN:   | FileCheck --check-prefix=CHECK-NO-I686 %s
+
+// CHECK-NO-I686: unknown argument: '-mno-align-double'
+
+// RUN: not %clang -v -c -mno-align-double %s -target x86_64-unknown-linux 2>&1 \
+// RUN:   | FileCheck --check-prefix=CHECK-NO-X86_64 %s
+
+// CHECK-NO-X86_64: unknown argument: '-mno-align-double'