[Driver] Add a cc1 flag for the new TBAA metadata format

[kosarev]

Summary

This patch starts a series of changes to add support for the new TBAA metadata format proposed in this llvm-dev thread:

http://lists.llvm.org/pipermail/llvm-dev/2017-November/118748.html

[rjmccall]

We don't want this to become a long-term feature; we just want to switch the implementation over to the new format. Is there a good reason not to do that in one patch? If so, adding an option is acceptable, but it should be a -cc1 option only, because it is purely a testing option.

[kosarev]

Adding a (temporary) flag for the new format would help with updating tests that depend on the shape of TBAA metadata. There are lots of them and I guess some change frequently so we may want to address this in a few patches. That would also reduce the pressure on those who are in process of preparing new patches. So yes, if we can live with both the formats for some time, then that would make the transition easier for all concerned.

Will remove the clang option from the patch. We don't need it indeed. Thanks for pointing out.

[rjmccall]

Okay. I'm fine with living with both formats as long as we're not exposing this as a feature.

[kosarev]

Removed the clang command-line flag for the new format.

[rjmccall]

LGTM.

include/clang/Driver/CC1Options.td

 def dump_coverage_mapping : Flag<["-"], "dump-coverage-mapping">,
   HelpText<"Dump the coverage mapping records, for testing">;
 def fuse_register_sized_bitfield_access: Flag<["-"], "fuse-register-sized-bitfield-access">,
   HelpText<"Use register sized accesses to bit-fields, when possible.">;
 def relaxed_aliasing : Flag<["-"], "relaxed-aliasing">,
   HelpText<"Turn off Type Based Alias Analysis">;
 def no_struct_path_tbaa : Flag<["-"], "no-struct-path-tbaa">,
   HelpText<"Turn off struct-path aware Type Based Alias Analysis">;
+def new_struct_path_tbaa : Flag<["-"], "new-struct-path-tbaa">,
+  HelpText<"Enable enhanced struct-path aware Type Based Alias Analysis">;
 def masm_verbose : Flag<["-"], "masm-verbose">,
   HelpText<"Generate verbose assembly output">;
 def mcode_model : Separate<["-"], "mcode-model">,
   HelpText<"The code model to use">, Values<"small,kernel,medium,large">;
 def mdebug_pass : Separate<["-"], "mdebug-pass">,
   HelpText<"Enable additional debug output">;
 def mdisable_fp_elim : Flag<["-"], "mdisable-fp-elim">,
   HelpText<"Disable frame pointer elimination optimization">;

include/clang/Driver/Options.td

def fdiagnostics_absolute_paths : Flag<["-"], "fdiagnostics-absolute-paths">, Group<f_Group>,
   Flags<[CC1Option, CoreOption]>, HelpText<"Print absolute paths in diagnostics">;
 def fno_spell_checking : Flag<["-"], "fno-spell-checking">, Group<f_Group>,
   Flags<[CC1Option]>, HelpText<"Disable spell-checking">;
 def fno_stack_protector : Flag<["-"], "fno-stack-protector">, Group<f_Group>,
   HelpText<"Disable the use of stack protectors">;
 def fno_strict_aliasing : Flag<["-"], "fno-strict-aliasing">, Group<f_Group>,
   Flags<[DriverOption, CoreOption]>;
 def fstruct_path_tbaa : Flag<["-"], "fstruct-path-tbaa">, Group<f_Group>;
+def fnew_struct_path_tbaa : Flag<["-"], "fnew-struct-path-tbaa">, Group<f_Group>;
 def fno_struct_path_tbaa : Flag<["-"], "fno-struct-path-tbaa">, Group<f_Group>;
 def fno_strict_enums : Flag<["-"], "fno-strict-enums">, Group<f_Group>;
 def fno_strict_vtable_pointers: Flag<["-"], "fno-strict-vtable-pointers">,
   Group<f_Group>;
 def fno_strict_overflow : Flag<["-"], "fno-strict-overflow">, Group<f_Group>;
 def fno_threadsafe_statics : Flag<["-"], "fno-threadsafe-statics">, Group<f_Group>,
   Flags<[CC1Option]>, HelpText<"Do not emit code to make initialization of local statics thread safe">;
 def fno_use_cxa_atexit : Flag<["-"], "fno-use-cxa-atexit">, Group<f_Group>, Flags<[CC1Option]>,

include/clang/Frontend/CodeGenOptions.def

CODEGENOPT(DumpCoverageMapping , 1, 0) ///< Dump the generated coverage mapping
                                        ///< regions.
 
   /// If -fpcc-struct-return or -freg-struct-return is specified.
 ENUM_CODEGENOPT(StructReturnConvention, StructReturnConventionKind, 2, SRCK_Default)
 
 CODEGENOPT(RelaxAll          , 1, 0) ///< Relax all machine code instructions.
 CODEGENOPT(RelaxedAliasing   , 1, 0) ///< Set when -fno-strict-aliasing is enabled.
 CODEGENOPT(StructPathTBAA    , 1, 0) ///< Whether or not to use struct-path TBAA.
+CODEGENOPT(NewStructPathTBAA , 1, 0) ///< Whether or not to use new struct-path TBAA.
 CODEGENOPT(SaveTempLabels    , 1, 0) ///< Save temporary labels.
 CODEGENOPT(SanitizeAddressUseAfterScope , 1, 0) ///< Enable use-after-scope detection
                                                 ///< in AddressSanitizer
 CODEGENOPT(SanitizeAddressGlobalsDeadStripping, 1, 0) ///< Enable linker dead stripping
                                                       ///< of globals in AddressSanitizer
 CODEGENOPT(SanitizeMemoryTrackOrigins, 2, 0) ///< Enable tracking origins in
                                              ///< MemorySanitizer
 CODEGENOPT(SanitizeMemoryUseAfterDtor, 1, 0) ///< Enable use-after-delete detection

lib/Driver/ToolChains/Clang.cpp

#endif
   OptSpecifier StrictAliasingAliasOption =
       OFastEnabled ? options::OPT_Ofast : options::OPT_fstrict_aliasing;
   // We turn strict aliasing off by default if we're in CL mode, since MSVC
   // doesn't do any TBAA.
   bool TBAAOnByDefault = !D.IsCLMode();
   if (!Args.hasFlag(options::OPT_fstrict_aliasing, StrictAliasingAliasOption,
                     options::OPT_fno_strict_aliasing, TBAAOnByDefault))
     CmdArgs.push_back("-relaxed-aliasing");
-  if (!Args.hasFlag(options::OPT_fstruct_path_tbaa,
-                    options::OPT_fno_struct_path_tbaa))
+  bool StructPathTBAA = Args.hasFlag(options::OPT_fstruct_path_tbaa,
+                                     options::OPT_fno_struct_path_tbaa);
+  bool NewStructPathTBAA = Args.hasFlag(options::OPT_fnew_struct_path_tbaa,
+                                        options::OPT_fno_struct_path_tbaa,
+                                        false);
+  if (!StructPathTBAA && !NewStructPathTBAA)
     CmdArgs.push_back("-no-struct-path-tbaa");
+  if (NewStructPathTBAA)
+    CmdArgs.push_back("-new-struct-path-tbaa");
   if (Args.hasFlag(options::OPT_fstrict_enums, options::OPT_fno_strict_enums,
                    false))
     CmdArgs.push_back("-fstrict-enums");
   if (!Args.hasFlag(options::OPT_fstrict_return, options::OPT_fno_strict_return,
                     true))
     CmdArgs.push_back("-fno-strict-return");
   if (Args.hasFlag(options::OPT_fallow_editor_placeholders,
                    options::OPT_fno_allow_editor_placeholders, false))

lib/Frontend/CompilerInvocation.cpp

static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
   Opts.DisableLifetimeMarkers = Args.hasArg(OPT_disable_lifetimemarkers);
   Opts.DisableO0ImplyOptNone = Args.hasArg(OPT_disable_O0_optnone);
   Opts.DisableRedZone = Args.hasArg(OPT_disable_red_zone);
   Opts.ForbidGuardVariables = Args.hasArg(OPT_fforbid_guard_variables);
   Opts.UseRegisterSizedBitfieldAccess = Args.hasArg(
     OPT_fuse_register_sized_bitfield_access);
   Opts.RelaxedAliasing = Args.hasArg(OPT_relaxed_aliasing);
   Opts.StructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa);
+  Opts.NewStructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa) &&
+                           Args.hasArg(OPT_new_struct_path_tbaa);
   Opts.FineGrainedBitfieldAccesses =
       Args.hasFlag(OPT_ffine_grained_bitfield_accesses,
                    OPT_fno_fine_grained_bitfield_accesses, false);
   Opts.DwarfDebugFlags = Args.getLastArgValue(OPT_dwarf_debug_flags);
   Opts.MergeAllConstants = !Args.hasArg(OPT_fno_merge_all_constants);
   Opts.NoCommon = Args.hasArg(OPT_fno_common);
   Opts.NoImplicitFloat = Args.hasArg(OPT_no_implicit_float);
   Opts.OptimizeSize = getOptimizationLevelSize(Args);

test/Driver/tbaa.c

+// Test translation of TBAA-related clang options to cc1 options.
+
+// RUN: %clang -### -target x86_64-unknown-linux \
+// RUN:   -fno-struct-path-tbaa %s 2>&1 | \
+// RUN:   FileCheck --check-prefix=CHECK-NO_PATH %s
+// RUN: %clang -### -target x86_64-unknown-linux \
+// RUN:   -fstruct-path-tbaa -fno-struct-path-tbaa %s 2>&1 | \
+// RUN:   FileCheck --check-prefix=CHECK-NO_PATH %s
+// RUN: %clang -### -target x86_64-unknown-linux \
+// RUN:   -fnew-struct-path-tbaa -fno-struct-path-tbaa %s 2>&1 | \
+// RUN:   FileCheck --check-prefix=CHECK-NO_PATH %s
+// CHECK-NO_PATH: "-cc1"
+// CHECK-NO_PATH-NOT: "-new-struct-path-tbaa"
+// CHECK-NO_PATH-SAME: "-no-struct-path-tbaa"
+// CHECK-NO_PATH-NOT: "-new-struct-path-tbaa"
+
+// RUN: %clang -### -target x86_64-unknown-linux \
+// RUN:   -fstruct-path-tbaa %s 2>&1 | \
+// RUN:   FileCheck --check-prefix=CHECK-PATH %s
+// CHECK-PATH: "-cc1"
+// CHECK-PATH-NOT: "-no-struct-path-tbaa"
+// CHECK-PATH-NOT: "-new-struct-path-tbaa"
+
+// RUN: %clang -### -target x86_64-unknown-linux \
+// RUN:   -fnew-struct-path-tbaa %s 2>&1 | \
+// RUN:   FileCheck --check-prefix=CHECK-NEW_PATH %s
+// CHECK-NEW_PATH: "-cc1"
+// CHECK-NEW_PATH-NOT: "-no-struct-path-tbaa"
+// CHECK-NEW_PATH: "-new-struct-path-tbaa"
+// CHECK-NEW_PATH-NOT: "-no-struct-path-tbaa"