[WIP] Add support for -falign-functions and -falign-functions= options.

include/clang/Basic/DiagnosticDriverKinds.td

 def err_drv_unknown_objc_runtime : Error<
   "unknown or ill-formed Objective-C runtime '%0'">;
 def err_drv_emit_llvm_link : Error<
    "-emit-llvm cannot be used when linking">;
 def err_drv_optimization_remark_pattern : Error<
   "%0 in '%1'">;
 def err_drv_no_neon_modifier : Error<"[no]neon is not accepted as modifier, please use [no]simd instead">;
 
+def err_drv_align_opt_pos_int : Error<"argument '%1' to '-%0' should be a non-negative integer">;
+def err_drv_align_opt_pow2 : Error<"argument '%1' to '-%0' is not a positive power of 2">;
+def err_drv_align_opt_too_large : Error<"argument '%1' to '-%0' should be %2 or smaller">;
+
 def warn_O4_is_O3 : Warning<"-O4 is equivalent to -O3">, InGroup<Deprecated>;
 def warn_drv_lto_libpath : Warning<"libLTO.dylib relative to clang installed dir not found; using 'ld' default search path instead">,
   InGroup<LibLTO>;
 def warn_drv_optimization_value : Warning<"optimization level '%0' is not supported; using '%1%2' instead">,
   InGroup<InvalidCommandLineArgument>;
 def warn_ignored_gcc_optimization : Warning<"optimization flag '%0' is not supported">,
   InGroup<IgnoredOptimizationArgument>;
 def warn_c_kext : Warning<

include/clang/Driver/Options.td

def Zlinker_input : Separate<["-"], "Zlinker-input">,
     Flags<[Unsupported, NoArgumentUnused]>;
 
 // Reserved library options.
 def Z_reserved_lib_stdcxx : Flag<["-"], "Z-reserved-lib-stdc++">,
     Flags<[LinkerInput, NoArgumentUnused, Unsupported]>, Group<reserved_lib_Group>;
 def Z_reserved_lib_cckext : Flag<["-"], "Z-reserved-lib-cckext">,
     Flags<[LinkerInput, NoArgumentUnused, Unsupported]>, Group<reserved_lib_Group>;
 
+def falign_functions : Flag<["-"], "falign-functions">, Group<f_Group>, Flags<[CC1Option]>;
+def fno_align_functions : Flag<["-"], "fno-align-functions">, Group<f_Group>;
+def falign_functions_EQ : Joined<["-"], "falign-functions=">, Group<f_Group>, Flags<[CC1Option]>;
+
 // Ignored options
 // FIXME: multiclasess produce suffixes, not prefixes. This is fine for now
 // since it is only used in ignored options.
 multiclass BooleanFFlag<string name> {
   def _f : Flag<["-"], "f"#name>;
   def _fno : Flag<["-"], "fno-"#name>;
 }
 
 defm : BooleanFFlag<"keep-inline-functions">, Group<clang_ignored_gcc_optimization_f_Group>;
 
 def fprofile_dir : Joined<["-"], "fprofile-dir=">, Group<clang_ignored_gcc_optimization_f_Group>;
 
 def fuse_ld_EQ : Joined<["-"], "fuse-ld=">, Group<f_Group>;
 
-defm align_functions : BooleanFFlag<"align-functions">, Group<clang_ignored_gcc_optimization_f_Group>;
-def falign_functions_EQ : Joined<["-"], "falign-functions=">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm align_labels : BooleanFFlag<"align-labels">, Group<clang_ignored_gcc_optimization_f_Group>;
 def falign_labels_EQ : Joined<["-"], "falign-labels=">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm align_loops : BooleanFFlag<"align-loops">, Group<clang_ignored_gcc_optimization_f_Group>;
 def falign_loops_EQ : Joined<["-"], "falign-loops=">, Group<clang_ignored_gcc_optimization_f_Group>;
 defm align_jumps : BooleanFFlag<"align-jumps">, Group<clang_ignored_gcc_optimization_f_Group>;
 def falign_jumps_EQ : Joined<["-"], "falign-jumps=">, Group<clang_ignored_gcc_optimization_f_Group>;
 
 // FIXME: This option should be supported and wired up to our diognostics, but

include/clang/Frontend/CodeGenOptions.def

 CODEGENOPT(UnrollLoops       , 1, 0) ///< Control whether loops are unrolled.
 CODEGENOPT(RerollLoops       , 1, 0) ///< Control whether loops are rerolled.
 CODEGENOPT(UnsafeFPMath      , 1, 0) ///< Allow unsafe floating point optzns.
 CODEGENOPT(UnwindTables      , 1, 0) ///< Emit unwind tables.
 CODEGENOPT(VectorizeBB       , 1, 0) ///< Run basic block vectorizer.
 CODEGENOPT(VectorizeLoop     , 1, 0) ///< Run loop vectorizer.
 CODEGENOPT(VectorizeSLP      , 1, 0) ///< Run SLP vectorizer.
 
+CODEGENOPT(AlignFunctions    , 1, 0) ///< Set when -falign-functions is enabled.
+CODEGENOPT(AlignFunctionsBytes, 32,  0) ///< Set when -falign-functions= is defined.
+
   /// Attempt to use register sized accesses to bit-fields in structures, when
   /// possible.
 CODEGENOPT(UseRegisterSizedBitfieldAccess , 1, 0)
 
 CODEGENOPT(VerifyModule      , 1, 1) ///< Control whether the module should be run
                                      ///< through the LLVM Verifier.
 
 CODEGENOPT(StackRealignment  , 1, 0) ///< Control whether to force stack

lib/CodeGen/CodeGenModule.cpp

void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D,
   }
 
   if (isa<CXXConstructorDecl>(D) || isa<CXXDestructorDecl>(D))
     F->setUnnamedAddr(true);
   else if (const auto *MD = dyn_cast<CXXMethodDecl>(D))
     if (MD->isVirtual())
       F->setUnnamedAddr(true);
 
-  unsigned alignment = D->getMaxAlignment() / Context.getCharWidth();
-  if (alignment)
-    F->setAlignment(alignment);
+  unsigned Alignment = D->getMaxAlignment() / Context.getCharWidth();
+  // Honor -falign-functions=*.
+  if (CodeGenOpts.AlignFunctionsBytes)
+    Alignment = std::max(Alignment, CodeGenOpts.AlignFunctionsBytes);
+  if (Alignment)
+    F->setAlignment(Alignment);
 
   // Some C++ ABIs require 2-byte alignment for member functions, in order to
   // reserve a bit for differentiating between virtual and non-virtual member
   // functions. If the current target's C++ ABI requires this and this is a
   // member function, set its alignment accordingly.
   if (getTarget().getCXXABI().areMemberFunctionsAligned()) {
     if (F->getAlignment() < 2 && isa<CXXMethodDecl>(D))
       F->setAlignment(2);

lib/Driver/Tools.cpp

if (S.getAsInteger(10, OptLevel))
       return false;
 
     return OptLevel > 1;
   }
 
   return false;
 }
 
+static bool shouldEnableAlignOpt(const ArgList &Args) {
+  if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
+    if (A->getOption().matches(options::OPT_O)) {
+      StringRef S(A->getValue());
+      return S != "s" && S != "z";
+    }
+  }
+  return true;
+}
+
 /// Add -x lang to \p CmdArgs for \p Input.
 static void addDashXForInput(const ArgList &Args, const InputInfo &Input,
                              ArgStringList &CmdArgs) {
   // When using -verify-pch, we don't want to provide the type
   // 'precompiled-header' if it was inferred from the file extension
   if (Args.hasArg(options::OPT_verify_pch) && Input.getType() == types::TY_PCH)
     return;
 
if (Args.hasFlag(options::OPT_fblocks, options::OPT_fno_blocks,
        !Args.hasArg(options::OPT_fno_blocks))) {
     CmdArgs.push_back("-fblocks");
 
     if (!Args.hasArg(options::OPT_fgnu_runtime) &&
         !getToolChain().hasBlocksRuntime())
       CmdArgs.push_back("-fblocks-runtime-optional");
   }
 
+  // -fno-align-function is default.
+  if (Arg *A = Args.getLastArg(options::OPT_falign_functions,
+                               options::OPT_falign_functions_EQ,
+                               options::OPT_falign_functions)) {
+    // These alignment optimizations are disabled with -Os and -Oz.
+    if (shouldEnableAlignOpt(Args)) {
+      if (A->getOption().matches(options::OPT_falign_functions))
+        CmdArgs.push_back("-falign-functions");
+      else if (A->getOption().matches(options::OPT_falign_functions_EQ)) {
+        StringRef BytesStr(A->getValue());
+        int Bytes = 0;
+        bool Error = false;
+        // The argument should be a non-negative integer.
+        if (BytesStr.getAsInteger(10, Bytes) || Bytes < 0) {
+          Error = true;
+          D.Diag(diag::err_drv_align_opt_pos_int) << A->getOption().getName() << BytesStr;
+        }
+        // The argument should be a power of 2.
+        if (!Error && !llvm::isPowerOf2_32(Bytes)) {
+          Error = true;
+          D.Diag(diag::err_drv_align_opt_pow2) << A->getOption().getName() << BytesStr;
+        }
+        // The argument shouldn't be too large.
+        if (!Error && Bytes > 0x10000000) {
+          Error = true;
+          D.Diag(diag::err_drv_align_opt_too_large) << A->getOption().getName() << BytesStr << 268435456;
+        }
+        // -falign-functions=1 is equivalent to -fno-align-functions.
+        if (!Error && Bytes != 1)
+          CmdArgs.push_back(Args.MakeArgString("-falign-functions=" + BytesStr));
+      }
+    }
+  }
+
   // -fmodules enables the use of precompiled modules (off by default).
   // Users can pass -fno-cxx-modules to turn off modules support for
   // C++/Objective-C++ programs.
   bool HaveModules = false;
   if (Args.hasFlag(options::OPT_fmodules, options::OPT_fno_modules, false)) {
     bool AllowedInCXX = Args.hasFlag(options::OPT_fcxx_modules,
                                      options::OPT_fno_cxx_modules, true);
     if (AllowedInCXX || !types::isCXX(InputType)) {

lib/Frontend/CompilerInvocation.cpp

static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
   }
 
   Opts.MSVolatile = Args.hasArg(OPT_fms_volatile);
 
   Opts.VectorizeBB = Args.hasArg(OPT_vectorize_slp_aggressive);
   Opts.VectorizeLoop = Args.hasArg(OPT_vectorize_loops);
   Opts.VectorizeSLP = Args.hasArg(OPT_vectorize_slp);
 
+  Opts.AlignFunctions = Args.hasArg(OPT_falign_functions);
+  if (Arg *A = Args.getLastArg(OPT_falign_functions_EQ)) {
+    StringRef Val = A->getValue();
+    unsigned Bytes = 0;
+    Val.getAsInteger(10, Bytes);
+    Opts.AlignFunctionsBytes = Bytes;
+  }
+
   Opts.MainFileName = Args.getLastArgValue(OPT_main_file_name);
   Opts.VerifyModule = !Args.hasArg(OPT_disable_llvm_verifier);
 
   Opts.DisableGCov = Args.hasArg(OPT_test_coverage);
   Opts.EmitGcovArcs = Args.hasArg(OPT_femit_coverage_data);
   Opts.EmitGcovNotes = Args.hasArg(OPT_femit_coverage_notes);
   if (Opts.EmitGcovArcs || Opts.EmitGcovNotes) {
     Opts.CoverageFile = Args.getLastArgValue(OPT_coverage_file);

test/CodeGen/func-aligned.c

 // RUN: %clang_cc1 -triple x86_64-apple-darwin %s -emit-llvm -o - | FileCheck %s
+// RUN: %clang_cc1 -triple x86_64-apple-darwin %s -falign-functions=128 -emit-llvm -o - | FileCheck -check-prefix=FALIGN-FUNC %s
 
 // rdar://7270273
 void foo() __attribute__((aligned (64)));
 void foo() {
 // CHECK: define void @foo() {{.*}} align 64
 }
+
+// The function should be aligned based on the command line option.
+void test1() {
+// FALIGN-FUNC: define void @test1() {{.*}} align 128
+}
+
+// The function alignment specified on the command line should override that
+// specified by the attribute.
+void test2() __attribute__((aligned (64)));
+void test2() {
+// FALIGN-FUNC: define void @test2() {{.*}} align 128
+}

test/Driver/clang_f_opts.c

 // RUN: -fexpensive-optimizations                                             \
 // RUN: -fno-expensive-optimizations                                          \
 // RUN: -fno-defer-pop                                                        \
 // RUN: -finline-functions                                                    \
 // RUN: -fkeep-inline-functions                                               \
 // RUN: -fno-keep-inline-functions                                            \
 // RUN: -freorder-blocks                                                      \
 // RUN: -fprofile-dir=/rand/dir                                               \
-// RUN: -falign-functions                                                     \
-// RUN: -falign-functions=1                                                   \
 // RUN: -ffloat-store                                                         \
 // RUN: -fgcse                                                                \
 // RUN: -fivopts                                                              \
 // RUN: -fprefetch-loop-arrays                                                \
 // RUN: -fprofile-correction                                                  \
 // RUN: -fprofile-values                                                      \
 // RUN: -frounding-math                                                       \
 // RUN: -fschedule-insns                                                      \

 // CHECK-WARNING-DAG: optimization flag '-fexpensive-optimizations' is not supported
 // CHECK-WARNING-DAG: optimization flag '-fno-expensive-optimizations' is not supported
 // CHECK-WARNING-DAG: optimization flag '-fno-defer-pop' is not supported
 // CHECK-WARNING-DAG: optimization flag '-finline-functions' is not supported
 // CHECK-WARNING-DAG: optimization flag '-fkeep-inline-functions' is not supported
 // CHECK-WARNING-DAG: optimization flag '-fno-keep-inline-functions' is not supported
 // CHECK-WARNING-DAG: optimization flag '-freorder-blocks' is not supported
 // CHECK-WARNING-DAG: optimization flag '-fprofile-dir=/rand/dir' is not supported
-// CHECK-WARNING-DAG: optimization flag '-falign-functions' is not supported
-// CHECK-WARNING-DAG: optimization flag '-falign-functions=1' is not supported
 // CHECK-WARNING-DAG: optimization flag '-ffloat-store' is not supported
 // CHECK-WARNING-DAG: optimization flag '-fgcse' is not supported
 // CHECK-WARNING-DAG: optimization flag '-fivopts' is not supported
 // CHECK-WARNING-DAG: optimization flag '-fprefetch-loop-arrays' is not supported
 // CHECK-WARNING-DAG: optimization flag '-fprofile-correction' is not supported
 // CHECK-WARNING-DAG: optimization flag '-fprofile-values' is not supported
 // CHECK-WARNING-DAG: optimization flag '-frounding-math' is not supported
 // CHECK-WARNING-DAG: optimization flag '-fschedule-insns' is not supported

 // Make sure we don't match the -NOT lines with the linker invocation.
 // Delimiters match the start of the cc1 and the start of the linker lines
 // DELIMITERS: {{^ *"}}
 // CHECK-WCHAR1: -fno-short-wchar
 // CHECK-WCHAR1-NOT: -fshort-wchar
 // CHECK-WCHAR2: -fshort-wchar
 // CHECK-WCHAR2-NOT: -fno-short-wchar
 // DELIMITERS: {{^ *"}}
+
+// RUN: %clang -### -S -falign-functions %s 2>&1 | FileCheck -check-prefix=CHECK-FALIGN-FUNCTIONS %s
+// RUN: %clang -### -S -O0 -falign-functions %s 2>&1 | FileCheck -check-prefix=CHECK-FALIGN-FUNCTIONS %s
+// RUN: %clang -### -S -O1 -falign-functions %s 2>&1 | FileCheck -check-prefix=CHECK-FALIGN-FUNCTIONS %s
+// RUN: %clang -### -S -O2 -falign-functions %s 2>&1 | FileCheck -check-prefix=CHECK-FALIGN-FUNCTIONS %s
+// RUN: %clang -### -S -O3 -falign-functions %s 2>&1 | FileCheck -check-prefix=CHECK-FALIGN-FUNCTIONS %s
+// RUN: %clang -### -S -Ofast -falign-functions %s 2>&1 | FileCheck -check-prefix=CHECK-FALIGN-FUNCTIONS %s
+// CHECK-FALIGN-FUNCTIONS: -falign-functions
+
+// RUN: %clang -### -S -falign-functions=2 %s 2>&1 | FileCheck -check-prefix=CHECK-FALIGN-FUNCTIONS_EQ %s
+// RUN: %clang -### -S -O0 -falign-functions=4 %s 2>&1 | FileCheck -check-prefix=CHECK-FALIGN-FUNCTIONS_EQ %s
+// RUN: %clang -### -S -O1 -falign-functions=8 %s 2>&1 | FileCheck -check-prefix=CHECK-FALIGN-FUNCTIONS_EQ %s
+// RUN: %clang -### -S -O2 -falign-functions=16 %s 2>&1 | FileCheck -check-prefix=CHECK-FALIGN-FUNCTIONS_EQ %s
+// RUN: %clang -### -S -O3 -falign-functions=32 %s 2>&1 | FileCheck -check-prefix=CHECK-FALIGN-FUNCTIONS_EQ %s
+// RUN: %clang -### -S -Ofast -falign-functions=16 %s 2>&1 | FileCheck -check-prefix=CHECK-FALIGN-FUNCTIONS_EQ %s
+// CHECK-FALIGN-FUNCTIONS_EQ: -falign-functions=
+
+// Argument to -falign-functions= should be a non-negative integer
+// RUN: %clang -### -S -falign-functions=-8 %s 2>&1 | FileCheck -check-prefix=CHECK-FALIGN-FUNCTIONS_EQ1 %s
+// CHECK-FALIGN-FUNCTIONS_EQ1: argument '-8' to '-falign-functions=' should be a non-negative integer
+// RUN: %clang -### -S -falign-functions=abc %s 2>&1 | FileCheck -check-prefix=CHECK-FALIGN-FUNCTIONS_EQ2 %s
+// CHECK-FALIGN-FUNCTIONS_EQ2: argument 'abc' to '-falign-functions=' should be a non-negative integer
+
+// Argument to -falign-functions= should be a power of 2.
+// RUN: %clang -### -S -falign-functions=11 %s 2>&1 | FileCheck -check-prefix=CHECK-FALIGN-FUNCTIONS_EQ3 %s
+// CHECK-FALIGN-FUNCTIONS_EQ3: argument '11' to '-falign-functions=' is not a positive power of 2
+
+// Argument to -falign-functions= shouldn't be too big.
+// RUN: %clang -### -S -falign-functions=1073741824 %s 2>&1 | FileCheck -check-prefix=CHECK-FALIGN-FUNCTIONS_EQ4 %s
+// CHECK-FALIGN-FUNCTIONS_EQ4: argument '1073741824' to '-falign-functions=' should be 268435456 or smaller
+
+// -falign-functions is disabled when optimizing for size.
+// RUN: %clang -### -S -Os -falign-functions %s 2>&1 | FileCheck -check-prefix=CHECK-FALIGN-FUNCTIONS-OSIZE %s
+// RUN: %clang -### -S -Oz -falign-functions %s 2>&1 | FileCheck -check-prefix=CHECK-FALIGN-FUNCTIONS-OSIZE %s
+
+// -falign-functions=1 is equivalent to -fno-align-functions.
+// RUN: %clang -### -S -O3 -falign-functions=1 %s 2>&1 | FileCheck -check-prefix=CHECK-FALIGN-FUNCTIONS-OSIZE %s
+
+// CHECK-FALIGN-FUNCTIONS-OSIZE-NOT: -falign-functions