Add -fno-jump-tables and-fjump-tables flags

[niravd]

Summary

These flags toggle the addition of the nousejumptable function
attribute introduced in D18321.

[echristo]

Hrm. So it can be changed in the future do we want it to be a string attribute similar to use-soft-float rather than a hard coded one? (I think the answer is "probably")

-eric

[niravd]

Modification to use soft attrbiutes as suggested

[hans]

Besides a few nits, this looks good as far as I can tell. Eric should probably sign off on it, though.

include/clang/Driver/Options.td

590

It's not just the size of the switch, but also the density, etc.

I think it would make more sense to add HelpText to the -fno flag below instead. How about:

"Do not use jump tables for lowering switches"

lib/CodeGen/CodeGenFunction.cpp

715

nit: period at the end of comment, and 80+ column line

test/CodeGen/nousejumptable.c

4

ultra nit: there's usually a space between the // and CHECK

7

Is there a need for volatile here? Otherwise, drop it.

[niravd]

Change help message and update nojumptable test for new string attribute

include/clang/Driver/Options.td

590

This is help message for from GCC, but I agree this is clearer

[mehdi_amini]

test/CodeGen/nousejumptable.c

44

The only thing this test does is checking for the attribute. All the code is useless. You can have a single function

define void @foo() {
   ret void
}

And it should be enough to check that the attribute is added

[niravd]

Simplify test

[niravd]

I'm waiting for an official okay from someone on this.

[hans]

LGTM

include/clang/Frontend/CodeGenOptions.def

154

ultra nit: period at end of comment

include/clang/Driver/Options.td

HelpText<"Enable the *frontend*'s 'fast-math' mode. This has no effect on "
            "same as GCC's -ffast-math flag">;
 def fno_fast_math : Flag<["-"], "fno-fast-math">, Group<f_Group>;
 def fmath_errno : Flag<["-"], "fmath-errno">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Require math functions to indicate errors by setting errno">;
 def fno_math_errno : Flag<["-"], "fno-math-errno">, Group<f_Group>;
 def fbracket_depth_EQ : Joined<["-"], "fbracket-depth=">, Group<f_Group>;
 def fsignaling_math : Flag<["-"], "fsignaling-math">, Group<f_Group>;
 def fno_signaling_math : Flag<["-"], "fno-signaling-math">, Group<f_Group>;
+def fjump_tables : Flag<["-"], "fjump-tables">, Group<f_Group>,
+  HelpText<"Use jump tables for sufficiently large switch">;
+def fno_jump_tables : Flag<["-"], "fno-jump-tables">, Group<f_Group>, Flags<[CC1Option]>;
 def fsanitize_EQ : CommaJoined<["-"], "fsanitize=">, Group<f_clang_Group>,
                    Flags<[CC1Option, CoreOption]>, MetaVarName<"<check>">,
                    HelpText<"Turn on runtime checks for various forms of undefined "
                             "or suspicious behavior. See user manual for available checks">;
 def fno_sanitize_EQ : CommaJoined<["-"], "fno-sanitize=">, Group<f_clang_Group>,
                       Flags<[CoreOption]>;
 def fsanitize_blacklist : Joined<["-"], "fsanitize-blacklist=">,
                           Group<f_clang_Group>, Flags<[CC1Option, CoreOption]>,

include/clang/Frontend/CodeGenOptions.def

 CODEGENOPT(SoftFloat         , 1, 0) ///< -soft-float.
 CODEGENOPT(StrictEnums       , 1, 0) ///< Optimize based on strict enum definition.
 CODEGENOPT(StrictVTablePointers, 1, 0) ///< Optimize based on the strict vtable pointers
 CODEGENOPT(TimePasses        , 1, 0) ///< Set when -ftime-report is enabled.
 CODEGENOPT(UnitAtATime       , 1, 1) ///< Unused. For mirroring GCC optimization
                                      ///< selection.
 CODEGENOPT(UnrollLoops       , 1, 0) ///< Control whether loops are unrolled.
 CODEGENOPT(RerollLoops       , 1, 0) ///< Control whether loops are rerolled.
+CODEGENOPT(NoUseJumpTables   , 1, 0) ///< Set when -fno-jump-tables is enabled
 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.
 
   /// Attempt to use register sized accesses to bit-fields in structures, when
   /// possible.

lib/CodeGen/CodeGenFunction.cpp

if (!CGM.getCodeGenOpts().NoInline) {
         if (RI->isInlineSpecified()) {
           Fn->addFnAttr(llvm::Attribute::InlineHint);
           break;
         }
     } else if (!FD->hasAttr<AlwaysInlineAttr>())
       Fn->addFnAttr(llvm::Attribute::NoInline);
   }
 
+  //If -fno-jump-tables pass it as Fn Attr. 
+  if (CGM.getCodeGenOpts().NoUseJumpTables) 
+    Fn->addFnAttr(llvm::Attribute::NoUseJumpTable);
+
   if (getLangOpts().OpenCL) {
     // Add metadata for a kernel function.
     if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(D))
       EmitOpenCLKernelMetadata(FD, Fn);
   }
 
   // If we are checking function types, emit a function type signature as
   // prologue data.

lib/Driver/Tools.cpp

#endif
 
   if (Arg *A = Args.getLastArg(options::OPT_Wframe_larger_than_EQ)) {
     StringRef v = A->getValue();
     CmdArgs.push_back("-mllvm");
     CmdArgs.push_back(Args.MakeArgString("-warn-stack-size=" + v));
     A->claim();
   }
 
+  if (!Args.hasFlag(options::OPT_fjump_tables, options::OPT_fno_jump_tables,
+                    true))
+    CmdArgs.push_back("-fno-jump-tables");
+
   if (Arg *A = Args.getLastArg(options::OPT_mregparm_EQ)) {
     CmdArgs.push_back("-mregparm");
     CmdArgs.push_back(A->getValue());
   }
 
   if (Arg *A = Args.getLastArg(options::OPT_fpcc_struct_return,
                                options::OPT_freg_struct_return)) {
     if (getToolChain().getArch() != llvm::Triple::x86) {

lib/Frontend/CompilerInvocation.cpp

Opts.FunctionSections = Args.hasFlag(OPT_ffunction_sections,
                                        OPT_fno_function_sections, false);
   Opts.DataSections = Args.hasFlag(OPT_fdata_sections,
                                    OPT_fno_data_sections, false);
   Opts.UniqueSectionNames = Args.hasFlag(OPT_funique_section_names,
                                          OPT_fno_unique_section_names, true);
 
   Opts.MergeFunctions = Args.hasArg(OPT_fmerge_functions);
 
+  Opts.NoUseJumpTables = Args.hasArg(OPT_fno_jump_tables);
+
   Opts.PrepareForLTO = Args.hasArg(OPT_flto, OPT_flto_EQ);
   const Arg *A = Args.getLastArg(OPT_flto, OPT_flto_EQ);
   Opts.EmitSummaryIndex = A && A->containsValue("thin");
   if (Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) {
     if (IK != IK_LLVM_IR)
       Diags.Report(diag::err_drv_argument_only_allowed_with)
           << A->getAsString(Args) << "-x ir";
     Opts.ThinLTOIndexFile = Args.getLastArgValue(OPT_fthinlto_index_EQ);

test/CodeGen/nousejumptable.c

+// RUN: %clang_cc1 -S -fno-jump-tables %s -emit-llvm -o - | FileCheck %s
+
+//CHECK: Function Attrs: nounwind nousejumptable
+//CHECK-LABEL: @main()
+
+volatile static unsigned choice;
+void ret_A();
+void ret_B();
+void ret_C();
+void ret_D();
+void ret_E();
+void ret_F();
+void ret_G();
+void ret_H();
+
+int main(){
+
+  switch(choice){
+    case 0: ret_A(); break;
+    case 1: ret_B(); break;
+    case 2: ret_C(); break;
+    case 3: ret_D(); break;
+    case 4: ret_E(); break;
+    case 5: ret_F(); break;
+    case 6: ret_G(); break;
+    case 7: ret_H(); break;
+  }
+
+}