Author: Sriraman Tallam Date: 2020-06-02T00:23:32-07:00 New Revision: e0bca46b0854143b2f93b60aac99e669c9776979
URL: https://github.com/llvm/llvm-project/commit/e0bca46b0854143b2f93b60aac99e669c9776979 DIFF: https://github.com/llvm/llvm-project/commit/e0bca46b0854143b2f93b60aac99e669c9776979.diff LOG: Options for Basic Block Sections, enabled in D68063 and D73674. This patch adds clang options: -fbasic-block-sections={all,<filename>,labels,none} and -funique-basic-block-section-names. LLVM Support for basic block sections is already enabled. + -fbasic-block-sections={all, <file>, labels, none} : Enables/Disables basic block sections for all or a subset of basic blocks. "labels" only enables basic block symbols. + -funique-basic-block-section-names: Enables unique section names for basic block sections, disabled by default. Differential Revision: https://reviews.llvm.org/D68049 Added: clang/test/CodeGen/Inputs/basic-block-sections.funcnames clang/test/CodeGen/basic-block-sections.c clang/test/Driver/fbasic-block-sections.c clang/test/Driver/funique-basic-block-section-names.c Modified: clang/docs/ClangCommandLineReference.rst clang/docs/UsersManual.rst clang/include/clang/Basic/CodeGenOptions.def clang/include/clang/Basic/CodeGenOptions.h clang/include/clang/Basic/DiagnosticFrontendKinds.td clang/include/clang/Driver/Options.td clang/lib/CodeGen/BackendUtil.cpp clang/lib/Driver/ToolChains/Clang.cpp clang/lib/Frontend/CompilerInvocation.cpp lld/ELF/Config.h lld/ELF/Driver.cpp lld/ELF/LTO.cpp llvm/include/llvm/CodeGen/CommandFlags.h llvm/include/llvm/CodeGen/Passes.h llvm/include/llvm/Target/TargetMachine.h llvm/include/llvm/Target/TargetOptions.h llvm/lib/CodeGen/BBSectionsPrepare.cpp llvm/lib/CodeGen/CommandFlags.cpp llvm/lib/CodeGen/MachineFunction.cpp llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp Removed: ################################################################################ diff --git a/clang/docs/ClangCommandLineReference.rst b/clang/docs/ClangCommandLineReference.rst index a10e747153e2..4fde6034975e 100644 --- a/clang/docs/ClangCommandLineReference.rst +++ b/clang/docs/ClangCommandLineReference.rst @@ -1331,6 +1331,10 @@ Restrict code to those available for App Extensions .. option:: -fautolink, -fno-autolink +.. option:: -fbasic-block-sections=labels, -fbasic-block-sections=all, -fbasic-block-sections=list=<arg>, -fbasic-block-sections=none + +Generate labels for each basic block or place each basic block or a subset of basic blocks in its own section. + .. option:: -fblocks, -fno-blocks Enable the 'blocks' language feature diff --git a/clang/docs/UsersManual.rst b/clang/docs/UsersManual.rst index ae479e0a58ae..d13d4180a112 100644 --- a/clang/docs/UsersManual.rst +++ b/clang/docs/UsersManual.rst @@ -1698,6 +1698,44 @@ are listed below. $ cd $P/bar && clang -c -funique-internal-linkage-names name_conflict.c $ cd $P && clang foo/name_conflict.o && bar/name_conflict.o +**-fbasic-block-sections=[labels, all, list=<arg>, none]** + + Controls whether Clang emits a label for each basic block. Further, with + values "all" and "list=arg", each basic block or a subset of basic blocks + can be placed in its own unique section. + + With the ``list=<arg>`` option, a file containing the subset of basic blocks + that need to placed in unique sections can be specified. The format of the + file is as follows. For example, ``list=spec.txt`` where ``spec.txt`` is the + following: + + :: + + !foo + !!2 + !_Z3barv + + will place the machine basic block with ``id 2`` in function ``foo`` in a + unique section. It will also place all basic blocks of functions ``bar`` + in unique sections. + + Further, section clusters can also be specified using the ``list=<arg>`` + option. For example, ``list=spec.txt`` where ``spec.txt`` contains: + + :: + + !foo + !!1 !!3 !!5 + !!2 !!4 !!6 + + will create two unique sections for function ``foo`` with the first + containing the odd numbered basic blocks and the second containing the + even numbered basic blocks. + + Basic block sections allow the linker to reorder basic blocks and enables + link-time optimizations like whole program inter-procedural basic block + reordering. + Profile Guided Optimization --------------------------- diff --git a/clang/include/clang/Basic/CodeGenOptions.def b/clang/include/clang/Basic/CodeGenOptions.def index d20282316b64..89a67235b966 100644 --- a/clang/include/clang/Basic/CodeGenOptions.def +++ b/clang/include/clang/Basic/CodeGenOptions.def @@ -45,6 +45,9 @@ CODEGENOPT(CXXCtorDtorAliases, 1, 0) ///< Emit complete ctors/dtors as linker ///< aliases to base ctors when possible. CODEGENOPT(DataSections , 1, 0) ///< Set when -fdata-sections is enabled. CODEGENOPT(UniqueSectionNames, 1, 1) ///< Set for -funique-section-names. +CODEGENOPT(UniqueBasicBlockSectionNames, 1, 1) ///< Set for -funique-basic-block-section-names, + ///< Produce unique section names with + ///< basic block sections. ENUM_CODEGENOPT(FramePointer, FramePointerKind, 2, FramePointerKind::None) /// frame-pointer: all,non-leaf,none CODEGENOPT(DisableFree , 1, 0) ///< Don't free memory. diff --git a/clang/include/clang/Basic/CodeGenOptions.h b/clang/include/clang/Basic/CodeGenOptions.h index 9799e4def27c..864ccd5e276d 100644 --- a/clang/include/clang/Basic/CodeGenOptions.h +++ b/clang/include/clang/Basic/CodeGenOptions.h @@ -110,6 +110,22 @@ class CodeGenOptions : public CodeGenOptionsBase { Embed_Marker // Embed a marker as a placeholder for bitcode. }; + // This field stores one of the allowed values for the option + // -fbasic-block-sections=. The allowed values with this option are: + // {"labels", "all", "list=<file>", "none"}. + // + // "labels": Only generate basic block symbols (labels) for all basic + // blocks, do not generate unique sections for basic blocks. + // Use the machine basic block id in the symbol name to + // associate profile info from virtual address to machine + // basic block. + // "all" : Generate basic block sections for all basic blocks. + // "list=<file>": Generate basic block sections for a subset of basic blocks. + // The functions and the machine basic block ids are specified + // in the file. + // "none": Disable sections/labels for basic blocks. + std::string BBSections; + enum class FramePointerKind { None, // Omit all frame pointers. NonLeaf, // Keep non-leaf frame pointers. diff --git a/clang/include/clang/Basic/DiagnosticFrontendKinds.td b/clang/include/clang/Basic/DiagnosticFrontendKinds.td index 9df3e79d183f..687c60c9c536 100644 --- a/clang/include/clang/Basic/DiagnosticFrontendKinds.td +++ b/clang/include/clang/Basic/DiagnosticFrontendKinds.td @@ -110,6 +110,9 @@ def warn_fe_concepts_ts_flag : Warning< "-fconcepts-ts is deprecated - use '-std=c++20' for Concepts support">, InGroup<Deprecated>; +def err_fe_unable_to_load_basic_block_sections_file : Error< + "unable to load basic block sections function list: '%0'">; + def warn_fe_serialized_diag_merge_failure : Warning< "unable to merge a subprocess's serialized diagnostics">, InGroup<SerializedDiagnostics>; diff --git a/clang/include/clang/Driver/Options.td b/clang/include/clang/Driver/Options.td index 0bbeeaf13308..3a5f75660421 100644 --- a/clang/include/clang/Driver/Options.td +++ b/clang/include/clang/Driver/Options.td @@ -1988,6 +1988,11 @@ def ffunction_sections : Flag<["-"], "ffunction-sections">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Place each function in its own section">; def fno_function_sections : Flag<["-"], "fno-function-sections">, Group<f_Group>; +def fbasic_block_sections_EQ : Joined<["-"], "fbasic-block-sections=">, Group<f_Group>, + Flags<[CC1Option, CC1AsOption]>, + HelpText<"Place each function's basic blocks in unique sections (ELF Only) : all | labels | none | list=<file>">, + DocBrief<[{Generate labels for each basic block or place each basic block or a subset of basic blocks in its own section.}]>, + Values<"all,labels,none,list=">; def fdata_sections : Flag <["-"], "fdata-sections">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Place each data in its own section">; def fno_data_sections : Flag <["-"], "fno-data-sections">, Group<f_Group>; @@ -2002,6 +2007,12 @@ def funique_section_names : Flag <["-"], "funique-section-names">, def fno_unique_section_names : Flag <["-"], "fno-unique-section-names">, Group<f_Group>, Flags<[CC1Option]>; +def funique_basic_block_section_names : Flag <["-"], "funique-basic-block-section-names">, + Group<f_Group>, Flags<[CC1Option]>, + HelpText<"Use unique names for basic block sections (ELF Only)">; +def fno_unique_basic_block_section_names : Flag <["-"], "fno-unique-basic-block-section-names">, + Group<f_Group>; + def funique_internal_linkage_names : Flag <["-"], "funique-internal-linkage-names">, Group<f_Group>, Flags<[CC1Option]>, HelpText<"Uniqueify Internal Linkage Symbol Names by appending the MD5 hash of the module path">; diff --git a/clang/lib/CodeGen/BackendUtil.cpp b/clang/lib/CodeGen/BackendUtil.cpp index fdf699cc28e0..056126dda445 100644 --- a/clang/lib/CodeGen/BackendUtil.cpp +++ b/clang/lib/CodeGen/BackendUtil.cpp @@ -430,7 +430,8 @@ static CodeGenFileType getCodeGenFileType(BackendAction Action) { } } -static void initTargetOptions(llvm::TargetOptions &Options, +static void initTargetOptions(DiagnosticsEngine &Diags, + llvm::TargetOptions &Options, const CodeGenOptions &CodeGenOpts, const clang::TargetOptions &TargetOpts, const LangOptions &LangOpts, @@ -488,9 +489,30 @@ static void initTargetOptions(llvm::TargetOptions &Options, Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS; Options.UnsafeFPMath = LangOpts.UnsafeFPMath; Options.StackAlignmentOverride = CodeGenOpts.StackAlignment; + + Options.BBSections = + llvm::StringSwitch<llvm::BasicBlockSection>(CodeGenOpts.BBSections) + .Case("all", llvm::BasicBlockSection::All) + .Case("labels", llvm::BasicBlockSection::Labels) + .StartsWith("list=", llvm::BasicBlockSection::List) + .Case("none", llvm::BasicBlockSection::None) + .Default(llvm::BasicBlockSection::None); + + if (Options.BBSections == llvm::BasicBlockSection::List) { + ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = + MemoryBuffer::getFile(CodeGenOpts.BBSections.substr(5)); + if (!MBOrErr) + Diags.Report(diag::err_fe_unable_to_load_basic_block_sections_file) + << MBOrErr.getError().message(); + else + Options.BBSectionsFuncListBuf = std::move(*MBOrErr); + } + Options.FunctionSections = CodeGenOpts.FunctionSections; Options.DataSections = CodeGenOpts.DataSections; Options.UniqueSectionNames = CodeGenOpts.UniqueSectionNames; + Options.UniqueBasicBlockSectionNames = + CodeGenOpts.UniqueBasicBlockSectionNames; Options.TLSSize = CodeGenOpts.TLSSize; Options.EmulatedTLS = CodeGenOpts.EmulatedTLS; Options.ExplicitEmulatedTLS = CodeGenOpts.ExplicitEmulatedTLS; @@ -802,7 +824,7 @@ void EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) { CodeGenOpt::Level OptLevel = getCGOptLevel(CodeGenOpts); llvm::TargetOptions Options; - initTargetOptions(Options, CodeGenOpts, TargetOpts, LangOpts, HSOpts); + initTargetOptions(Diags, Options, CodeGenOpts, TargetOpts, LangOpts, HSOpts); TM.reset(TheTarget->createTargetMachine(Triple, TargetOpts.CPU, FeaturesStr, Options, RM, CM, OptLevel)); } @@ -1480,15 +1502,12 @@ BitcodeModule *clang::FindThinLTOModule(MutableArrayRef<BitcodeModule> BMs) { return nullptr; } -static void runThinLTOBackend(ModuleSummaryIndex *CombinedIndex, Module *M, - const HeaderSearchOptions &HeaderOpts, - const CodeGenOptions &CGOpts, - const clang::TargetOptions &TOpts, - const LangOptions &LOpts, - std::unique_ptr<raw_pwrite_stream> OS, - std::string SampleProfile, - std::string ProfileRemapping, - BackendAction Action) { +static void runThinLTOBackend( + DiagnosticsEngine &Diags, ModuleSummaryIndex *CombinedIndex, Module *M, + const HeaderSearchOptions &HeaderOpts, const CodeGenOptions &CGOpts, + const clang::TargetOptions &TOpts, const LangOptions &LOpts, + std::unique_ptr<raw_pwrite_stream> OS, std::string SampleProfile, + std::string ProfileRemapping, BackendAction Action) { StringMap<DenseMap<GlobalValue::GUID, GlobalValueSummary *>> ModuleToDefinedGVSummaries; CombinedIndex->collectDefinedGVSummariesPerModule(ModuleToDefinedGVSummaries); @@ -1558,7 +1577,7 @@ static void runThinLTOBackend(ModuleSummaryIndex *CombinedIndex, Module *M, Conf.RelocModel = CGOpts.RelocationModel; Conf.CGOptLevel = getCGOptLevel(CGOpts); Conf.OptLevel = CGOpts.OptimizationLevel; - initTargetOptions(Conf.Options, CGOpts, TOpts, LOpts, HeaderOpts); + initTargetOptions(Diags, Conf.Options, CGOpts, TOpts, LOpts, HeaderOpts); Conf.SampleProfile = std::move(SampleProfile); Conf.PTO.LoopUnrolling = CGOpts.UnrollLoops; // For historical reasons, loop interleaving is set to mirror setting for loop @@ -1648,8 +1667,8 @@ void clang::EmitBackendOutput(DiagnosticsEngine &Diags, // of an error). if (CombinedIndex) { if (!CombinedIndex->skipModuleByDistributedBackend()) { - runThinLTOBackend(CombinedIndex.get(), M, HeaderOpts, CGOpts, TOpts, - LOpts, std::move(OS), CGOpts.SampleProfileFile, + runThinLTOBackend(Diags, CombinedIndex.get(), M, HeaderOpts, CGOpts, + TOpts, LOpts, std::move(OS), CGOpts.SampleProfileFile, CGOpts.ProfileRemappingFile, Action); return; } diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp index dd83cafb2748..4dfc41c6d3d2 100644 --- a/clang/lib/Driver/ToolChains/Clang.cpp +++ b/clang/lib/Driver/ToolChains/Clang.cpp @@ -4205,10 +4205,13 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, options::OPT_fno_function_sections, options::OPT_fdata_sections, options::OPT_fno_data_sections, + options::OPT_fbasic_block_sections_EQ, options::OPT_funique_internal_linkage_names, options::OPT_fno_unique_internal_linkage_names, options::OPT_funique_section_names, options::OPT_fno_unique_section_names, + options::OPT_funique_basic_block_section_names, + options::OPT_fno_unique_basic_block_section_names, options::OPT_mrestrict_it, options::OPT_mno_restrict_it, options::OPT_mstackrealign, @@ -4826,6 +4829,16 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, CmdArgs.push_back("-ffunction-sections"); } + if (Arg *A = Args.getLastArg(options::OPT_fbasic_block_sections_EQ)) { + StringRef Val = A->getValue(); + if (Val != "all" && Val != "labels" && Val != "none" && + !(Val.startswith("list=") && llvm::sys::fs::exists(Val.substr(5)))) + D.Diag(diag::err_drv_invalid_value) + << A->getAsString(Args) << A->getValue(); + else + A->render(Args, CmdArgs); + } + if (Args.hasFlag(options::OPT_fdata_sections, options::OPT_fno_data_sections, UseSeparateSections)) { CmdArgs.push_back("-fdata-sections"); @@ -4839,6 +4852,10 @@ void Clang::ConstructJob(Compilation &C, const JobAction &JA, options::OPT_fno_unique_internal_linkage_names, false)) CmdArgs.push_back("-funique-internal-linkage-names"); + if (Args.hasFlag(options::OPT_funique_basic_block_section_names, + options::OPT_fno_unique_basic_block_section_names, false)) + CmdArgs.push_back("-funique-basic-block-section-names"); + Args.AddLastArg(CmdArgs, options::OPT_finstrument_functions, options::OPT_finstrument_functions_after_inlining, options::OPT_finstrument_function_entry_bare); diff --git a/clang/lib/Frontend/CompilerInvocation.cpp b/clang/lib/Frontend/CompilerInvocation.cpp index ce038d72dbe2..6f11eca73b95 100644 --- a/clang/lib/Frontend/CompilerInvocation.cpp +++ b/clang/lib/Frontend/CompilerInvocation.cpp @@ -937,10 +937,19 @@ static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK, Opts.TrapFuncName = std::string(Args.getLastArgValue(OPT_ftrap_function_EQ)); Opts.UseInitArray = !Args.hasArg(OPT_fno_use_init_array); - Opts.FunctionSections = Args.hasArg(OPT_ffunction_sections); + Opts.BBSections = + std::string(Args.getLastArgValue(OPT_fbasic_block_sections_EQ, "none")); + + // Basic Block Sections implies Function Sections. + Opts.FunctionSections = + Args.hasArg(OPT_ffunction_sections) || + (Opts.BBSections != "none" && Opts.BBSections != "labels"); + Opts.DataSections = Args.hasArg(OPT_fdata_sections); Opts.StackSizeSection = Args.hasArg(OPT_fstack_size_section); Opts.UniqueSectionNames = !Args.hasArg(OPT_fno_unique_section_names); + Opts.UniqueBasicBlockSectionNames = + Args.hasArg(OPT_funique_basic_block_section_names); Opts.UniqueInternalLinkageNames = Args.hasArg(OPT_funique_internal_linkage_names); diff --git a/clang/test/CodeGen/Inputs/basic-block-sections.funcnames b/clang/test/CodeGen/Inputs/basic-block-sections.funcnames new file mode 100644 index 000000000000..329cea9a0adf --- /dev/null +++ b/clang/test/CodeGen/Inputs/basic-block-sections.funcnames @@ -0,0 +1 @@ +!world diff --git a/clang/test/CodeGen/basic-block-sections.c b/clang/test/CodeGen/basic-block-sections.c new file mode 100644 index 000000000000..6cdea79f0fa7 --- /dev/null +++ b/clang/test/CodeGen/basic-block-sections.c @@ -0,0 +1,47 @@ +// REQUIRES: x86-registered-target + +// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -S -o - < %s | FileCheck %s --check-prefix=PLAIN +// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -S -fbasic-block-sections=all -fbasic-block-sections=none -o - < %s | FileCheck %s --check-prefix=PLAIN + +// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -S -fbasic-block-sections=labels -o - < %s | FileCheck %s --check-prefix=BB_LABELS +// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -S -fbasic-block-sections=all -o - < %s | FileCheck %s --check-prefix=BB_WORLD --check-prefix=BB_ALL +// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -S -fbasic-block-sections=list=%S/Inputs/basic-block-sections.funcnames -o - < %s | FileCheck %s --check-prefix=BB_WORLD --check-prefix=BB_LIST +// RUN: %clang_cc1 -triple x86_64-pc-linux-gnu -S -fbasic-block-sections=all -funique-basic-block-section-names -o - < %s | FileCheck %s --check-prefix=UNIQUE + +int world(int a) { + if (a > 10) + return 10; + else if (a > 5) + return 5; + else + return 0; +} + +int another(int a) { + if (a > 10) + return 20; + return 0; +} + +// PLAIN-NOT: section +// PLAIN: world: +// +// BB_LABELS-NOT: section +// BB_LABELS: world: +// BB_LABELS: a.BB.world: +// BB_LABELS: aa.BB.world: +// BB_LABELS: a.BB.another: +// +// BB_WORLD: .section .text.world,"ax",@progbits{{$}} +// BB_WORLD: world: +// BB_WORLD: .section .text.world,"ax",@progbits,unique +// BB_WORLD: world.1: +// BB_WORLD: .section .text.another,"ax",@progbits +// BB_ALL: .section .text.another,"ax",@progbits,unique +// BB_ALL: another.1: +// BB_LIST-NOT: .section .text.another,"ax",@progbits,unique +// BB_LIST: another: +// BB_LIST-NOT: another.1: +// +// UNIQUE: .section .text.world.world.1, +// UNIQUE: .section .text.another.another.1, diff --git a/clang/test/Driver/fbasic-block-sections.c b/clang/test/Driver/fbasic-block-sections.c new file mode 100644 index 000000000000..2ff98c94222b --- /dev/null +++ b/clang/test/Driver/fbasic-block-sections.c @@ -0,0 +1,9 @@ +// RUN: %clang -### -fbasic-block-sections=none %s -S 2>&1 | FileCheck -check-prefix=CHECK-OPT-NONE %s +// RUN: %clang -### -fbasic-block-sections=all %s -S 2>&1 | FileCheck -check-prefix=CHECK-OPT-ALL %s +// RUN: %clang -### -fbasic-block-sections=list=%s %s -S 2>&1 | FileCheck -check-prefix=CHECK-OPT-LIST %s +// RUN: %clang -### -fbasic-block-sections=labels %s -S 2>&1 | FileCheck -check-prefix=CHECK-OPT-LABELS %s +// +// CHECK-OPT-NONE: "-fbasic-block-sections=none" +// CHECK-OPT-ALL: "-fbasic-block-sections=all" +// CHECK-OPT-LIST: "-fbasic-block-sections={{[^ ]*}}fbasic-block-sections.c" +// CHECK-OPT-LABELS: "-fbasic-block-sections=labels" diff --git a/clang/test/Driver/funique-basic-block-section-names.c b/clang/test/Driver/funique-basic-block-section-names.c new file mode 100644 index 000000000000..56f26b0dfbaa --- /dev/null +++ b/clang/test/Driver/funique-basic-block-section-names.c @@ -0,0 +1,4 @@ +// RUN: %clang -### -funique-basic-block-section-names %s -S 2>&1 | FileCheck -check-prefix=CHECK-OPT %s +// RUN: %clang -### -funique-basic-block-section-names -fno-unique-basic-block-section-names %s -S 2>&1 | FileCheck -check-prefix=CHECK-NOOPT %s +// CHECK-OPT: "-funique-basic-block-section-names" +// CHECK-NOOPT-NOT: "-funique-basic-block-section-names" diff --git a/lld/ELF/Config.h b/lld/ELF/Config.h index d494ec156823..cc4547bb0ae2 100644 --- a/lld/ELF/Config.h +++ b/lld/ELF/Config.h @@ -168,7 +168,7 @@ struct Configuration { bool ltoDebugPassManager; bool ltoEmitAsm; bool ltoNewPassManager; - bool ltoUniqueBBSectionNames; + bool ltoUniqueBasicBlockSectionNames; bool ltoWholeProgramVisibility; bool mergeArmExidx; bool mipsN32Abi = false; diff --git a/lld/ELF/Driver.cpp b/lld/ELF/Driver.cpp index b375ab839c36..d2edadaccf52 100644 --- a/lld/ELF/Driver.cpp +++ b/lld/ELF/Driver.cpp @@ -945,7 +945,7 @@ static void readConfigs(opt::InputArgList &args) { config->ltoSampleProfile = args.getLastArgValue(OPT_lto_sample_profile); config->ltoBasicBlockSections = args.getLastArgValue(OPT_lto_basicblock_sections); - config->ltoUniqueBBSectionNames = + config->ltoUniqueBasicBlockSectionNames = args.hasFlag(OPT_lto_unique_bb_section_names, OPT_no_lto_unique_bb_section_names, false); config->mapFile = args.getLastArgValue(OPT_Map); diff --git a/lld/ELF/LTO.cpp b/lld/ELF/LTO.cpp index bbf92f5a2814..56bf5b48f81a 100644 --- a/lld/ELF/LTO.cpp +++ b/lld/ELF/LTO.cpp @@ -78,7 +78,7 @@ static lto::Config createConfig() { // Check if basic block sections must be used. // Allowed values for --lto-basicblock-sections are "all", "labels", // "<file name specifying basic block ids>", or none. This is the equivalent - // of -fbasicblock-sections= flag in clang. + // of -fbasic-block-sections= flag in clang. if (!config->ltoBasicBlockSections.empty()) { if (config->ltoBasicBlockSections == "all") { c.Options.BBSections = BasicBlockSection::All; @@ -99,7 +99,8 @@ static lto::Config createConfig() { } } - c.Options.UniqueBBSectionNames = config->ltoUniqueBBSectionNames; + c.Options.UniqueBasicBlockSectionNames = + config->ltoUniqueBasicBlockSectionNames; if (auto relocModel = getRelocModelFromCMModel()) c.RelocModel = *relocModel; diff --git a/llvm/include/llvm/CodeGen/CommandFlags.h b/llvm/include/llvm/CodeGen/CommandFlags.h index a019c4807873..6cc0ac74542e 100644 --- a/llvm/include/llvm/CodeGen/CommandFlags.h +++ b/llvm/include/llvm/CodeGen/CommandFlags.h @@ -102,7 +102,7 @@ bool getEmulatedTLS(); bool getUniqueSectionNames(); -bool getUniqueBBSectionNames(); +bool getUniqueBasicBlockSectionNames(); llvm::EABI getEABIVersion(); diff --git a/llvm/include/llvm/CodeGen/Passes.h b/llvm/include/llvm/CodeGen/Passes.h index 7a7afa2be9b0..9e5b4446c195 100644 --- a/llvm/include/llvm/CodeGen/Passes.h +++ b/llvm/include/llvm/CodeGen/Passes.h @@ -45,7 +45,7 @@ namespace llvm { FunctionPass *createUnreachableBlockEliminationPass(); /// createBBSectionsPrepare Pass - This pass assigns sections to machine basic - /// blocks and is enabled with -fbasicblock-sections. + /// blocks and is enabled with -fbasic-block-sections. /// Buf is a memory buffer that contains the list of functions and basic /// block ids to selectively enable basic block sections. MachineFunctionPass *createBBSectionsPreparePass(const MemoryBuffer *Buf); diff --git a/llvm/include/llvm/Target/TargetMachine.h b/llvm/include/llvm/Target/TargetMachine.h index c2e14d14d351..6d539f1145ee 100644 --- a/llvm/include/llvm/Target/TargetMachine.h +++ b/llvm/include/llvm/Target/TargetMachine.h @@ -246,7 +246,9 @@ class TargetMachine { bool getUniqueSectionNames() const { return Options.UniqueSectionNames; } /// Return true if unique basic block section names must be generated. - bool getUniqueBBSectionNames() const { return Options.UniqueBBSectionNames; } + bool getUniqueBasicBlockSectionNames() const { + return Options.UniqueBasicBlockSectionNames; + } /// Return true if data objects should be emitted into their own section, /// corresponds to -fdata-sections. @@ -261,7 +263,7 @@ class TargetMachine { } /// If basic blocks should be emitted into their own section, - /// corresponding to -fbasicblock-sections. + /// corresponding to -fbasic-block-sections. llvm::BasicBlockSection getBBSectionsType() const { return Options.BBSections; } diff --git a/llvm/include/llvm/Target/TargetOptions.h b/llvm/include/llvm/Target/TargetOptions.h index 9e13b09d9f97..f465f9b0e8fb 100644 --- a/llvm/include/llvm/Target/TargetOptions.h +++ b/llvm/include/llvm/Target/TargetOptions.h @@ -121,7 +121,7 @@ namespace llvm { EnableFastISel(false), EnableGlobalISel(false), UseInitArray(false), DisableIntegratedAS(false), RelaxELFRelocations(false), FunctionSections(false), DataSections(false), - UniqueSectionNames(true), UniqueBBSectionNames(false), + UniqueSectionNames(true), UniqueBasicBlockSectionNames(false), TrapUnreachable(false), NoTrapAfterNoreturn(false), TLSSize(0), EmulatedTLS(false), ExplicitEmulatedTLS(false), EnableIPRA(false), EmitStackSizeSection(false), EnableMachineOutliner(false), @@ -234,7 +234,7 @@ namespace llvm { unsigned UniqueSectionNames : 1; /// Use unique names for basic block sections. - unsigned UniqueBBSectionNames : 1; + unsigned UniqueBasicBlockSectionNames : 1; /// Emit target-specific trap instruction for 'unreachable' IR instructions. unsigned TrapUnreachable : 1; diff --git a/llvm/lib/CodeGen/BBSectionsPrepare.cpp b/llvm/lib/CodeGen/BBSectionsPrepare.cpp index eb71a382be18..e869888bb2cb 100644 --- a/llvm/lib/CodeGen/BBSectionsPrepare.cpp +++ b/llvm/lib/CodeGen/BBSectionsPrepare.cpp @@ -9,15 +9,15 @@ // BBSectionsPrepare implementation. // // The purpose of this pass is to assign sections to basic blocks when -// -fbasicblock-sections= option is used. Further, with profile information only -// the subset of basic blocks with profiles are placed in separate sections and -// the rest are grouped in a cold section. The exception handling blocks are +// -fbasic-block-sections= option is used. Further, with profile information +// only the subset of basic blocks with profiles are placed in separate sections +// and the rest are grouped in a cold section. The exception handling blocks are // treated specially to ensure they are all in one seciton. // // Basic Block Sections // ==================== // -// With option, -fbasicblock-sections=list, every function may be split into +// With option, -fbasic-block-sections=list, every function may be split into // clusters of basic blocks. Every cluster will be emitted into a separate // section with its basic blocks sequenced in the given order. To get the // optimized performance, the clusters must form an optimal BB layout for the @@ -48,7 +48,7 @@ // Basic Block Labels // ================== // -// With -fbasicblock-sections=labels, or when a basic block is placed in a +// With -fbasic-block-sections=labels, or when a basic block is placed in a // unique section, it is labelled with a symbol. This allows easy mapping of // virtual addresses from PMU profiles back to the corresponding basic blocks. // Since the number of basic blocks is large, the labeling bloats the symbol diff --git a/llvm/lib/CodeGen/CommandFlags.cpp b/llvm/lib/CodeGen/CommandFlags.cpp index 1020d22d1795..947ae327f0d1 100644 --- a/llvm/lib/CodeGen/CommandFlags.cpp +++ b/llvm/lib/CodeGen/CommandFlags.cpp @@ -78,7 +78,7 @@ CGOPT(std::string, BBSections) CGOPT(unsigned, TLSSize) CGOPT(bool, EmulatedTLS) CGOPT(bool, UniqueSectionNames) -CGOPT(bool, UniqueBBSectionNames) +CGOPT(bool, UniqueBasicBlockSectionNames) CGOPT(EABI, EABIVersion) CGOPT(DebuggerKind, DebuggerTuningOpt) CGOPT(bool, EnableStackSizeSection) @@ -350,11 +350,11 @@ codegen::RegisterCodeGenFlags::RegisterCodeGenFlags() { cl::init(true)); CGBINDOPT(UniqueSectionNames); - static cl::opt<bool> UniqueBBSectionNames( + static cl::opt<bool> UniqueBasicBlockSectionNames( "unique-bb-section-names", cl::desc("Give unique names to every basic block section"), cl::init(false)); - CGBINDOPT(UniqueBBSectionNames); + CGBINDOPT(UniqueBasicBlockSectionNames); static cl::opt<EABI> EABIVersion( "meabi", cl::desc("Set EABI type (default depends on triple):"), @@ -460,7 +460,7 @@ TargetOptions codegen::InitTargetOptionsFromCodeGenFlags() { Options.FunctionSections = getFunctionSections(); Options.BBSections = getBBSectionsMode(Options); Options.UniqueSectionNames = getUniqueSectionNames(); - Options.UniqueBBSectionNames = getUniqueBBSectionNames(); + Options.UniqueBasicBlockSectionNames = getUniqueBasicBlockSectionNames(); Options.TLSSize = getTLSSize(); Options.EmulatedTLS = getEmulatedTLS(); Options.ExplicitEmulatedTLS = EmulatedTLSView->getNumOccurrences() > 0; diff --git a/llvm/lib/CodeGen/MachineFunction.cpp b/llvm/lib/CodeGen/MachineFunction.cpp index 3cbcf8c18318..3e57e3c38932 100644 --- a/llvm/lib/CodeGen/MachineFunction.cpp +++ b/llvm/lib/CodeGen/MachineFunction.cpp @@ -340,7 +340,7 @@ void MachineFunction::RenumberBlocks(MachineBasicBlock *MBB) { MBBNumbering.resize(BlockNo); } -/// This is used with -fbasicblock-sections or -fbasicblock-labels option. +/// This is used with -fbasic-block-sections or -fbasicblock-labels option. /// A unary encoding of basic block labels is done to keep ".strtab" sizes /// small. void MachineFunction::createBBLabels() { diff --git a/llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp b/llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp index 68df50f1a87a..03254ed77d71 100644 --- a/llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp +++ b/llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp @@ -879,7 +879,7 @@ MCSection *TargetLoweringObjectFileELF::getSectionForMachineBasicBlock( Name += MBB.getParent()->getName(); } else { Name += MBB.getParent()->getSection()->getName(); - if (TM.getUniqueBBSectionNames()) { + if (TM.getUniqueBasicBlockSectionNames()) { Name += "."; Name += MBB.getSymbol()->getName(); } else { _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
