Propeller: Clang options for basic block sections

[tmsriram]

Summary

Options for Basic Block Sections, enabled in D68063 and D73674.

This patch adds clang options -fbasicblock-sections={all,<filename>,labels,none} and -funique-bb-section-names. LLVM Support for basic block sections is already enabled.

+ -fbasicblock-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-bb-section-names: Enables unique section names for basic block sections, disabled by default.

[mehdi_amini]

clang/include/clang/Basic/CodeGenOptions.def

50

Nit: indentation is off here.

366

Can you add a doc here? (possibly referring to somewhere else if it is extensively documented elsewhere?)

clang/include/clang/Driver/Options.td

1991

Is the "labels" options dependent/related to the previous -fpropeller-label one?

clang/lib/CodeGen/CGDeclCXX.cpp

348 ↗

(On Diff #221825)

Is this related to these new option? It this change the behavior of -ffunction-sections?

clang/lib/CodeGen/CodeGenModule.cpp

1032 ↗

(On Diff #221825)

I agree with the improvement, but as nit this isn't related to the current patch or even in a function you're otherwise touching. (it creates an extra hunk in the review)

1100 ↗

(On Diff #221825)

What happens in case of conflict? (maybe clarify in the comment)

[MaskRay]

clang/lib/CodeGen/BackendUtil.cpp

450

if (S.consume_front("!")) {
  if (S.empty())
    ...
  else
    ... 
}

clang/lib/Driver/ToolChains/Gnu.cpp

631 ↗

(On Diff #221825)

This check is overly constrained. Some systems default to use lld (e.g. installed at /usr/bin/ld). I suggest removing this check.

640 ↗

(On Diff #221825)

Why --no-call-graph-profile-sort?

642 ↗

(On Diff #221825)

This will silently ignore user specified -z keep-text-section-prefix.

With -z nokeep-text-section-prefix, an input section .text.hot.foo will go to the output section .text, instead of .text.hot. Why do you need the option?

[MaskRay]

clang/include/clang/Basic/CodeGenOptions.h

113

Comment its allowed values ("all", "labels", "none")

clang/lib/CodeGen/CodeGenModule.cpp

1103 ↗

(On Diff #221825)

if (getCodeGenOpts().UniqueInternalFuncNames &&
    isa<FunctionDecl>(GD.getDecl()) &&
    getFunctionLinkage(GD) == llvm::GlobalValue::InternalLinkage) {

How does it interop with MangledName = getCUDARuntime().getDeviceStubName(MangledName); below?

clang/lib/Driver/ToolChains/Clang.cpp

4881

The comment is a bit verbose. I think it can just state that when -fpropeller-optimize= or -fpropeller-label is specified, default to -funique-internal-funcnames, followed by a reason why -funique-internal-funcnames should be used.

clang/test/CodeGen/unique_internal_funcnames.c

18 ↗

(On Diff #221825)

foo.${{[0-9a-f]+}} (to make it clearer)

[tmsriram]

Updated patch to address the comments.

[tmsriram]

clang/include/clang/Basic/CodeGenOptions.def

366

I am unable to find a doc for this. I added comments on this based on what "shouldRelocateWithSymbol" in ELFObjectWriter does and why it prefers relocating with sections rather than symbols.

clang/include/clang/Driver/Options.td

1991

Yes, -fpropeller-label is the umbrella propeller option that turns on -fbasicblock-sections=labels.

clang/lib/CodeGen/CGDeclCXX.cpp

348 ↗

(On Diff #221825)

Yes, this is related to function sections getting it right which is important for Propeller.

clang/lib/CodeGen/CodeGenModule.cpp

1032 ↗

(On Diff #221825)

Removed it and will add it independently.

1103 ↗

(On Diff #221825)

The .stub will be suffixed and it will demangle correctly.

clang/lib/Driver/ToolChains/Gnu.cpp

631 ↗

(On Diff #221825)

I see what you mean, can we follow this up in some manner with a check to see if the underlying linker supports Propeller?

640 ↗

(On Diff #221825)

Call graph profile sort conflicts with the reordering we do and cannot be on at the same time. We have plans to merge the two, so until then.

642 ↗

(On Diff #221825)

We are planning to restore keep-text-section-prefix in some manner with Propeller. Since propeller shuffles sections what is hot is not clearly defined by a prefix so this option won't make sense with Propeller. We will use a heuristic to compute hotness and then regenerate the section markers in the final binary.

[MaskRay]

clang/lib/Driver/ToolChains/Gnu.cpp

631 ↗

(On Diff #221825)

Some systems install lld at /usr/bin/ld. This will work even if -fuse-ld=lld is not specified. lld can also be used with -fuse-ld=/path/to/ld.lld . I think the best is just not to have the check.

642 ↗

(On Diff #221825)

OK, thanks for the clarification. The two disabled features deserve comments, even if they are TODO.

[tmsriram]

Updated to top of trunk, bug fixes.

[tmsriram]

clang-formatted.

[tmsriram]

Splitting the clang patch into several pieces:

1. This is the parent patch and just contains support for basic block section options.
2. A separate patch for unique internal function names
3. A separate patch for an option to relocate with symbols instead of sections
4. A separate patch for Propeller flags for clang

[MaskRay]

If you don't mind, I can push a Diff to this Differential which will address these review comments.

clang/lib/CodeGen/BackendUtil.cpp

451

MemoryBuffer::getFile

avoid fstream.

clang/lib/Frontend/CompilerInvocation.cpp

958

This patch requires a rebase.

Opts.UniqueBBSectionNames = Args.hasArg(OPT_funique_bb_section_names);

-ffoo and -fno-foo should have a test/Driver/ test.

There is no need to test both -ffoo and -fno-foo for cc1 options.

[grimar]

clang/include/clang/Basic/CodeGenOptions.h

113

I'd suggest to rewrite it somehow. This set of values did not help me to understand what is this field for. The comment could probably be (for example): "This is a field for.... Allowed values are:...."

clang/lib/CodeGen/BackendUtil.cpp

459

Something is wrong with the namings (I am not an expert in lib/CodeGen), but you are mixing lower vs upper case styles: "fin", "line", "S", "R". Seems the code around prefers upper case.

[grimar]

clang/lib/CodeGen/BackendUtil.cpp

465

if (S.empty() || S[0] == '@' || S[0] == '#')
  continue;
if (!S.consume_front("!") || S.empty())
  break;
if (S.consume_front("!")) {

It is looks a bit strange. See: you are testing S.empty() condition twice and you are checking S.consume_front("!") twice.

476

It seems this assert can be triggered for a wrong user input?

clang/lib/Frontend/CompilerInvocation.cpp

962

Doesn't seem you need "{}" around this lines. (Its a single call and looks inconsistent with the code around).
(The same for the change above)

[tmsriram]

In D68049#1865967, @MaskRay wrote:

If you don't mind, I can push a Diff to this Differential which will address these review comments.

Let me update this patch asap as we refactored getBBSectionsList into llvm as it is shared by llc, clang and lld.

[tmsriram]

Removed getBBSectionsList (moved to LLVM) and address other reviewer comments.

[MaskRay]

In D68049#1865967, @MaskRay wrote:
If you don't mind, I can push a Diff to this Differential which will address these review comments.

I can't because I can't figure out the patch relationship...

First, this patch does not build on its own. I try applying D68063 first, then this patch. It still does not compile..

clang/lib/CodeGen/BackendUtil.cpp:484:11: error: no member named 'propeller' in namespace 'llvm'
    llvm::propeller::getBBSectionsList(CodeGenOpts.BBSections,

Chatted with shenhan and xur offline. I tend to agree that -fbasicblock-sections=label can improve profile accuracy. It'd be nice to make that feature separate,
even if there is still a debate on whether the rest of Propeller is done in a maintainable way.

I think the patch series should probably be structured this way:

1. LLVM CodeGen: enables basic block sections.
2. clang Driver/Frontend/CodeGen: pass basic block sections options to LLVM.

3. LLVM CodeGen: which enables the rest of Propeller options.
4. lld: a file similar to lld/ELF/LTO.cpp . It should be a thin wrapper of Propeller features. It should not do hacky diassembly tasks.
5. clang Driver/Frontend/CodeGen: passes compiler/linker options to 3 and 4

Making 1 and 2 separate can help move forward the patch series. 1 and 2 should not reference llvm::propeller.

[tmsriram]

In D68049#1868623, @MaskRay wrote:

In D68049#1865967, @MaskRay wrote:
If you don't mind, I can push a Diff to this Differential which will address these review comments.

I can't because I can't figure out the patch relationship...

First, this patch does not build on its own. I try applying D68063 first, then this patch. It still does not compile..

Weird, getBBSectionsList is defined by D68063. Let me try doing that again. I will also address the rest of your comments.

clang/lib/CodeGen/BackendUtil.cpp:484:11: error: no member named 'propeller' in namespace 'llvm'
    llvm::propeller::getBBSectionsList(CodeGenOpts.BBSections,

Chatted with shenhan and xur offline. I tend to agree that -fbasicblock-sections=label can improve profile accuracy. It'd be nice to make that feature separate,
even if there is still a debate on whether the rest of Propeller is done in a maintainable way.

I think the patch series should probably be structured this way:

1. LLVM CodeGen: enables basic block sections.
2. clang Driver/Frontend/CodeGen: pass basic block sections options to LLVM.

3. LLVM CodeGen: which enables the rest of Propeller options.
4. lld: a file similar to lld/ELF/LTO.cpp . It should be a thin wrapper of Propeller features. It should not do hacky diassembly tasks.
5. clang Driver/Frontend/CodeGen: passes compiler/linker options to 3 and 4

Making 1 and 2 separate can help move forward the patch series. 1 and 2 should not reference llvm::propeller.

clang/lib/CodeGen/BackendUtil.cpp

459

I am moving this function out of clang into llvm as this needs to be shared by llc, llvm and lld. I will address all your comments for this function in the llvm change.

[tmsriram]

In D68049#1870094, @tmsriram wrote:

In D68049#1868623, @MaskRay wrote:

In D68049#1865967, @MaskRay wrote:
If you don't mind, I can push a Diff to this Differential which will address these review comments.

I can't because I can't figure out the patch relationship...

First, this patch does not build on its own. I try applying D68063 first, then this patch. It still does not compile..

Darn, the include of "llvm/ProfileData/BBSectionsProf.h" is missing in BackendUtil.cpp. Made this mistake when splitting the patch. I will fix this shortly.

Weird, getBBSectionsList is defined by D68063. Let me try doing that again. I will also address the rest of your comments.

clang/lib/CodeGen/BackendUtil.cpp:484:11: error: no member named 'propeller' in namespace 'llvm'
    llvm::propeller::getBBSectionsList(CodeGenOpts.BBSections,

Chatted with shenhan and xur offline. I tend to agree that -fbasicblock-sections=label can improve profile accuracy. It'd be nice to make that feature separate,
even if there is still a debate on whether the rest of Propeller is done in a maintainable way.

I think the patch series should probably be structured this way:

1. LLVM CodeGen: enables basic block sections.
2. clang Driver/Frontend/CodeGen: pass basic block sections options to LLVM.

3. LLVM CodeGen: which enables the rest of Propeller options.
4. lld: a file similar to lld/ELF/LTO.cpp . It should be a thin wrapper of Propeller features. It should not do hacky diassembly tasks.
5. clang Driver/Frontend/CodeGen: passes compiler/linker options to 3 and 4

Making 1 and 2 separate can help move forward the patch series. 1 and 2 should not reference llvm::propeller.

[tmsriram]

Remove usage of "propeller". Fix header inclusion.

[tmsriram]

In D68049#1870094, @tmsriram wrote:

In D68049#1868623, @MaskRay wrote:

In D68049#1865967, @MaskRay wrote:
If you don't mind, I can push a Diff to this Differential which will address these review comments.

I can't because I can't figure out the patch relationship...

First, this patch does not build on its own. I try applying D68063 first, then this patch. It still does not compile..

This should work now. Please apply D68063 first and then this one. Thanks!

Weird, getBBSectionsList is defined by D68063. Let me try doing that again. I will also address the rest of your comments.

clang/lib/CodeGen/BackendUtil.cpp:484:11: error: no member named 'propeller' in namespace 'llvm'
    llvm::propeller::getBBSectionsList(CodeGenOpts.BBSections,

Chatted with shenhan and xur offline. I tend to agree that -fbasicblock-sections=label can improve profile accuracy. It'd be nice to make that feature separate,
even if there is still a debate on whether the rest of Propeller is done in a maintainable way.

I think the patch series should probably be structured this way:

1. LLVM CodeGen: enables basic block sections.
2. clang Driver/Frontend/CodeGen: pass basic block sections options to LLVM.

3. LLVM CodeGen: which enables the rest of Propeller options.
4. lld: a file similar to lld/ELF/LTO.cpp . It should be a thin wrapper of Propeller features. It should not do hacky diassembly tasks.
5. clang Driver/Frontend/CodeGen: passes compiler/linker options to 3 and 4

Making 1 and 2 separate can help move forward the patch series. 1 and 2 should not reference llvm::propeller.

[tmsriram]

I think the patch series should probably be structured this way:

1. LLVM CodeGen: enables basic block sections.
2. clang Driver/Frontend/CodeGen: pass basic block sections options to LLVM.

3. LLVM CodeGen: which enables the rest of Propeller options.
4. lld: a file similar to lld/ELF/LTO.cpp . It should be a thin wrapper of Propeller features. It should not do hacky diassembly tasks.
5. clang Driver/Frontend/CodeGen: passes compiler/linker options to 3 and 4

Making 1 and 2 separate can help move forward the patch series. 1 and 2 should not reference llvm::propeller.

It is now structured like how you mentioned above. 1) corresponds to D68063 and D73674. 2) corresponds to this patch, D68049. These patches do not reference "propeller" anywhere and are only about basic block sections and labels.

We will address Eli's comments in the LLVM patches. We will also make 3), 4) and 5) like how you wanted. Further, D68065 is about LLD support for basic block sections and will not reference "propeller".

[lebedev.ri]

In D68049#1870401, @tmsriram wrote:

In D68049#1870094, @tmsriram wrote:

In D68049#1868623, @MaskRay wrote:

In D68049#1865967, @MaskRay wrote:
If you don't mind, I can push a Diff to this Differential which will address these review comments.

I can't because I can't figure out the patch relationship...

First, this patch does not build on its own. I try applying D68063 first, then this patch. It still does not compile..

This should work now. Please apply D68063 first and then this one. Thanks!

Please can you specify all those patch relations by marking patches as parent/child in phab ui?

[tmsriram]

Clang options for Basic Block Sections enabled in D68063 and D73674

1. -fbasicblock-sections = { "all" | "<filename>" | "labels" | "none" }
2. -funique-bb-section-names

Added more tests. Rebased and checked that it applies cleanly on trunk.

[MaskRay]

clang/lib/Driver/ToolChains/Clang.cpp

4877

If we want to pass the option verbatim, A->render(Args, CmdArgs);

However, we actually want (a convention) to catch the error at the driver level. So the value checking in Frontend/CompilerInvocation.cpp should be moved here.

(Note that you used err_drv_invalid_value in Frontend/CompilerInvocation.cpp . drv is short for driver)

clang/test/CodeGen/basicblock-sections.c

35 ↗

(On Diff #253271)

I haven't read through the previous threads whether we should use a .c -> .s test here. Assume we've decided to do that, @progbits should be followed by {{$}} to ensure there is no unique assembly linkage.

38 ↗

(On Diff #253271)

If world is followed by a colon, the colon should be added. The little detail will make it clear that this is a label.

[tmsriram]

Fix test and make error check at driver.

clang/test/CodeGen/basicblock-sections.c

35 ↗

(On Diff #253271)

Fixed. About .c->.s, this is similar to what function-sections.c does too. Please let me know if I missed anything.

[tmsriram]

Ping.

[MaskRay]

In D68049#1970825, @tmsriram wrote:

Ping.

@rsmith ^^^

More specific question, do you think clang/test/CodeGen/basicblock-sections.c should be converted to a -S -emit-llvm test?

[dblaikie]

In D68049#1971276, @MaskRay wrote:

In D68049#1970825, @tmsriram wrote:

Ping.

@rsmith ^^^

More specific question, do you think clang/test/CodeGen/basicblock-sections.c should be converted to a -S -emit-llvm test?

My understanding is that because this patch only changes TargetOptions, it has no effect on the emitted LLVM IR - only on how that IR is translated to machine code. (like -ffunction-sections, for instance - that property is not persisted in the LLVM IR, it's an API-level communication between Clang and the LLVM backends) So either it goes untested, or it gets tested by a source->assembly test.

[tmsriram]

In D68049#1972297, @dblaikie wrote:

In D68049#1971276, @MaskRay wrote:

In D68049#1970825, @tmsriram wrote:

Ping.

@rsmith ^^^

More specific question, do you think clang/test/CodeGen/basicblock-sections.c should be converted to a -S -emit-llvm test?

My understanding is that because this patch only changes TargetOptions, it has no effect on the emitted LLVM IR - only on how that IR is translated to machine code. (like -ffunction-sections, for instance - that property is not persisted in the LLVM IR, it's an API-level communication between Clang and the LLVM backends) So either it goes untested, or it gets tested by a source->assembly test.

Yes, David is right. Machine IR after BBSectionsPrepare is the first point at which this option has an effect. This is similar to function-sections.c. I acknowledge the concern that tests should not do more than what is required.

[tmsriram]

Ping.

[rsmith]

Please add documentation for the new flags.

clang/include/clang/Driver/Options.td

1991

I would prefer to spell this basic-block rather than basicblock, but I don't feel strongly about it.

1992

It's not great to use the same argument as both one of three specific strings and as an arbitrary filename. This not only prevents using those three names as the file name, it also means adding any more specific strings is a backwards-incompatible change. Can you find some way to tweak this to avoid that problem?

2010–2014

I don't like the inconsistency of using bb here and basicblock / basic-block above. Would spelling this out fully (-funique-basic-block-section-names) be OK?

clang/lib/CodeGen/BackendUtil.cpp

492–507

I don't like doing the parsing here. But... this is consistent with what the other options above do, so I'm OK with keep it like this for consistency. (If someone wants to clean this up we can do that separately for all these enum options.)

[tmsriram]

clang/include/clang/Driver/Options.td

1992

Understood, I have the following suggestions:

1. Would this be ugly? -fbasicblock-sections=list=<filename>
2. I could make this a completely new option.

Is there a preference? Thanks.

[tmsriram]

Document the flags, rename the options.

[tmsriram]

clang/lib/CodeGen/BackendUtil.cpp

492–507

Acknowledged.

[tmsriram]

Ping.

[tmsriram]

@rsmith Ping.

[shenhan]

lld/ELF/LTO.cpp

79

Maybe "--lto-basicblock-sections" should be changed to "--lto-basic-block-sections" too?

[tmsriram]

Rebase.

[tmsriram]

lld/ELF/LTO.cpp

79

Ok if I do this as a separate patch? llc options need to renamed too so I clean up independently after this.

[rsmith]

clang/include/clang/Basic/CodeGenOptions.h

114–127

This comment appears to be out of date with respect to the list= change.

clang/include/clang/Driver/Options.td

1992

Using list= filename seems fine to me.

1993

Missing list= from this description.

Please also specify Values<"all,labels,none,list="> here so that we can tab-complete these values.

clang/lib/CodeGen/BackendUtil.cpp

504–505

Please emit a proper diagnostic for this rather than writing to stderr directly. We should be able to pass the DiagnosticsEngine into here.

clang/test/CodeGen/basic-block-sections.funcnames

1 ↗

(On Diff #263322)

This file should be moved to the Inputs subdirectory (top-level files in this directory should generally be tests).

[tmsriram]

Address reviewer comments:

1. Use Diagnostic instead of errs
2. Move test input to Inputs/
3. Fix option description.

[tmsriram]

Ping.

clang/include/clang/Basic/CodeGenOptions.h

114–127

Fixed, sorry.

[rsmith]

Clang side LG with some minor changes.

clang/docs/ClangCommandLineReference.rst

1336

This file is automatically generated from the .td file; this text will be lost when the file is auto-generated. To include a custom description here, it should be specified as a DocBrief annotation on the option. (Otherwise we default to using the HelpText.)

clang/docs/UsersManual.rst

1704

Please either explain here or link to an explanation elsewhere of what "arg" is and how to format it.

clang/lib/CodeGen/BackendUtil.cpp

504–505

Can you register a regular diagnostic message for this (it looks like we register CodeGen diagnostics in include/clang/Basic/DiagnosticFrontendKinds.td) rather than emitting a custom diagnostic?

[tmsriram]

Address reviewer comments:

• New diagnostic kind
• Document list=<arg>
• Add docbrief

clang/docs/ClangCommandLineReference.rst

1336

Thanks, I included it in both places like other options seem to be doing.

[tmsriram]

Ping.

[tmsriram]

Ping.

[MaskRay]

lld/ELF/LTO.cpp

79

--lto-basic-block-sections

I think it should be fine updating it here, and probably preferable, since you already touched some related LLD code. It does not affect any tests. (You did not add any tests for --lto-basicblock-sections in the original LLD patch.)

[MaskRay]

LLD side changes look good. Are you waiting on an explicit approval from @rmisth ?

[rsmith]

Clang side of these changes LGTM

[tmsriram]

In D68049#2066937, @MaskRay wrote:

LLD side changes look good. Are you waiting on an explicit approval from @rmisth ?

Yes.

lld/ELF/LTO.cpp

79

Yes, I intend to clean this up and the llc option in a separate cleanup patch so that this doesn't get too complicated. Is that alright?

[MaskRay]

clang/lib/Frontend/CompilerInvocation.cpp

962

Please mark this comment as done.

lld/ELF/LTO.cpp

79

It is ok.

clang/docs/ClangCommandLineReference.rst

 .. option:: -fastcp
 
 .. option:: -fastf
 
 .. option:: -fasynchronous-unwind-tables, -fno-asynchronous-unwind-tables
 
 .. 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
 
 .. option:: -fbootclasspath=<arg>, --bootclasspath <arg>, --bootclasspath=<arg>
 
 .. option:: -fborland-extensions, -fno-borland-extensions
 

clang/docs/UsersManual.rst

**-f[no]-unique-internal-linkage-names**
    symbols with the same private linkage name:
 
    .. code-block:: console
 
      $ cd $P/foo && clang -c -funique-internal-linkage-names name_conflict.c
      $ 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
 ---------------------------
 
 Profile information enables better optimization. For example, knowing that a
 branch is taken very frequently helps the compiler make better decisions when
 ordering basic blocks. Knowing that a function ``foo`` is called more
 frequently than another function ``bar`` helps the inliner. Optimization
 levels ``-O2`` and above are recommended for use of profile guided optimization.

clang/include/clang/Basic/CodeGenOptions.h

public:
 
   enum EmbedBitcodeKind {
     Embed_Off,      // No embedded bitcode.
     Embed_All,      // Embed both bitcode and commandline in the output.
     Embed_Bitcode,  // Embed just the bitcode in the output.
     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.
     All,         // Keep all frame pointers.
   };
 
   /// The code model to use (-mcmodel).
   std::string CodeModel;

clang/include/clang/Basic/CodeGenOptions.def

 CODEGENOPT(ControlFlowGuardNoChecks  , 1, 0) ///< -cfguard-no-checks
 CODEGENOPT(ControlFlowGuard  , 1, 0) ///< -cfguard
 CODEGENOPT(CXAAtExit         , 1, 1) ///< Use __cxa_atexit for calling destructors.
 CODEGENOPT(RegisterGlobalDtorsWithAtExit, 1, 1) ///< Use atexit or __cxa_atexit to register global destructors.
 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.
 CODEGENOPT(DiscardValueNames , 1, 0) ///< Discard Value Names from the IR (LLVMContext flag)
 CODEGENOPT(DisableGCov       , 1, 0) ///< Don't run the GCov pass, for testing.
 CODEGENOPT(DisableLLVMPasses , 1, 0) ///< Don't run any LLVM IR passes to get
                                      ///< the pristine IR generated by the
                                      ///< frontend.

 /// The minimum hotness value a diagnostic needs in order to be included in
 /// optimization diagnostics.
 VALUE_CODEGENOPT(DiagnosticsHotnessThreshold, 32, 0)
 
 /// Whether copy relocations support is available when building as PIE.
 CODEGENOPT(PIECopyRelocations, 1, 0)
 
 /// Whether we should use the undefined behaviour optimization for control flow
 /// paths that reach the end of a function without executing a required return.
 CODEGENOPT(StrictReturn, 1, 1)
 
 /// Whether emit extra debug info for sample pgo profile collection.
 CODEGENOPT(DebugInfoForProfiling, 1, 0)
 
 /// Whether 3-component vector type is preserved.
 CODEGENOPT(PreserveVec3Type, 1, 0)
 

clang/include/clang/Basic/DiagnosticFrontendKinds.td

 def err_fe_invalid_wchar_type
     : Error<"invalid wchar_t type '%0'; must be one of 'char', 'short', 'int'">;
 def err_fe_invalid_exception_model
    : Error<"invalid exception model '%0' for target '%1'">;
 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>;
 def warn_fe_serialized_diag_failure : Warning<
     "unable to open file %0 for serializing diagnostics (%1)">,
     InGroup<SerializedDiagnostics>;
 
 def err_verify_missing_line : Error<

clang/include/clang/Driver/Options.td

def fwrapv : Flag<["-"], "fwrapv">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Treat signed integer overflow as two's complement">;
 def fwritable_strings : Flag<["-"], "fwritable-strings">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Store string literals as writable data">;
 def fzero_initialized_in_bss : Flag<["-"], "fzero-initialized-in-bss">, Group<f_Group>;
 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>;
 def fstack_size_section : Flag<["-"], "fstack-size-section">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Emit section containing metadata on function stack sizes">;
 def fno_stack_size_section : Flag<["-"], "fno-stack-size-section">, Group<f_Group>,
   HelpText<"Don't emit section containing metadata on function stack sizes">;
 
 def funique_section_names : Flag <["-"], "funique-section-names">,
   Group<f_Group>,
   HelpText<"Use unique names for text and data sections">;
 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">;
 def fno_unique_internal_linkage_names : Flag <["-"], "fno-unique-internal-linkage-names">,
   Group<f_Group>;
 
 def fstrict_return : Flag<["-"], "fstrict-return">, Group<f_Group>,
   HelpText<"Always treat control flow paths that fall off the end of a "

clang/lib/CodeGen/BackendUtil.cpp

static CodeGenFileType getCodeGenFileType(BackendAction Action) {
   else if (Action == Backend_EmitMCNull)
     return CGFT_Null;
   else {
     assert(Action == Backend_EmitAssembly && "Invalid action!");
     return CGFT_AssemblyFile;
   }
 }
 
-static void initTargetOptions(llvm::TargetOptions &Options,
+static void initTargetOptions(DiagnosticsEngine &Diags,
+                              llvm::TargetOptions &Options,
                               const CodeGenOptions &CodeGenOpts,
                               const clang::TargetOptions &TargetOpts,
                               const LangOptions &LangOpts,
                               const HeaderSearchOptions &HSOpts) {
   Options.ThreadModel =
       llvm::StringSwitch<llvm::ThreadModel::Model>(CodeGenOpts.ThreadModel)
           .Case("posix", llvm::ThreadModel::POSIX)
           .Case("single", llvm::ThreadModel::Single);
 
   // Set float ABI type.
   assert((CodeGenOpts.FloatABI == "soft" || CodeGenOpts.FloatABI == "softfp" ||
           CodeGenOpts.FloatABI == "hard" || CodeGenOpts.FloatABI.empty()) &&
          "Invalid Floating Point ABI!");
   Options.FloatABIType =
       llvm::StringSwitch<llvm::FloatABI::ABIType>(CodeGenOpts.FloatABI)
           .Case("soft", llvm::FloatABI::Soft)
           .Case("softfp", llvm::FloatABI::Soft)
           .Case("hard", llvm::FloatABI::Hard)
           .Default(llvm::FloatABI::Default);
 
   // Set FP fusion mode.
   switch (LangOpts.getDefaultFPContractMode()) {
   case LangOptions::FPM_Off:
     // Preserve any contraction performed by the front-end.  (Strict performs
     // splitting of the muladd intrinsic in the backend.)
     Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
     break;
   case LangOptions::FPM_On:
     Options.AllowFPOpFusion = llvm::FPOpFusion::Standard;
     break;
   case LangOptions::FPM_Fast:
     Options.AllowFPOpFusion = llvm::FPOpFusion::Fast;
     break;
   }
 
   Options.UseInitArray = CodeGenOpts.UseInitArray;
   Options.DisableIntegratedAS = CodeGenOpts.DisableIntegratedAS;
   Options.CompressDebugSections = CodeGenOpts.getCompressDebugSections();
   Options.RelaxELFRelocations = CodeGenOpts.RelaxELFRelocations;
 
   // Set EABI version.
   Options.EABIVersion = TargetOpts.EABIVersion;
 
   if (LangOpts.SjLjExceptions)
     Options.ExceptionModel = llvm::ExceptionHandling::SjLj;
   if (LangOpts.SEHExceptions)
     Options.ExceptionModel = llvm::ExceptionHandling::WinEH;
   if (LangOpts.DWARFExceptions)
     Options.ExceptionModel = llvm::ExceptionHandling::DwarfCFI;
   if (LangOpts.WasmExceptions)
     Options.ExceptionModel = llvm::ExceptionHandling::Wasm;
 
   Options.NoInfsFPMath = CodeGenOpts.NoInfsFPMath;
   Options.NoNaNsFPMath = CodeGenOpts.NoNaNsFPMath;
   Options.NoZerosInBSS = CodeGenOpts.NoZeroInitializedInBSS;
   Options.UnsafeFPMath = CodeGenOpts.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;
   Options.DebuggerTuning = CodeGenOpts.getDebuggerTuning();
   Options.EmitStackSizeSection = CodeGenOpts.StackSizeSection;
   Options.EmitAddrsig = CodeGenOpts.Addrsig;
   Options.ForceDwarfFrameSection = CodeGenOpts.ForceDwarfFrameSection;
   Options.EmitCallSiteInfo = CodeGenOpts.EmitCallSiteInfo;
void EmitAssemblyHelper::CreateTargetMachine(bool MustCreateTM) {
 
   Optional<llvm::CodeModel::Model> CM = getCodeModel(CodeGenOpts);
   std::string FeaturesStr =
       llvm::join(TargetOpts.Features.begin(), TargetOpts.Features.end(), ",");
   llvm::Reloc::Model RM = CodeGenOpts.RelocationModel;
   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));
 }
 
 bool EmitAssemblyHelper::AddEmitPasses(legacy::PassManager &CodeGenPasses,
                                        BackendAction Action,
                                        raw_pwrite_stream &OS,
                                        raw_pwrite_stream *DwoOS) {
BitcodeModule *clang::FindThinLTOModule(MutableArrayRef<BitcodeModule> BMs) {
   for (BitcodeModule &BM : BMs) {
     Expected<BitcodeLTOInfo> LTOInfo = BM.getLTOInfo();
     if (LTOInfo && LTOInfo->IsThinLTO)
       return &BM;
   }
   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);
 
   setCommandLineOpts(CGOpts);
 
   // We can simply import the values mentioned in the combined index, since
   // we should only invoke this using the individual indexes written out
if (CGOpts.SaveTempsFilePrefix != "") {
     }
   }
   Conf.CPU = TOpts.CPU;
   Conf.CodeModel = getCodeModel(CGOpts);
   Conf.MAttrs = TOpts.Features;
   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
   // unrolling.
   Conf.PTO.LoopInterleaving = CGOpts.UnrollLoops;
   Conf.PTO.LoopVectorization = CGOpts.VectorizeLoop;
   Conf.PTO.SLPVectorization = CGOpts.VectorizeSLP;
   Conf.PTO.CallGraphProfile = CGOpts.CallGraphProfile;
if (!IndexOrErr) {
       return;
     }
     std::unique_ptr<ModuleSummaryIndex> CombinedIndex = std::move(*IndexOrErr);
     // A null CombinedIndex means we should skip ThinLTO compilation
     // (LLVM will optionally ignore empty index files, returning null instead
     // 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;
       }
       // Distributed indexing detected that nothing from the module is needed
       // for the final linking. So we can skip the compilation. We sill need to
       // output an empty object file to make sure that a linker does not fail
       // trying to read it. Also for some features, like CFI, we must skip
       // the compilation as CombinedIndex does not contain all required

clang/lib/Driver/ToolChains/Clang.cpp

if (C.getDriver().embedBitcodeInObject() && !C.getDriver().isUsingLTO() &&
     // also reject kernel/kext
     static const constexpr unsigned kBitcodeOptionBlacklist[] = {
         options::OPT_mkernel,
         options::OPT_fapple_kext,
         options::OPT_ffunction_sections,
         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,
         options::OPT_mno_stackrealign,
         options::OPT_mstack_alignment,
         options::OPT_mcmodel_EQ,
         options::OPT_mlong_calls,
         options::OPT_mno_long_calls,
#endif
 
   bool UseSeparateSections = isUseSeparateSections(Triple);
 
   if (Args.hasFlag(options::OPT_ffunction_sections,
                    options::OPT_fno_function_sections, UseSeparateSections)) {
     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");
   }
 
   if (!Args.hasFlag(options::OPT_funique_section_names,
                     options::OPT_fno_unique_section_names, true))
     CmdArgs.push_back("-fno-unique-section-names");
 
   if (Args.hasFlag(options::OPT_funique_internal_linkage_names,
                    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);
 
   // NVPTX doesn't support PGO or coverage. There's no runtime support for
   // sampling, overhead of call arc collection is way too high and there's no
   // way to collect the output.
   if (!Triple.isNVPTX())

clang/lib/Frontend/CompilerInvocation.cpp

Opts.ThreadModel =
       std::string(Args.getLastArgValue(OPT_mthread_model, "posix"));
   if (Opts.ThreadModel != "posix" && Opts.ThreadModel != "single")
     Diags.Report(diag::err_drv_invalid_value)
         << Args.getLastArg(OPT_mthread_model)->getAsString(Args)
         << Opts.ThreadModel;
   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);
 
   Opts.MergeFunctions = Args.hasArg(OPT_fmerge_functions);
 
   Opts.NoUseJumpTables = Args.hasArg(OPT_fno_jump_tables);
 
   Opts.NullPointerIsValid = Args.hasArg(OPT_fno_delete_null_pointer_checks);

clang/test/CodeGen/Inputs/basic-block-sections.funcnames

+!world

clang/test/CodeGen/basic-block-sections.c

+// 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,

clang/test/Driver/fbasic-block-sections.c

+// 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"

clang/test/Driver/funique-basic-block-section-names.c

+// 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"

lld/ELF/Config.h

struct Configuration {
   bool hasDynamicList = false;
   bool hasDynSymTab;
   bool ignoreDataAddressEquality;
   bool ignoreFunctionAddressEquality;
   bool ltoCSProfileGenerate;
   bool ltoDebugPassManager;
   bool ltoEmitAsm;
   bool ltoNewPassManager;
-  bool ltoUniqueBBSectionNames;
+  bool ltoUniqueBasicBlockSectionNames;
   bool ltoWholeProgramVisibility;
   bool mergeArmExidx;
   bool mipsN32Abi = false;
   bool mmapOutputFile;
   bool nmagic;
   bool noDynamicLinker = false;
   bool noinhibitExec;
   bool nostdlib;

lld/ELF/Driver.cpp

static void readConfigs(opt::InputArgList &args) {
   config->ltoWholeProgramVisibility =
       args.hasArg(OPT_lto_whole_program_visibility);
   config->ltoo = args::getInteger(args, OPT_lto_O, 2);
   config->ltoObjPath = args.getLastArgValue(OPT_lto_obj_path_eq);
   config->ltoPartitions = args::getInteger(args, OPT_lto_partitions, 1);
   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);
   config->mipsGotSize = args::getInteger(args, OPT_mips_got_size, 0xfff0);
   config->mergeArmExidx =
       args.hasFlag(OPT_merge_exidx_entries, OPT_no_merge_exidx_entries, true);
   config->mmapOutputFile =
       args.hasFlag(OPT_mmap_output_file, OPT_no_mmap_output_file, true);

lld/ELF/LTO.cpp

static lto::Config createConfig() {
   c.Options.RelaxELFRelocations = true;
   c.Options.EmitAddrsig = true;
 
   // Always emit a section per function/datum with LTO.
   c.Options.FunctionSections = true;
   c.Options.DataSections = true;
 
   // 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;
     } else if (config->ltoBasicBlockSections == "labels") {
       c.Options.BBSections = BasicBlockSection::Labels;
     } else if (config->ltoBasicBlockSections == "none") {
       c.Options.BBSections = BasicBlockSection::None;
     } else {
       ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr =
           MemoryBuffer::getFile(config->ltoBasicBlockSections.str());
       if (!MBOrErr) {
         error("cannot open " + config->ltoBasicBlockSections + ":" +
               MBOrErr.getError().message());
       } else {
         c.Options.BBSectionsFuncListBuf = std::move(*MBOrErr);
       }
       c.Options.BBSections = BasicBlockSection::List;
     }
   }
 
-  c.Options.UniqueBBSectionNames = config->ltoUniqueBBSectionNames;
+  c.Options.UniqueBasicBlockSectionNames =
+      config->ltoUniqueBasicBlockSectionNames;
 
   if (auto relocModel = getRelocModelFromCMModel())
     c.RelocModel = *relocModel;
   else if (config->relocatable)
     c.RelocModel = None;
   else if (config->isPic)
     c.RelocModel = Reloc::PIC_;
   else

llvm/include/llvm/CodeGen/CommandFlags.h

 std::string getBBSections();
 
 unsigned getTLSSize();
 
 bool getEmulatedTLS();
 
 bool getUniqueSectionNames();
 
-bool getUniqueBBSectionNames();
+bool getUniqueBasicBlockSectionNames();
 
 llvm::EABI getEABIVersion();
 
 llvm::DebuggerKind getDebuggerTuningOpt();
 
 bool getEnableStackSizeSection();
 
 bool getEnableAddrsig();

llvm/include/llvm/CodeGen/Passes.h

namespace llvm {
   /// work well with unreachable basic blocks (what live ranges make sense for a
   /// block that cannot be reached?).  As such, a code generator should either
   /// not instruction select unreachable blocks, or run this pass as its
   /// last LLVM modifying pass to clean up blocks that are not reachable from
   /// the entry block.
   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);
 
   /// MachineFunctionPrinter pass - This pass prints out the machine function to
   /// the given stream as a debugging tool.
   MachineFunctionPass *
   createMachineFunctionPrinterPass(raw_ostream &OS,

llvm/include/llvm/Target/TargetMachine.h

void setSupportsDebugEntryValues(bool Enable) {
     Options.SupportsDebugEntryValues = Enable;
   }
 
   bool shouldPrintMachineCode() const { return Options.PrintMachineCode; }
 
   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.
   bool getDataSections() const {
     return Options.DataSections;
   }
 
   /// Return true if functions should be emitted into their own section,
   /// corresponding to -ffunction-sections.
   bool getFunctionSections() const {
     return Options.FunctionSections;
   }
 
   /// 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;
   }
 
   /// Get the list of functions and basic block ids that need unique sections.
   const MemoryBuffer *getBBSectionsFuncListBuf() const {
     return Options.BBSectionsFuncListBuf.get();
   }

llvm/include/llvm/Target/TargetOptions.h

TargetOptions()
         : PrintMachineCode(false), UnsafeFPMath(false), NoInfsFPMath(false),
           NoNaNsFPMath(false), NoTrappingFPMath(true),
           NoSignedZerosFPMath(false),
           HonorSignDependentRoundingFPMathOption(false), NoZerosInBSS(false),
           GuaranteedTailCallOpt(false), StackSymbolOrdering(true),
           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),
           SupportsDefaultOutlining(false), EmitAddrsig(false),
           EmitCallSiteInfo(false), SupportsDebugEntryValues(false),
           EnableDebugEntryValues(false), ForceDwarfFrameSection(false),
           FPDenormalMode(DenormalMode::IEEE, DenormalMode::IEEE) {}
 
public:
     unsigned FunctionSections : 1;
 
     /// Emit data into separate sections.
     unsigned DataSections : 1;
 
     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;
 
     /// Do not emit a trap instruction for 'unreachable' IR instructions behind
     /// noreturn calls, even if TrapUnreachable is true.
     unsigned NoTrapAfterNoreturn : 1;
 

llvm/lib/CodeGen/BBSectionsPrepare.cpp

 //===-- BBSectionsPrepare.cpp ---=========---------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // 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
 // function. Every cluster's section is labeled with a symbol to allow the
 // linker to reorder the sections in any arbitrary sequence. A global order of
 // these sections would encapsulate the function layout.
 //
 // There are a couple of challenges to be addressed:

 //    needs special handling with basic block sections. DebugInfo needs to be
 //    emitted with more relocations as basic block sections can break a
 //    function into potentially several disjoint pieces, and CFI needs to be
 //    emitted per cluster. This also bloats the object file and binary sizes.
 //
 // 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
 // table sizes and the string table sizes significantly. While the binary size
 // does increase, it does not affect performance as the symbol table is not
 // loaded in memory during run-time. The string table size bloat is kept very
 // minimal using a unary naming scheme that uses string suffix compression. The
 // basic blocks for function foo are named "a.BB.foo", "aa.BB.foo", ... This

llvm/lib/CodeGen/CommandFlags.cpp

 CGOPT(bool, UseCtors)
 CGOPT(bool, RelaxELFRelocations)
 CGOPT_EXP(bool, DataSections)
 CGOPT_EXP(bool, FunctionSections)
 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)
 CGOPT(bool, EnableAddrsig)
 CGOPT(bool, EmitCallSiteInfo)
 CGOPT(bool, EnableDebugEntryValues)
 CGOPT(bool, ForceDwarfFrameSection)
 
static cl::opt<bool> EmulatedTLS(
       "emulated-tls", cl::desc("Use emulated TLS model"), cl::init(false));
   CGBINDOPT(EmulatedTLS);
 
   static cl::opt<bool> UniqueSectionNames(
       "unique-section-names", cl::desc("Give unique names to every section"),
       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):"),
       cl::init(EABI::Default),
       cl::values(
           clEnumValN(EABI::Default, "default", "Triple default EABI version"),
           clEnumValN(EABI::EABI4, "4", "EABI version 4"),
           clEnumValN(EABI::EABI5, "5", "EABI version 5"),
TargetOptions codegen::InitTargetOptionsFromCodeGenFlags() {
   Options.StackAlignmentOverride = getOverrideStackAlignment();
   Options.StackSymbolOrdering = getStackSymbolOrdering();
   Options.UseInitArray = !getUseCtors();
   Options.RelaxELFRelocations = getRelaxELFRelocations();
   Options.DataSections = getDataSections();
   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;
   Options.ExceptionModel = getExceptionModel();
   Options.EmitStackSizeSection = getEnableStackSizeSection();
   Options.EmitAddrsig = getEnableAddrsig();
   Options.EmitCallSiteInfo = getEmitCallSiteInfo();
   Options.EnableDebugEntryValues = getEnableDebugEntryValues();

llvm/lib/CodeGen/MachineFunction.cpp

void MachineFunction::RenumberBlocks(MachineBasicBlock *MBB) {
   }
 
   // Okay, all the blocks are renumbered.  If we have compactified the block
   // numbering, shrink MBBNumbering now.
   assert(BlockNo <= MBBNumbering.size() && "Mismatch!");
   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() {
   const TargetInstrInfo *TII = getSubtarget().getInstrInfo();
   this->BBSectionsSymbolPrefix.resize(getNumBlockIDs(), 'a');
   for (auto MBBI = begin(), E = end(); MBBI != E; ++MBBI) {
     assert(
         (MBBI->getNumber() >= 0 && MBBI->getNumber() < (int)getNumBlockIDs()) &&

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

MCSection *TargetLoweringObjectFileELF::getSectionForMachineBasicBlock(
   if (MBB.getSectionID() == MBBSectionID::ColdSectionID) {
     Name += ".text.unlikely.";
     Name += MBB.getParent()->getName();
   } else if (MBB.getSectionID() == MBBSectionID::ExceptionSectionID) {
     Name += ".text.eh.";
     Name += MBB.getParent()->getName();
   } else {
     Name += MBB.getParent()->getSection()->getName();
-    if (TM.getUniqueBBSectionNames()) {
+    if (TM.getUniqueBasicBlockSectionNames()) {
       Name += ".";
       Name += MBB.getSymbol()->getName();
     } else {
       UniqueID = NextUniqueID++;
     }
   }
 
   unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_EXECINSTR;