Propeller: LLVM support for basic block sections

[tmsriram]

Summary

This is the parent patch of a series of patches to enable Basic Block Sections support in LLVM which is the building block for the Propeller post link optimization framework. Please see the RFC here: https://groups.google.com/forum/#!msg/llvm-dev/ef3mKzAdJ7U/1shV64BYBAAJ and the detailed RFC doc here: https://github.com/google/llvm-propeller/blob/plo-dev/Propeller_RFC.pdf.

We introduce a new compiler option, -fbasicblock-sections=, which places every basic block in a unique ELF text section in the object file along with a symbol labeling the basic block. The linker can then order the basic block sections in any arbitrary sequence which when done correctly can encapsulate block layout, function layout and function splitting optimizations. However, there are a couple of challenges to be addressed for this to be feasible:

1. The compiler must not allow any implicit fall-through between any two adjacent basic blocks as they could be reordered at link time to be non-adjacent. In other words, the compiler must make a fall-through between adjacent basic blocks explicit by retaining the direct jump instruction that jumps to the next basic block. These branches can only be removed later by the linker after the blocks have been reordered.
2. All inter-basic block branch targets would now need to be resolved by the linker as they cannot be calculated during compile time. This is done using static relocations which bloats the size of the object files. Further, the compiler tries to use short branch instructions on some ISAs for branch offsets that can be accommodated in one byte. This is not possible with basic block sections as the offset is not determined at compile time, and long branch instructions have to be used everywhere.
3. Each additional section bloats object file sizes by tens of bytes. The number of basic blocks can be potentially very large compared to the size of functions and can bloat object sizes significantly. Option fbasicblock-sections= also takes a file path which can be used to specify a subset of basic blocks that needs unique sections to keep the bloats small.
4. Debug Info and CFI need special handling and will be presented as separate patches.

Basic Block Labels

With -fbasicblock-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 turns out to be very good for string table sizes and the bloat in the string table size for a very large binary is ~8 %. The naming also allows using the --symbol-ordering-file option in LLD to arbitrarily reorder the sections.

[tejohnson]

A few comments after a quick high level scan of patch. Also - please mark all these related patches as parent and child versions in Phabricator.

llvm/include/llvm/CodeGen/MachineBasicBlock.h

139

comment

820

please run clang-format on this patch

llvm/include/llvm/Transforms/Utils/ModuleUtils.h

111

What happens if unique module id is not actually unique?

112

I don't see any calls using this new parameter in this patch - should this change be included with a different patch in the set?

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

2988

Should this be uncommented, or removed?

llvm/lib/CodeGen/MachineBlockPlacement.cpp

3128

Only a whitespace change in this file, remove from patch.

llvm/lib/MC/MCDwarf.cpp

1481

add comment summarizing when dedup is needed

1711

Add parameter name constants to constant parameters here and in other calls to this function.

llvm/lib/Target/X86/X86FrameLowering.cpp

465

change to early return. Also a comment would be good

llvm/lib/Transforms/Utils/ModuleUtils.cpp

274

Confusing comment, as the first 2 sentences seem contradictory (module id not guaranteed to be unique, so we use it).

[MaskRay]

llvm/lib/CodeGen/MachineBasicBlock.cpp

81

std::string(getNumber(), 'a')

llvm/lib/MC/ELFObjectWriter.cpp

1374

R_*_SIZE is x86 specific. If you want to use it on other architectures, it will require an ABI change.

[aprantl]

llvm/include/llvm/CodeGen/AsmPrinterHandler.h

71

Please doxygenify all comments in this patch according to https://llvm.org/docs/CodingStandards.html#doxygen-use-in-documentation-comments.

llvm/test/DebugInfo/X86/basicblock-sections-cfi.ll

85

Please try to remove all string attributes that aren't strictly necessary, they are a maintenance burden.

[tmsriram]

clang-format, comments, minor fixes suggested.

[tmsriram]

llvm/include/llvm/Transforms/Utils/ModuleUtils.h

111

It does not make the situation any worse and we would could end up with two or more internal linkage functions having the same name. Profile attribution would not be accurate and could cause sub-optimal performance decisions particularly if this function is hot. Maybe we could warn about this and let the user pick another name for this.

112

It is used in clang/lib/CodeGen/CodeGenModule.cpp where the function name is formed. Is this ok?

llvm/lib/CodeGen/MachineBasicBlock.cpp

81

Great catch!

llvm/lib/MC/ELFObjectWriter.cpp

1374

Currently guarded with a -mrelocate-with-symbols option. Anything better we could do here?

[tejohnson]

llvm/include/llvm/Transforms/Utils/ModuleUtils.h

111

I think just clarify what the consequences of a collision are in the comments (would be a bigger problem if there was a possible correctness issue).

112

Can you connect these patches by parent/child relationships in phabricator?

[tmsriram]

Main changes:

• Support for Basic block sections with exceptions
• Support for selectively enabling basic block sections for a subset of basic blocks
• Bug fixes with debug info and cfi

[aprantl]

llvm/lib/CodeGen/AsmPrinter/EHStreamer.h

73 ↗

(On Diff #238663)

///

76 ↗

(On Diff #238663)

///

[tmsriram]

Fix comments.

[tmsriram]

llvm/lib/CodeGen/AsmPrinter/EHStreamer.h

76 ↗

(On Diff #238663)

This seems alright, other structs use the same style for per-field comments.

[davidxl]

Try to avoid monolithic patch like this. Please consider splitting it into a few smaller incremental patches with (possibly) independent testing. Logically, it can be split into 1) IR support; 2) machine BB level support; 3) debug support 4) CFI support 5) exception and 6) the 'main tranformation' part if there is one'.

[tmsriram]

Splitting the LLVM patch for Basic Block Sections Support into many smaller patches as follows:

1. Base patch for basic block sections support - This itself is split into Base_1 and Base_2
2. CFI Support for block sections
3. DebugInfo Support for basic block sections
4. Exceptions Support for basic block sections
5. Other smaller patches

We will link the dependent patches as children of this parent patch.

This is the parent patch and is the base patch (Base_1)

[davidxl]

llvm/include/llvm/Target/TargetMachine.h

261

nit: naming consistency: getBasicBlockSections -->getBBSections

267

isFunctionBBSectionsList.

274

getBBSectionSet

[tmsriram]

Include llc options for basic block sections.

[tmsriram]

Change "BasicBlockSections" to "BBSections".

[MaskRay]

llvm/include/llvm/Target/TargetOptions.h

68

Newer code should use enum class instead of namespace+unscoped enumeration

69

Order enum members by the extent they enable basic block sections.

llvm/lib/CodeGen/CodeGenPrepare.cpp

439

We probably can make TargetPassConfig required so we don't have to check TM nullness everywhere.

Created D73754

[tmsriram]

Support the basicblock-sections=<file> option in llc too for feature completeness here and to add tests.

[tmsriram]

Fix a typo.

[tmsriram]

Refactore getBBSectionsList function into a common place so that it can be shared with clang and lld.

[mehdi_amini]

I'm too far away from this part of the code to really assess if this is the proper way of plugin into the codegen unfortunately, I'd ask @echristo maybe?

llvm/include/llvm/CodeGen/CommandFlags.inc

26

Is this needed in this file?

llvm/include/llvm/IR/BasicBlock.h

437

These methods aren't defined (or used) anywhere.

llvm/include/llvm/ProfileData/PropellerProf.h

20 ↗

(On Diff #242470)

The "propeller-specific" aspect of it seems unrelated to "adding support for basic block sections"

[tmsriram]

Address reviewer comments. Delete changes to BasicBlock.h.

[tmsriram]

llvm/include/llvm/ProfileData/PropellerProf.h

20 ↗

(On Diff #242470)

We can rename this to BBSectionsList.h or something similar. This allows basic block sections for a specific set of basic blocks which is useful for Propeller.

[tmsriram]

Rebase and rename PropellerProf to BBSectionsProf.

[tmsriram]

Use MemoryBuffer::getFile instead of fstream.

[efriedma]

I'm not really happy with the way functions lists are handled:

1. It probably makes sense to encode as a function attribute, rather than sticking booleans directly onto llvm::Function . Otherwise, we need to figure out a serialization story; we try to keep IR serialization as complete as possible, even as late as CodeGenPrepare.

2. Attaching the attributes should be done by a separate module pass, I think, not by jamming it into CodeGenPrepare. CodeGenPrepare is an optimization, this isn't (at least, not in the same sense).

3. Not sure it makes sense to stick the list of functions into TargetMachine, as opposed to just modifying the module when the file is parsed.

[tmsriram]

Remove usage of "propeller" from this patch, this is only about support for basic block sections.

[lebedev.ri]

(tests missing?)

llvm/include/llvm/ProfileData/BBSectionsProf.h

1 ↗

(On Diff #243943)

License blurb missing

llvm/lib/ProfileData/BBSectionsProf.cpp

1 ↗

(On Diff #243943)

License blurb missing

[tmsriram]

Deleted changes to CodeGenPrepare.cpp, Function.*.

BBSections is now handled in a separate pass so this base patch becomes very simple.

[tmsriram]

Rebase.

[tmsriram]

@efriedma : Hi Eli, this is the parent patch of D73674. Appreciate if you could take a look at this too, thanks!

[efriedma]

I'm not completely comfortable passing the BB-sections list to the backend as a file path; generally we try to allow the "frontend" (clang/llc/etc.) to control all file I/O. But I'm not sure what the alternative looks like. I guess we could pass it as MemoryBuffer?

Otherwise looks fine.

[tmsriram]

In D68063#1908455, @efriedma wrote:

I'm not completely comfortable passing the BB-sections list to the backend as a file path; generally we try to allow the "frontend" (clang/llc/etc.) to control all file I/O. But I'm not sure what the alternative looks like. I guess we could pass it as MemoryBuffer?

Otherwise looks fine.

• Looking into this, it is not possible to keep the unique_ptr<MemoryBuffer> in TargetOptions.h as the assignment operator is deleted.
• I may have to store the MemoryBuffer in TargetMachine or find another home for it, in which case I may need special handling for both llc and LTO.
• I looked at how some other profile files are stored and noticed that for SampleProfileLoader, the file path is stored as a string in PassBuilder.h and the file seems to be read in the backend.

Thoughts? Thanks!

[tmsriram]

Address Reviewer comments.

• Use MemoryBuffer in TargetOptions.h instead of storing the profile file as string. Make it shared_ptr to allow copying of Options.

[echristo]

Couple of inline comments. I'm trying pretty hard to be able to get rid of TargetOptions.h some day if possible. Any thoughts on ways to do this without?

llvm/include/llvm/Target/TargetOptions.h

71–72

Can you describe the use case behind this in the comments?

272–274

Why would you want to be able to copy it again?

[echristo]

Also the commit message is awesome, but would be good to get the commit message represented as comments in lots of the final code if possible :)

[echristo]

To be clear I think this is close to being acceptable, I'm just asking some questions before hitting the ack and getting things tidied up a bit so the next person doesn't have to ask :)

[tmsriram]

In D68063#1913547, @echristo wrote:

Also the commit message is awesome, but would be good to get the commit message represented as comments in lots of the final code if possible :)

Will do, I can go over the code and add these comments in appropriate places but if you have specific locations please mention.

llvm/include/llvm/Target/TargetOptions.h

71–72

Sure. Just to be clear, are you referring only to "List" or everything?

272–274

I am not copying Options but this is existing code. I can dig exactly where but Options is being copied and that disallows unique_ptr. shared_ptr seems fine as I only want one copy of the MemoryBuffer and that is guaranteed.

[tmsriram]

In D68063#1913544, @echristo wrote:

Couple of inline comments. I'm trying pretty hard to be able to get rid of TargetOptions.h some day if possible. Any thoughts on ways to do this without?

Missed this comment. I can dig more and maybe move it to TargetMachine.h potentially. This has to be done from llc and LTO too so not sure how that would work. Where were you planning on moving the existing fields of TargetOptions to? Thanks.

[efriedma]

In LLVM core libraries, we generally want to accommodate use-cases that don't involve writing files to disk. This makes it easier to write tools targeting new use-cases. Here, for example, someone might want to try writing a JIT using a Propeller workflow. If SampleProfileLoader isn't supporting that, it should probably be fixed.

Mechanically, this seems fine... but it's also okay if we end up with a bit of similar code in multiple places. llc option parsing vs. lld option parsing is two distinct operations.

[tmsriram]

In D68063#1913593, @efriedma wrote:

In LLVM core libraries, we generally want to accommodate use-cases that don't involve writing files to disk. This makes it easier to write tools targeting new use-cases. Here, for example, someone might want to try writing a JIT using a Propeller workflow. If SampleProfileLoader isn't supporting that, it should probably be fixed.

Mechanically, this seems fine... but it's also okay if we end up with a bit of similar code in multiple places. llc option parsing vs. lld option parsing is two distinct operations.

Sure, I made the MemoryBuffer a shared_ptr in TargetOptions and moves the IO out of the LLVM core. The duplicated code in lld and llc is just the getFile and Error check. Thanks!

[MaskRay]

To be clear I think this is close to being acceptable

Agreed. I am still waiting for the resolution to my (very old) comment about:

namespace BasicBlockSection {
  enum SectionMode {

A scoped enumeration (enum class) will be clearer.

The summary is very long and includes lots of stuff not touched by this patch. The relevant paragraphs should be moved to a subsequent patch I think.

[tmsriram]

In D68063#1913667, @MaskRay wrote:

To be clear I think this is close to being acceptable

Agreed. I am still waiting for the resolution to my (very old) comment about:

Then, let me end your wait right away! :)

namespace BasicBlockSection {
  enum SectionMode {

A scoped enumeration (enum class) will be clearer.

I put it in its own namespace like many other enums in that file which are not scoped. If you insist, I can remove the namespace and make it scoped.

The summary is very long and includes lots of stuff not touched by this patch. The relevant paragraphs should be moved to a subsequent patch I think.

IMO, The ideal place to put the summary would be in BBSectionsPrepare.cpp which is the pass that does the actual analysis. I will do that.

[tmsriram]

Address Reviewer comments:

• Make BasicBlock a scoped enum and reorder fields
• More comments on all the enum values
• Rebase

[tmsriram]

@eli.friedman @echristo Is this patch alright? I have added detailed comments as suggested by Eric to BBSectionsPrepare.cpp in https://reviews.llvm.org/D73674#change-lCLJRdamtrcE Thanks!

[efriedma]

LGTM

[MaskRay]

Please still consider my suggestion that removes unrelated paragraphs from the summary :)

[tmsriram]

In D68063#1918478, @MaskRay wrote:

Please still consider my suggestion that removes unrelated paragraphs from the summary :)

Edited to keep it focussed on bb sections and labels.

[tmsriram]

Fix the comment for the option basicblock-sections.

llvm/include/llvm/CodeGen/AsmPrinterHandler.h

virtual void beginFunclet(const MachineBasicBlock &MBB,
                             MCSymbol *Sym = nullptr) {}
   virtual void endFunclet() {}
 
   /// Process beginning of an instruction.
   virtual void beginInstruction(const MachineInstr *MI) = 0;
 
   /// Process end of an instruction.
   virtual void endInstruction() = 0;
+
+  // Process beginning and end of a basic block, with basic block sections.
+  virtual void beginBasicBlock(const MachineBasicBlock &MBB) { }
+  virtual void endBasicBlock(const MachineBasicBlock &MBB) { }
 };
 } // End of namespace llvm
 
 #endif

llvm/include/llvm/CodeGen/CommandFlags.inc

 #include "llvm/IR/Module.h"
 #include "llvm/MC/MCTargetOptionsCommandFlags.inc"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Support/CodeGen.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Target/TargetOptions.h"
 #include <string>
 using namespace llvm;
 
 static cl::opt<std::string>
     MArch("march",
           cl::desc("Architecture to generate code for (see --version)"));
 
 static cl::opt<std::string>
     MCPU("mcpu",
static cl::opt<bool> DataSections("data-sections",
                                   cl::desc("Emit data into separate sections"),
                                   cl::init(false));
 
 static cl::opt<bool>
     FunctionSections("function-sections",
                      cl::desc("Emit functions into separate sections"),
                      cl::init(false));
 
+static cl::opt<llvm::BasicBlockSection::SectionMode> BasicBlockSections(
+    "basicblock-sections",
+    cl::desc("Emit basic blocks into separate sections"),
+    cl::init(BasicBlockSection::None),
+    cl::values(
+        clEnumValN(BasicBlockSection::None, "none", "Off"),
+        clEnumValN(BasicBlockSection::All, "all", "All Basic Blocks"),
+        clEnumValN(BasicBlockSection::Labels, "labels", "Labelled Basic Blocks")));
+
 static cl::opt<bool> EmulatedTLS("emulated-tls",
                                  cl::desc("Use emulated TLS model"),
                                  cl::init(false));
 
 static cl::opt<bool>
     UniqueSectionNames("unique-section-names",
                        cl::desc("Give unique names to every section"),
                        cl::init(true));
 
+static cl::opt<bool> UniqueBBSectionNames(
+   "unique-bb-section-names",
+   cl::desc("Give unique names to every basic block section"),
+   cl::init(false));
+
 static cl::opt<llvm::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"),
                            clEnumValN(EABI::GNU, "gnu", "EABI GNU")));
static TargetOptions InitTargetOptionsFromCodeGenFlags() {
   Options.NoZerosInBSS = DontPlaceZerosInBSS;
   Options.GuaranteedTailCallOpt = EnableGuaranteedTailCallOpt;
   Options.StackAlignmentOverride = OverrideStackAlignment;
   Options.StackSymbolOrdering = StackSymbolOrdering;
   Options.UseInitArray = !UseCtors;
   Options.RelaxELFRelocations = RelaxELFRelocations;
   Options.DataSections = DataSections;
   Options.FunctionSections = FunctionSections;
+  Options.BasicBlockSections = BasicBlockSections;
   Options.UniqueSectionNames = UniqueSectionNames;
+  Options.UniqueBBSectionNames = UniqueBBSectionNames;
   Options.EmulatedTLS = EmulatedTLS;
   Options.ExplicitEmulatedTLS = EmulatedTLS.getNumOccurrences() > 0;
   Options.ExceptionModel = ExceptionModel;
   Options.EmitStackSizeSection = EnableStackSizeSection;
   Options.EmitAddrsig = EnableAddrsig;
   Options.EnableDebugEntryValues = EnableDebugEntryValues;
 
   Options.MCOptions = InitMCTargetOptionsFromFlags();
+  Options.MCOptions.MCRelocateWithSymbols = (BasicBlockSections == BasicBlockSection::All);
 
   Options.ThreadModel = TMModel;
   Options.EABIVersion = EABIVersion;
   Options.DebuggerTuning = DebuggerTuningOpt;
 
   return Options;
 }
 

llvm/include/llvm/CodeGen/MachineBasicBlock.h

private:
   bool IsEHScopeEntry = false;
 
   /// Indicate that this basic block is the entry block of an EH funclet.
   bool IsEHFuncletEntry = false;
 
   /// Indicate that this basic block is the entry block of a cleanup funclet.
   bool IsCleanupFuncletEntry = false;
 
+  /// Indicate that this basic block needs a unqiue section.
+  bool IsUniqueSection = false;
+
   /// since getSymbol is a relatively heavy-weight operation, the symbol
   /// is only computed once and is cached.
   mutable MCSymbol *CachedMCSymbol = nullptr;
 
+  MCSymbol *EndMCSymbol = nullptr;
+
   // Intrusive list support
   MachineBasicBlock() = default;
 
   explicit MachineBasicBlock(MachineFunction &MF, const BasicBlock *BB);
 
   ~MachineBasicBlock();
 
   // MachineBasicBlocks are allocated and owned by MachineFunction.
#endif
   void setIsEHFuncletEntry(bool V = true) { IsEHFuncletEntry = V; }
 
   /// Returns true if this is the entry block of a cleanup funclet.
   bool isCleanupFuncletEntry() const { return IsCleanupFuncletEntry; }
 
   /// Indicates if this is the entry block of a cleanup funclet.
   void setIsCleanupFuncletEntry(bool V = true) { IsCleanupFuncletEntry = V; }
 
+  /// Indicate that this basic block needs a unqiue section.
+  bool isUniqueSection() const { return IsUniqueSection; }
+
+  void setIsUniqueSection(bool V = true) { IsUniqueSection = V; }
+
   /// Returns true if it is legal to hoist instructions into this block.
   bool isLegalToHoistInto() const;
 
   // Code Layout methods.
 
   /// Move 'this' block before or after the specified block.  This only moves
   /// the block, it does not modify the CFG or adjust potential fall-throughs at
   /// the end of the block.
   void moveBefore(MachineBasicBlock *NewAfter);
   void moveAfter(MachineBasicBlock *NewBefore);
 
+  /// Insert an unconditional jump to a fallthrough block if any.
+  void insertUnconditionalFallthroughBranch();
+
   /// Update the terminator instructions in block to account for changes to the
   /// layout. If the block previously used a fallthrough, it may now need a
   /// branch, and if it previously used branching it may now be able to use a
   /// fallthrough.
   void updateTerminator();
 
   // Machine-CFG mutators
 
#endif
   /// MachineBasicBlocks are uniquely numbered at the function level, unless
   /// they're not in a MachineFunction yet, in which case this will return -1.
   int getNumber() const { return Number; }
   void setNumber(int N) { Number = N; }
 
   /// Return the MCSymbol for this basic block.
   MCSymbol *getSymbol() const;
 
+  void setEndMCSymbol(MCSymbol *Sym)
+  { EndMCSymbol = Sym; }
+
+  MCSymbol *getEndMCSymbol() const {
+    return EndMCSymbol;
+  }
+
   Optional<uint64_t> getIrrLoopHeaderWeight() const {
     return IrrLoopHeaderWeight;
   }
 
   void setIrrLoopHeaderWeight(uint64_t Weight) {
     IrrLoopHeaderWeight = Weight;
   }
 

llvm/include/llvm/CodeGen/MachineFunction.h

 class MachineFrameInfo;
 class MachineFunction;
 class MachineJumpTableInfo;
 class MachineModuleInfo;
 class MachineRegisterInfo;
 class MCContext;
 class MCInstrDesc;
 class MCSymbol;
+class MCSection;
 class Pass;
 class PseudoSourceValueManager;
 class raw_ostream;
 class SlotIndexes;
 class TargetRegisterClass;
 class TargetSubtargetInfo;
 struct WasmEHFuncInfo;
 struct WinEHFuncInfo;
class MachineFunction {
   MachineFrameInfo *FrameInfo;
 
   // Keep track of constants which are spilled to memory
   MachineConstantPool *ConstantPool;
 
   // Keep track of jump tables for switch instructions
   MachineJumpTableInfo *JumpTableInfo;
 
+  // Keep track of the function section.
+  MCSection *Section = nullptr;
+
   // Keeps track of Wasm exception handling related data. This will be null for
   // functions that aren't using a wasm EH personality.
   WasmEHFuncInfo *WasmEHInfo = nullptr;
 
   // Keeps track of Windows exception handling related data. This will be null
   // for functions that aren't using a funclet-based EH personality.
   WinEHFuncInfo *WinEHInfo = nullptr;
 
class MachineFunction {
   std::vector<std::tuple<MCSymbol *, MCSymbol *, const DIType *>>
       CodeViewHeapAllocSites;
 
   bool CallsEHReturn = false;
   bool CallsUnwindInit = false;
   bool HasEHScopes = false;
   bool HasEHFunclets = false;
 
+  // True if basic block sections that are generated have been sorted.
+  bool BBSectionsSorted = false;
+  // True if sections must be generated for all basic blocks.
+  bool BasicBlockSections = false;
+  // True if labels must be generated for all basic blocks.
+  bool BasicBlockLabels = false;
+
   /// List of C++ TypeInfo used.
   std::vector<const GlobalValue *> TypeInfos;
 
   /// List of typeids encoding filters used.
   std::vector<unsigned> FilterIds;
 
   /// List of the indices in FilterIds corresponding to filter terminators.
   std::vector<unsigned> FilterEnds;
assert(delegate && !TheDelegate &&
            "Attempted to set delegate to null, or to change it without "
            "first resetting it!");
 
     TheDelegate = delegate;
   }
 
   MachineModuleInfo &getMMI() const { return MMI; }
   MCContext &getContext() const { return Ctx; }
+  MCSection *getSection() const { return Section; }
+  void setSection(MCSection *S) { Section = S; }
 
   PseudoSourceValueManager &getPSVManager() const { return *PSVManager; }
 
   /// Return the DataLayout attached to the Module associated to this MF.
   const DataLayout &getDataLayout() const;
 
   /// Return the LLVM function that this machine code represents
   const Function &getFunction() const { return F; }
 
   /// getName - Return the name of the corresponding LLVM function.
   StringRef getName() const;
 
   /// getFunctionNumber - Return a unique ID for the current function.
   unsigned getFunctionNumber() const { return FunctionNumber; }
 
+  bool getBasicBlockSections() const { return BasicBlockSections; }
+  bool sortBasicBlockSections();
+  bool getBasicBlockLabels() const { return BasicBlockLabels; }
+
   /// getTarget - Return the target machine this machine code is compiled with
   const LLVMTargetMachine &getTarget() const { return Target; }
 
   /// getSubtarget - Return the subtarget for which this machine code is being
   /// compiled.
   const TargetSubtargetInfo &getSubtarget() const { return *STI; }
 
   /// getSubtarget - This method returns a pointer to the specified type of

llvm/include/llvm/CodeGen/TargetFrameLowering.h

public:
 
   /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
   /// the function.
   virtual void emitPrologue(MachineFunction &MF,
                             MachineBasicBlock &MBB) const = 0;
   virtual void emitEpilogue(MachineFunction &MF,
                             MachineBasicBlock &MBB) const = 0;
 
+  virtual void emitCalleeSavedFrameMoves(MachineBasicBlock &MBB,
+                                         MachineBasicBlock::iterator MBBI) const { }
+
   /// Replace a StackProbe stub (if any) with the actual probe code inline
   virtual void inlineStackProbe(MachineFunction &MF,
                                 MachineBasicBlock &PrologueMBB) const {}
 
   /// Adjust the prologue to have the function use segmented stacks. This works
   /// by adding a check even before the "normal" function prologue.
   virtual void adjustForSegmentedStacks(MachineFunction &MF,
                                         MachineBasicBlock &PrologueMBB) const {}

llvm/include/llvm/CodeGen/TargetLoweringObjectFileImpl.h

MCSection *getExplicitSectionGlobal(const GlobalObject *GO, SectionKind Kind,
                                       const TargetMachine &TM) const override;
 
   MCSection *SelectSectionForGlobal(const GlobalObject *GO, SectionKind Kind,
                                     const TargetMachine &TM) const override;
 
   MCSection *getSectionForJumpTable(const Function &F,
                                     const TargetMachine &TM) const override;
 
+  MCSection *getSectionForMachineBasicBlock(const Function &F,
+                                            const MachineBasicBlock &MBB,
+                                            const TargetMachine &TM)
+                                            const override;
+
   bool shouldPutJumpTableInFunctionSection(bool UsesLabelDifference,
                                            const Function &F) const override;
 
   /// Return an MCExpr to use for a reference to the specified type info global
   /// variable from exception handling information.
   const MCExpr *getTTypeGlobalReference(const GlobalValue *GV,
                                         unsigned Encoding,
                                         const TargetMachine &TM,

llvm/include/llvm/IR/BasicBlock.h

 #define LLVM_IR_BASICBLOCK_H
 
 #include "llvm-c/Types.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/ADT/ilist.h"
 #include "llvm/ADT/ilist_node.h"
 #include "llvm/ADT/iterator.h"
 #include "llvm/ADT/iterator_range.h"
+#include "llvm/IR/GlobalObject.h"
 #include "llvm/IR/Instruction.h"
 #include "llvm/IR/SymbolTableListTraits.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/CBindingWrapping.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include <cassert>
 #include <cstddef>
return const_cast<LandingPadInst *>(
                     static_cast<const BasicBlock *>(this)->getLandingPadInst());
   }
 
   /// Return true if it is legal to hoist instructions into this block.
   bool isLegalToHoistInto() const;
 
   Optional<uint64_t> getIrrLoopHeaderWeight() const;
 
+  /// Set the section prefix for this function.
+  void setSectionPrefix(StringRef Prefix);
+
+  /// Get the section prefix for this function.
+  Optional<StringRef> getSectionPrefix() const;
+
 private:
   /// Increment the internal refcount of the number of BlockAddresses
   /// referencing this BasicBlock by \p Amt.
   ///
   /// This is almost always 0, sometimes one possibly, but almost never 2, and
   /// inconceivably 3 or more.
   void AdjustBlockAddressRefCount(int Amt) {
     setValueSubclassData(getSubclassDataFromValue()+Amt);

llvm/include/llvm/IR/DebugInfoMetadata.h

public:
   DIType *getContainingType() const {
     return cast_or_null<DIType>(getRawContainingType());
   }
 
   DICompileUnit *getUnit() const {
     return cast_or_null<DICompileUnit>(getRawUnit());
   }
   void replaceUnit(DICompileUnit *CU) { replaceOperandWith(5, CU); }
+
+  void replaceLinkageName(StringRef NewName) {
+    replaceOperandWith(3, MDString::get(getContext(), NewName));
+  }
+
   DITemplateParameterArray getTemplateParams() const {
     return cast_or_null<MDTuple>(getRawTemplateParams());
   }
   DISubprogram *getDeclaration() const {
     return cast_or_null<DISubprogram>(getRawDeclaration());
   }
   DINodeArray getRetainedNodes() const {
     return cast_or_null<MDTuple>(getRawRetainedNodes());

llvm/include/llvm/IR/Function.h

private:
   /// Bits from GlobalObject::GlobalObjectSubclassData.
   enum {
     /// Whether this function is materializable.
     IsMaterializableBit = 0,
   };
 
   friend class SymbolTableListTraits<Function>;
 
+  bool BasicBlockSections = false;
+  bool BasicBlockLabels = false;
+
   /// hasLazyArguments/CheckLazyArguments - The argument list of a function is
   /// built on demand, so that the list isn't allocated until the first client
   /// needs it.  The hasLazyArguments predicate returns true if the arg list
   /// hasn't been set up yet.
 public:
   bool hasLazyArguments() const {
     return getSubclassDataFromValue() & (1<<0);
   }
public:
   // Provide fast operand accessors.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
   /// Returns the number of non-debug IR instructions in this function.
   /// This is equivalent to the sum of the sizes of each basic block contained
   /// within this function.
   unsigned getInstructionCount() const;
 
+  bool getBasicBlockSections() const {
+    return BasicBlockSections;
+  }
+
+  void setBasicBlockSections(bool value) {
+    BasicBlockSections = value;
+  }
+
+  bool getBasicBlockLabels() const {
+    return BasicBlockLabels;
+  }
+
+  void setBasicBlockLabels(bool value) {
+    BasicBlockLabels = value;
+  }
+
   /// Returns the FunctionType for me.
   FunctionType *getFunctionType() const {
     return cast<FunctionType>(getValueType());
   }
 
   /// Returns the type of the ret val.
   Type *getReturnType() const { return getFunctionType()->getReturnType(); }
 

llvm/include/llvm/MC/MCAsmInfo.h

protected:
   // If true, emit GOTPCRELX/REX_GOTPCRELX instead of GOTPCREL, on
   // X86_64 ELF.
   bool RelaxELFRelocations = true;
 
   // If true, then the lexer and expression parser will support %neg(),
   // %hi(), and similar unary operators.
   bool HasMipsExpressions = false;
 
+  // If true, then use symbols instead of sections for relocations.  This is
+  // true with basic block sections, as the basic block is relaxed by the
+  // linker.
+  bool RelocateWithSymbols = false;
+  bool RelocateWithSizeRelocs = false;
+
 public:
   explicit MCAsmInfo();
   virtual ~MCAsmInfo();
 
   /// Get the code pointer size in bytes.
   unsigned getCodePointerSize() const { return CodePointerSize; }
 
   /// Get the callee-saved register stack slot
void setCompressDebugSections(DebugCompressionType CompressDebugSections) {
     this->CompressDebugSections = CompressDebugSections;
   }
 
   bool shouldUseLogicalShr() const { return UseLogicalShr; }
 
   bool canRelaxRelocations() const { return RelaxELFRelocations; }
   void setRelaxELFRelocations(bool V) { RelaxELFRelocations = V; }
   bool hasMipsExpressions() const { return HasMipsExpressions; }
+  bool shouldRelocateWithSymbols() const { return RelocateWithSymbols; }
+  bool shouldRelocateWithSizeRelocs() const { return RelocateWithSizeRelocs; }
+  void setRelocateWithSymbols(bool V = true) {
+    // Relocate with symbols and size relocs.  This is currently active
+    // during basic block sections.  If the target does not support size
+    // relocs, this must be split.
+    RelocateWithSymbols = V;
+    RelocateWithSizeRelocs = V;
+  }
 };
 
 } // end namespace llvm
 
 #endif // LLVM_MC_MCASMINFO_H

llvm/include/llvm/MC/MCDwarf.h

MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R, int O, StringRef V)
     assert(Op != OpRegister);
   }
 
   MCCFIInstruction(OpType Op, MCSymbol *L, unsigned R1, unsigned R2)
       : Operation(Op), Label(L), Register(R1), Register2(R2) {
     assert(Op == OpRegister);
   }
 
+  long long GetOffsetOrRegister2() const {
+    if (Operation == OpRegister)
+      return Register2;
+    return Offset;
+  }
+
 public:
   /// .cfi_def_cfa defines a rule for computing CFA as: take address from
   /// Register and add Offset to it.
   static MCCFIInstruction createDefCfa(MCSymbol *L, unsigned Register,
                                        int Offset) {
     return MCCFIInstruction(OpDefCfa, L, Register, -Offset, "");
   }
 
assert(Operation == OpDefCfa || Operation == OpOffset ||
            Operation == OpAdjustCfaOffset || Operation == OpGnuArgsSize);
     return Offset;
   }
 
   StringRef getValues() const {
     assert(Operation == OpEscape);
     return StringRef(&Values[0], Values.size());
   }
+
+  friend hash_code hash_value(const MCCFIInstruction &Arg) {
+    return hash_combine(Arg.Label, Arg.Operation, Arg.Register,
+                        Arg.GetOffsetOrRegister2());
+  }
+
+  bool operator<(const MCCFIInstruction &Other) const {
+    return std::make_tuple(Label, Operation, Register, GetOffsetOrRegister2()) <
+           std::make_tuple(Other.Label, Other.Operation, Other.Register,
+                           Other.GetOffsetOrRegister2());
+  }
+
+  bool operator==(const MCCFIInstruction &Other) const {
+    return !(*this < Other) && !(Other < *this);
+  }
+
+  MCCFIInstruction StripLabel() const {
+    MCCFIInstruction Copy = *this;
+    Copy.Label = nullptr;
+    return Copy;
+  }
 };
 
 struct MCDwarfFrameInfo {
   MCDwarfFrameInfo() = default;
 
   MCSymbol *Begin = nullptr;
   MCSymbol *End = nullptr;
   const MCSymbol *Personality = nullptr;

llvm/include/llvm/MC/MCTargetOptions.h

public:
   bool MCNoExecStack : 1;
   bool MCFatalWarnings : 1;
   bool MCNoWarn : 1;
   bool MCNoDeprecatedWarn : 1;
   bool MCSaveTempLabels : 1;
   bool MCUseDwarfDirectory : 1;
   bool MCIncrementalLinkerCompatible : 1;
   bool MCPIECopyRelocations : 1;
+  bool MCRelocateWithSymbols : 1;
   bool ShowMCEncoding : 1;
   bool ShowMCInst : 1;
   bool AsmVerbose : 1;
 
   /// Preserve Comments in Assembly.
   bool PreserveAsmComments : 1;
 
   int DwarfVersion = 0;

llvm/include/llvm/Target/TargetLoweringObjectFile.h

 #include "llvm/IR/Module.h"
 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/SectionKind.h"
 #include <cstdint>
 
 namespace llvm {
 
 class GlobalValue;
+class MachineBasicBlock;
 class MachineModuleInfo;
 class Mangler;
 class MCContext;
 class MCExpr;
 class MCSection;
 class MCSymbol;
 class MCSymbolRefExpr;
 class MCStreamer;
public:
 
   /// Given a constant with the SectionKind, return a section that it should be
   /// placed in.
   virtual MCSection *getSectionForConstant(const DataLayout &DL,
                                            SectionKind Kind,
                                            const Constant *C,
                                            unsigned &Align) const;
 
+  virtual MCSection *getSectionForMachineBasicBlock(const Function &F,
+      const MachineBasicBlock &MBB, const TargetMachine &TM) const;
+
   /// Classify the specified global variable into a set of target independent
   /// categories embodied in SectionKind.
   static SectionKind getKindForGlobal(const GlobalObject *GO,
                                       const TargetMachine &TM);
 
   /// This method computes the appropriate section to emit the specified global
   /// variable or function definition. This should not be passed external (or
   /// available externally) globals.

llvm/include/llvm/Target/TargetMachine.h

public:
   void setSupportsDefaultOutlining(bool Enable) {
     Options.SupportsDefaultOutlining = Enable;
   }
 
   bool shouldPrintMachineCode() const { return Options.PrintMachineCode; }
 
   bool getUniqueSectionNames() const { return Options.UniqueSectionNames; }
 
+  bool getUniqueBBSectionNames() const { return Options.UniqueBBSectionNames; }
+
   /// 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.
+  llvm::BasicBlockSection::SectionMode getBasicBlockSections() const {
+    return Options.BasicBlockSections;
+  }
+
+  bool isFunctionInBasicBlockSectionsList(const StringRef &name) const {
+    return Options.BasicBlockSectionsList.lookup(name);
+  }
+
   /// Get a \c TargetIRAnalysis appropriate for the target.
   ///
   /// This is used to construct the new pass manager's target IR analysis pass,
   /// set up appropriately for this target machine. Even the old pass manager
   /// uses this to answer queries about the IR.
   TargetIRAnalysis getTargetIRAnalysis();
 
   /// Return a TargetTransformInfo for a given function.
   ///
   /// The returned TargetTransformInfo is specialized to the subtarget
   /// corresponding to \p F.
   virtual TargetTransformInfo getTargetTransformInfo(const Function &F);
 
   /// Allow the target to modify the pass manager, e.g. by calling

llvm/include/llvm/Target/TargetOptions.h

 // targets.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_TARGET_TARGETOPTIONS_H
 #define LLVM_TARGET_TARGETOPTIONS_H
 
 #include "llvm/MC/MCTargetOptions.h"
+#include "llvm/ADT/StringMap.h"
 
 namespace llvm {
   class MachineFunction;
   class Module;
 
   namespace FloatABI {
     enum ABIType {
       Default, // Target-specific (either soft or hard depending on triple, etc).
namespace FPDenormal {
     enum DenormalMode {
       IEEE,           // IEEE 754 denormal numbers
       PreserveSign,   // the sign of a flushed-to-zero number is preserved in
                       // the sign of 0
       PositiveZero    // denormals are flushed to positive zero
     };
   }
 
+  namespace BasicBlockSection {
+    enum SectionMode {
+      None,    // Do not use Basic Block Sections.
+      All,    // Use Basic Block Sections for all functions.
+      Labels, // Do not use Basic Block Sections but label basic blocks.
+      List // Get list of functions from a file/
+    };
+  }
+
   enum class EABI {
     Unknown,
     Default, // Default means not specified
     EABI4,   // Target-specific (either 4, 5 or gnu depending on triple).
     EABI5,
     GNU
   };
 
TargetOptions()
         : PrintMachineCode(false), UnsafeFPMath(false), NoInfsFPMath(false),
           NoNaNsFPMath(false), NoTrappingFPMath(false),
           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), TrapUnreachable(false),
+          UniqueSectionNames(true),
+          UniqueBBSectionNames(false), TrapUnreachable(false),
           NoTrapAfterNoreturn(false), EmulatedTLS(false),
           ExplicitEmulatedTLS(false), EnableIPRA(false),
           EmitStackSizeSection(false), EnableMachineOutliner(false),
           SupportsDefaultOutlining(false), EmitAddrsig(false),
           EnableDebugEntryValues(false) {}
 
     /// PrintMachineCode - This flag is enabled when the -print-machineinstrs
     /// option is specified on the command line, and should enable debugging
public:
     /// Emit functions into separate sections.
     unsigned FunctionSections : 1;
 
     /// Emit data into separate sections.
     unsigned DataSections : 1;
 
     unsigned UniqueSectionNames : 1;
 
+    unsigned UniqueBBSectionNames : 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;
 
     /// EmulatedTLS - This flag enables emulated TLS model, using emutls
public:
     unsigned EnableMachineOutliner : 1;
 
     /// Set if the target supports default outlining behaviour.
     unsigned SupportsDefaultOutlining : 1;
 
     /// Emit address-significance table.
     unsigned EmitAddrsig : 1;
 
+    /// Emit basic blocks into separate sections.
+    BasicBlockSection::SectionMode BasicBlockSections = BasicBlockSection::None;
+
+    StringMap<bool> BasicBlockSectionsList;
+
     /// Emit debug info about parameter's entry values.
     unsigned EnableDebugEntryValues : 1;
 
     /// FloatABIType - This setting is set by -float-abi=xxx option is specfied
     /// on the command line. This setting may either be Default, Soft, or Hard.
     /// Default selects the target's default behavior. Soft selects the ABI for
     /// software floating point, but does not indicate that FP hardware may not
     /// be used. Such a combination is unfortunately popular (e.g.
     /// arm-apple-darwin). Hard presumes that the normal FP ABI is used.

llvm/include/llvm/Transforms/Utils/ModuleUtils.h

 /// members.
 ///
 /// This identifier is normally guaranteed to be unique, or the program would
 /// fail to link due to multiply defined symbols.
 ///
 /// If the module has no strong external symbols (such a module may still have a
 /// semantic effect if it performs global initialization), we cannot produce a
 /// unique identifier for this module, so we return the empty string.
-std::string getUniqueModuleId(Module *M);
+///
+/// If UseModuleId is true, we include the ModuleIdentifier string.  This is
+/// however not guaranteed to be unique.
+std::string getUniqueModuleId(Module *M, bool UseModuleId = false);
 
 } // End llvm namespace
 
 #endif //  LLVM_TRANSFORMS_UTILS_MODULEUTILS_H

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

if (isVerbose())
     OutStreamer->GetCommentOS()
         << "-- Begin function "
         << GlobalValue::dropLLVMManglingEscape(F.getName()) << '\n';
 
   // Print out constants referenced by the function
   EmitConstantPool();
 
   // Print the 'header' of function.
-  OutStreamer->SwitchSection(getObjFileLowering().SectionForGlobal(&F, TM));
+  MF->setSection(getObjFileLowering().SectionForGlobal(&F, TM));
+  OutStreamer->SwitchSection(MF->getSection());
+
   EmitVisibility(CurrentFnSym, F.getVisibility());
 
   EmitLinkage(&F, CurrentFnSym);
   if (MAI->hasFunctionAlignment())
     EmitAlignment(MF->getAlignment(), &F);
 
   if (MAI->hasDotTypeDotSizeDirective())
     OutStreamer->EmitSymbolAttribute(CurrentFnSym, MCSA_ELF_TypeFunction);
if (!MLI) {
       OwnedMLI->getBase().analyze(MDT->getBase());
       MLI = OwnedMLI.get();
     }
   }
 
   // Print out code for the function.
   bool HasAnyRealCode = false;
   int NumInstsInFunction = 0;
+  bool emitBasicBlockSections = MF->getBasicBlockSections();
+  if (emitBasicBlockSections)
+    MF->sortBasicBlockSections();
+
   for (auto &MBB : *MF) {
     // Print a label for the basic block.
     EmitBasicBlockStart(MBB);
     for (auto &MI : MBB) {
       // Print the assembly for the instruction.
       if (!MI.isPosition() && !MI.isImplicitDef() && !MI.isKill() &&
           !MI.isDebugInstr()) {
         HasAnyRealCode = true;
for (auto &MI : MBB) {
         for (const HandlerInfo &HI : Handlers) {
           NamedRegionTimer T(HI.TimerName, HI.TimerDescription,
                              HI.TimerGroupName, HI.TimerGroupDescription,
                              TimePassesIsEnabled);
           HI.Handler->endInstruction();
         }
       }
     }
-
+    if (MF->getBasicBlockLabels() || MBB.isUniqueSection()) {
+      // Emit size directive for the size of this basic block.  Create a symbol
+      // for the end of the basic block.
+      MCSymbol *CurrentBBEnd = OutContext.createTempSymbol();
+      const MCExpr *SizeExp =  MCBinaryExpr::createSub(
+          MCSymbolRefExpr::create(CurrentBBEnd, OutContext),
+          MCSymbolRefExpr::create(MBB.getSymbol(), OutContext), OutContext);
+      OutStreamer->EmitLabel(CurrentBBEnd);
+      MBB.setEndMCSymbol(CurrentBBEnd);
+      OutStreamer->emitELFSize(MBB.getSymbol(), SizeExp);
+    }
     EmitBasicBlockEnd(MBB);
   }
 
   EmittedInsts += NumInstsInFunction;
   MachineOptimizationRemarkAnalysis R(DEBUG_TYPE, "InstructionCount",
                                       MF->getFunction().getSubprogram(),
                                       &MF->front());
   R << ore::NV("NumInstructions", NumInstsInFunction)
if (!HasAnyRealCode && (MAI->hasSubsectionsViaSymbols() ||
     // Targets can opt-out of emitting the noop here by leaving the opcode
     // unspecified.
     if (Noop.getOpcode()) {
       OutStreamer->AddComment("avoids zero-length function");
       OutStreamer->EmitInstruction(Noop, getSubtargetInfo());
     }
   }
 
+  // Switch to the original section if basic block sections was used.
+  if (emitBasicBlockSections)
+    OutStreamer->SwitchSection(MF->getSection());
+
   const Function &F = MF->getFunction();
   for (const auto &BB : F) {
     if (!BB.hasAddressTaken())
       continue;
     MCSymbol *Sym = GetBlockAddressSymbol(&BB);
     if (Sym->isDefined())
       continue;
     OutStreamer->AddComment("Address of block that was removed by CodeGen");
void AsmPrinter::setupCodePaddingContext(const MachineBasicBlock &MBB,
   Context.IsBasicBlockReachableViaBranch =
       MBB.pred_size() > 0 && !isBlockOnlyReachableByFallthrough(&MBB);
 }
 
 /// EmitBasicBlockStart - This method prints the label for the specified
 /// MachineBasicBlock, an alignment (if present) and a comment describing
 /// it if appropriate.
 void AsmPrinter::EmitBasicBlockStart(const MachineBasicBlock &MBB) {
+  bool BasicBlockSections = MF->getBasicBlockSections();
   // End the previous funclet and start a new one.
   if (MBB.isEHFuncletEntry()) {
     for (const HandlerInfo &HI : Handlers) {
       HI.Handler->endFunclet();
       HI.Handler->beginFunclet(MBB);
     }
   }
 
   // Emit an alignment directive for this block, if needed.
+  if (MBB.pred_empty() || !BasicBlockSections) {
     const llvm::Align Align = MBB.getAlignment();
     if (Align != llvm::Align::None())
       EmitAlignment(Align);
+  }
   MCCodePaddingContext Context;
   setupCodePaddingContext(MBB, Context);
   OutStreamer->EmitCodePaddingBasicBlockStart(Context);
 
   // If the block has its address taken, emit any labels that were used to
   // reference the block.  It is possible that there is more than one label
   // here, because multiple LLVM BB's may have been RAUW'd to this block after
   // the references were generated.
if (const BasicBlock *BB = MBB.getBasicBlock()) {
         OutStreamer->GetCommentOS() << '\n';
       }
     }
 
     assert(MLI != nullptr && "MachineLoopInfo should has been computed");
     emitBasicBlockLoopComments(MBB, MLI, *this);
   }
 
-  // Print the main label for the block.
+  bool emitBBLabels = BasicBlockSections || MF->getBasicBlockLabels();
   if (MBB.pred_empty() ||
-      (isBlockOnlyReachableByFallthrough(&MBB) && !MBB.isEHFuncletEntry() &&
-       !MBB.hasLabelMustBeEmitted())) {
+      (!emitBBLabels && isBlockOnlyReachableByFallthrough(&MBB) &&
+       !MBB.isEHFuncletEntry() && !MBB.hasLabelMustBeEmitted())) {
     if (isVerbose()) {
       // NOTE: Want this comment at start of line, don't emit with AddComment.
       OutStreamer->emitRawComment(" %bb." + Twine(MBB.getNumber()) + ":",
                                   false);
     }
   } else {
-    if (isVerbose() && MBB.hasLabelMustBeEmitted())
+    if (isVerbose() && MBB.hasLabelMustBeEmitted()) {
       OutStreamer->AddComment("Label of block must be emitted");
+    }
+    // For -fbasicblock-sections, switch to another section.
+    if (MBB.isUniqueSection()) {
+      OutStreamer->SwitchSection(
+          getObjFileLowering().getSectionForMachineBasicBlock(MF->getFunction(),
+                                                              MBB, TM));
+    } else if (BasicBlockSections) {
+      OutStreamer->SwitchSection(MF->getSection());
+    }
+    // Emit alignment after section is created for basic block sections.
+    // if (MBB.isUniqueSection()) {
+    //  if (unsigned LogAlign = MBB.getLogAlignment())
+    //    EmitAlignment(LogAlign);
+    // }
     OutStreamer->EmitLabel(MBB.getSymbol());
+    // With BasicBlockSections, each Basic Block must handle CFI information on its own.
+    if (MBB.isUniqueSection()) {
+      for (const HandlerInfo &HI : Handlers) {
+        HI.Handler->beginBasicBlock(MBB);
+      }
+    }
   }
 }
 
 void AsmPrinter::EmitBasicBlockEnd(const MachineBasicBlock &MBB) {
   MCCodePaddingContext Context;
   setupCodePaddingContext(MBB, Context);
   OutStreamer->EmitCodePaddingBasicBlockEnd(Context);
+  // Check if CFI information needs to be updated for this MBB with basic block
+  // sections.
+  if (MF->getBasicBlockSections()) {
+    auto I = std::next(MBB.getIterator());
+    const MachineBasicBlock *nextBB = (I != MF->end()) ? &*I : nullptr;
+    if (MBB.isUniqueSection() ||
+        !nextBB || nextBB->isUniqueSection()) {
+      for (const HandlerInfo &HI : Handlers) {
+        HI.Handler->endBasicBlock(MBB);
+      }
+    }
+  }
 }
 
 void AsmPrinter::EmitVisibility(MCSymbol *Sym, unsigned Visibility,
                                 bool IsDefinition) const {
   MCSymbolAttr Attr = MCSA_Invalid;
 
   switch (Visibility) {
   default: break;
if (Attr != MCSA_Invalid)
     OutStreamer->EmitSymbolAttribute(Sym, Attr);
 }
 
 /// isBlockOnlyReachableByFallthough - Return true if the basic block has
 /// exactly one predecessor and the control transfer mechanism between
 /// the predecessor and this block is a fall-through.
 bool AsmPrinter::
 isBlockOnlyReachableByFallthrough(const MachineBasicBlock *MBB) const {
+  // With BasicBlock Sections, no block is a fall through.
+  if (MBB->isUniqueSection())
+    return false;
+
   // If this is a landing pad, it isn't a fall through.  If it has no preds,
   // then nothing falls through to it.
   if (MBB->isEHPad() || MBB->pred_empty())
     return false;
 
   // If there isn't exactly one predecessor, it can't be a fall through.
   if (MBB->pred_size() > 1)
     return false;

llvm/lib/CodeGen/AsmPrinter/DwarfCFIException.cpp

void DwarfCFIExceptionBase::markFunctionEnd() {
   // Map all labels and get rid of any dead landing pads.
   if (!Asm->MF->getLandingPads().empty()) {
     MachineFunction *NonConstMF = const_cast<MachineFunction*>(Asm->MF);
     NonConstMF->tidyLandingPads();
   }
 }
 
 void DwarfCFIExceptionBase::endFragment() {
-  if (shouldEmitCFI)
+  // With -fbasicblock-sections, this is handled at each basic block.
+  if (shouldEmitCFI && !Asm->MF->getBasicBlockSections())
     Asm->OutStreamer->EmitCFIEndProc();
 }
 
 DwarfCFIException::DwarfCFIException(AsmPrinter *A)
     : DwarfCFIExceptionBase(A), shouldEmitPersonality(false),
       forceEmitPersonality(false), shouldEmitLSDA(false),
       shouldEmitMoves(false) {}
 

 /// endFunction - Gather and emit post-function exception information.
 ///
 void DwarfCFIException::endFunction(const MachineFunction *MF) {
   if (!shouldEmitPersonality)
     return;
 
   emitExceptionTable();
 }
+
+void DwarfCFIException::beginBasicBlock(const MachineBasicBlock &MBB) {
+  if (shouldEmitCFI)
+    Asm->OutStreamer->EmitCFIStartProc(/*IsSimple=*/false);
+}
+
+void DwarfCFIException::endBasicBlock(const MachineBasicBlock &MBB) {
+  if (shouldEmitCFI)
+    Asm->OutStreamer->EmitCFIEndProc();
+}

llvm/lib/CodeGen/AsmPrinter/DwarfCompileUnit.cpp

 }
 
 // Find DIE for the given subprogram and attach appropriate DW_AT_low_pc
 // and DW_AT_high_pc attributes. If there are global variables in this
 // scope then create and insert DIEs for these variables.
 DIE &DwarfCompileUnit::updateSubprogramScopeDIE(const DISubprogram *SP) {
   DIE *SPDie = getOrCreateSubprogramDIE(SP, includeMinimalInlineScopes());
 
+  if (!Asm->MF->getBasicBlockSections())
     attachLowHighPC(*SPDie, Asm->getFunctionBegin(), Asm->getFunctionEnd());
+  else {
+    SmallVector<RangeSpan, 2> BB_List;
+    BB_List.push_back(RangeSpan(Asm->getFunctionBegin(),
+                                Asm->getFunctionEnd()));
+    // If basic block sections are on, only the entry BB and exception
+    // handling BBs will be in the [getFunctionBegin(), getFunctionEnd()]
+    // range. Ranges for the other BBs have to be emitted separately.
+    for (auto &MBB : *Asm->MF) {
+      if (!MBB.pred_empty() && MBB.isUniqueSection()) {
+        BB_List.push_back(
+            RangeSpan(MBB.getSymbol(),
+                      MBB.getEndMCSymbol()));
+      }
+    }
+    attachRangesOrLowHighPC(*SPDie, BB_List);
+  }
   if (DD->useAppleExtensionAttributes() &&
       !DD->getCurrentFunction()->getTarget().Options.DisableFramePointerElim(
           *DD->getCurrentFunction()))
     addFlag(*SPDie, dwarf::DW_AT_APPLE_omit_frame_ptr);
 
   // Only include DW_AT_frame_base in full debug info
   if (!includeMinimalInlineScopes()) {
     if (Asm->MF->getTarget().getTargetTriple().isNVPTX()) {
addSectionDelta(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(),
                     RangeSectionSym);
   else
     addSectionLabel(ScopeDIE, dwarf::DW_AT_ranges, List.getSym(),
                     RangeSectionSym);
 }
 
 void DwarfCompileUnit::attachRangesOrLowHighPC(
     DIE &Die, SmallVector<RangeSpan, 2> Ranges) {
-  if (Ranges.size() == 1 || !DD->useRangesSection()) {
+  // With basic block sections, if the range spans multiple sections then this
+  // cannot be emitted as (low pc, high pc).
+  if ((Asm->TM.getBasicBlockSections() == llvm::BasicBlockSection::None) &&
+      (Ranges.size() == 1 || !DD->useRangesSection())) {
     const RangeSpan &Front = Ranges.front();
     const RangeSpan &Back = Ranges.back();
     attachLowHighPC(Die, Front.getStart(), Back.getEnd());
   } else
     addScopeRangeList(Die, std::move(Ranges));
 }
 
 void DwarfCompileUnit::attachRangesOrLowHighPC(
     DIE &Die, const SmallVectorImpl<InsnRange> &Ranges) {
   SmallVector<RangeSpan, 2> List;
   List.reserve(Ranges.size());
-  for (const InsnRange &R : Ranges)
-    List.push_back(RangeSpan(DD->getLabelBeforeInsn(R.first),
-                             DD->getLabelAfterInsn(R.second)));
+  for (const InsnRange &R : Ranges) {
+    auto *BeginLabel = DD->getLabelBeforeInsn(R.first);
+    auto *EndLabel = DD->getLabelAfterInsn(R.second);
+
+    const auto *BeginMBB = R.first->getParent();
+    const auto *EndBB = R.second->getParent();
+
+    if (BeginMBB == EndBB || !EndBB->isUniqueSection() ||
+        Asm->MF->getBasicBlockSections() == llvm::BasicBlockSection::None) {
+      // Without basic block sections, there is just one continuous range.
+      // The same holds if EndBB is in the initial non-unique-section BB range.
+      List.push_back(RangeSpan(BeginLabel, EndLabel));
+      continue;
+    }
+
+    const auto *LastMBBInSection = BeginMBB;
+
+    if (BeginMBB->isUniqueSection()) {
+      // BeginLabel lies in a unique section ending at the BeginMBB's end
+      // symbol.
+      assert(BeginMBB->getEndMCSymbol() &&
+             "Unique BB sections should have end symbols.");
+      List.push_back(RangeSpan(BeginLabel, BeginMBB->getEndMCSymbol()));
+    } else {
+      // BeginLabel lies in a non-unique section, but EndLabel does not. The
+      // section for non-unique-section BBs ends at Asm->getFunctionEnd().
+      List.push_back(RangeSpan(BeginLabel, Asm->getFunctionEnd()));
+      while (!std::next(LastMBBInSection)->isUniqueSection())
+        ++LastMBBInSection;
+    }
+
+    for (auto *MBB = std::next(LastMBBInSection); MBB != EndBB; ++MBB) {
+      assert(MBB->isUniqueSection() && "All non-unique-section BBs should be"
+                                       " before the unique-section ones.");
+      assert(MBB->getSymbol() && "Unique BB sections should have symbols.");
+      assert(MBB->getEndMCSymbol() &&
+             "Unique BB sections should have end symbols.");
+      List.push_back(RangeSpan(MBB->getSymbol(), MBB->getEndMCSymbol()));
+    }
+
+    assert(EndBB->getSymbol() && "Unique BB sections should have symbols.");
+    List.push_back(RangeSpan(EndBB->getSymbol(), EndLabel));
+  }
   attachRangesOrLowHighPC(Die, std::move(List));
 }
 
 // This scope represents inlined body of a function. Construct DIE to
 // represent this concrete inlined copy of the function.
 DIE *DwarfCompileUnit::constructInlinedScopeDIE(LexicalScope *Scope) {
   assert(Scope->getScopeNode());
   auto *DS = Scope->getScopeNode();

llvm/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

void DwarfDebug::endFunctionImpl(const MachineFunction *MF) {
   }
 
   DenseSet<InlinedEntity> Processed;
   collectEntityInfo(TheCU, SP, Processed);
 
   // Add the range of this function to the list of ranges for the CU.
   TheCU.addRange(RangeSpan(Asm->getFunctionBegin(), Asm->getFunctionEnd()));
 
+  // With basic block sections, add all basic block ranges with unique
+  // sections.
+  if (MF->getBasicBlockSections()) {
+    for (auto &MBB : *MF) {
+      if (MBB.isUniqueSection() && !MBB.pred_empty()) {
+        TheCU.addRange(RangeSpan(MBB.getSymbol(), MBB.getEndMCSymbol()));
+      }
+    }
+  }
+
   // Under -gmlt, skip building the subprogram if there are no inlined
   // subroutines inside it. But with -fdebug-info-for-profiling, the subprogram
   // is still needed as we need its source location.
   if (!TheCU.getCUNode()->getDebugInfoForProfiling() &&
       TheCU.getCUNode()->getEmissionKind() == DICompileUnit::LineTablesOnly &&
       LScopes.getAbstractScopesList().empty() && !IsDarwin) {
     assert(InfoHolder.getScopeVariables().empty());
     PrevLabel = nullptr;
for (const auto &List : DebugLocs.getLists()) {
     for (const auto &Entry : DebugLocs.getEntries(List)) {
       // GDB only supports startx_length in pre-standard split-DWARF.
       // (in v5 standard loclists, it currently* /only/ supports base_address +
       // offset_pair, so the implementations can't really share much since they
       // need to use different representations)
       // * as of October 2018, at least
       // Ideally/in v5, this could use SectionLabels to reuse existing addresses
       // in the address pool to minimize object size/relocations.
+      if (Asm->TM.getBasicBlockSections() != llvm::BasicBlockSection::None &&
+          Asm->TM.getBasicBlockSections() != llvm::BasicBlockSection::Labels) {
+        // With basic block sections, symbol difference cannot be emitted as
+        // the can span sections.
+        Asm->emitInt8(dwarf::DW_LLE_startx_endx);
+        Asm->EmitULEB128(AddrPool.getIndex(Entry.BeginSym));
+        Asm->EmitULEB128(AddrPool.getIndex(Entry.EndSym));
+      } else {
         Asm->emitInt8(dwarf::DW_LLE_startx_length);
         unsigned idx = AddrPool.getIndex(Entry.BeginSym);
         Asm->EmitULEB128(idx);
         Asm->EmitLabelDifference(Entry.EndSym, Entry.BeginSym, 4);
-
+      }
       emitDebugLocEntryLocation(Entry, List.CU);
     }
     Asm->emitInt8(dwarf::DW_LLE_end_of_list);
   }
 }
 
 struct ArangeSpan {
   const MCSymbol *Start, *End;

llvm/lib/CodeGen/AsmPrinter/DwarfException.h

public:
   /// immediately after the function entry point.
   void beginFunction(const MachineFunction *MF) override;
 
   /// Gather and emit post-function exception information.
   void endFunction(const MachineFunction *) override;
 
   void beginFragment(const MachineBasicBlock *MBB,
                      ExceptionSymbolProvider ESP) override;
+
+  void beginBasicBlock(const MachineBasicBlock &MBB) override;
+  void endBasicBlock(const MachineBasicBlock &MBB) override;
 };
 
 class LLVM_LIBRARY_VISIBILITY ARMException : public DwarfCFIExceptionBase {
   void emitTypeInfos(unsigned TTypeEncoding, MCSymbol *TTBaseLabel) override;
   ARMTargetStreamer &getTargetStreamer();
 
 public:
   //===--------------------------------------------------------------------===//

llvm/lib/CodeGen/CFIInstrInserter.cpp

void CFIInstrInserter::updateSuccCFAInfo(MBBCFAInfo &MBBInfo) {
   } while (!Stack.empty());
 }
 
 bool CFIInstrInserter::insertCFIInstrs(MachineFunction &MF) {
   const MBBCFAInfo *PrevMBBInfo = &MBBVector[MF.front().getNumber()];
   const TargetInstrInfo *TII = MF.getSubtarget().getInstrInfo();
   bool InsertedCFIInstr = false;
 
+  MF.sortBasicBlockSections();
+ 
   for (MachineBasicBlock &MBB : MF) {
     // Skip the first MBB in a function
     if (MBB.getNumber() == MF.front().getNumber()) continue;
 
     const MBBCFAInfo &MBBInfo = MBBVector[MBB.getNumber()];
     auto MBBI = MBBInfo.MBB->begin();
     DebugLoc DL = MBBInfo.MBB->findDebugLoc(MBBI);
 
-    if (PrevMBBInfo->OutgoingCFAOffset != MBBInfo.IncomingCFAOffset) {
+    // If the current MBB will be placed in a unique section, a full DefCfa
+    // must be emitted.
+    const bool ForceFullCFA = MBB.isUniqueSection();
+
+    if (PrevMBBInfo->OutgoingCFAOffset != MBBInfo.IncomingCFAOffset ||
+        ForceFullCFA) {
       // If both outgoing offset and register of a previous block don't match
       // incoming offset and register of this block, add a def_cfa instruction
       // with the correct offset and register for this block.
-      if (PrevMBBInfo->OutgoingCFARegister != MBBInfo.IncomingCFARegister) {
+      if (PrevMBBInfo->OutgoingCFARegister != MBBInfo.IncomingCFARegister ||
+          ForceFullCFA) {
         unsigned CFIIndex = MF.addFrameInst(MCCFIInstruction::createDefCfa(
             nullptr, MBBInfo.IncomingCFARegister, getCorrectCFAOffset(&MBB)));
         BuildMI(*MBBInfo.MBB, MBBI, DL, TII->get(TargetOpcode::CFI_INSTRUCTION))
             .addCFIIndex(CFIIndex);
         // If outgoing offset of a previous block doesn't match incoming offset
         // of this block, add a def_cfa_offset instruction with the correct
         // offset for this block.
       } else {
if (PrevMBBInfo->OutgoingCFAOffset != MBBInfo.IncomingCFAOffset ||
                MBBInfo.IncomingCFARegister) {
       unsigned CFIIndex =
           MF.addFrameInst(MCCFIInstruction::createDefCfaRegister(
               nullptr, MBBInfo.IncomingCFARegister));
       BuildMI(*MBBInfo.MBB, MBBI, DL, TII->get(TargetOpcode::CFI_INSTRUCTION))
           .addCFIIndex(CFIIndex);
       InsertedCFIInstr = true;
     }
+
+    if (ForceFullCFA) {
+      MF.getSubtarget().getFrameLowering()->emitCalleeSavedFrameMoves(
+          *MBBInfo.MBB, MBBI);
+      InsertedCFIInstr = true;
+    }
+
     PrevMBBInfo = &MBBInfo;
   }
   return InsertedCFIInstr;
 }
 
 void CFIInstrInserter::report(const MBBCFAInfo &Pred, const MBBCFAInfo &Succ) {
   errs() << "*** Inconsistent CFA register and/or offset between pred and succ "
             "***\n";

llvm/lib/CodeGen/CodeGenPrepare.cpp

bool CodeGenPrepare::runOnFunction(Function &F) {
   TTI = &getAnalysis<TargetTransformInfoWrapperPass>().getTTI(F);
   LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
   BPI.reset(new BranchProbabilityInfo(F, *LI));
   BFI.reset(new BlockFrequencyInfo(F, *BPI, *LI));
   OptSize = F.hasOptSize();
 
   ProfileSummaryInfo *PSI =
       &getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI();
+
+  if (TM && TM->getBasicBlockSections() == llvm::BasicBlockSection::All)
+    F.setBasicBlockSections(true);
+
+  if (TM && TM->getBasicBlockSections() == llvm::BasicBlockSection::List &&
+      TM->isFunctionInBasicBlockSectionsList(F.getName()))
+    F.setBasicBlockSections(true);
+
+  if (TM && TM->getBasicBlockSections() == llvm::BasicBlockSection::Labels)
+    F.setBasicBlockLabels(true);
+
   if (ProfileGuidedSectionPrefix) {
     if (PSI->isFunctionHotInCallGraph(&F, *BFI))
       F.setSectionPrefix(".hot");
     else if (PSI->isFunctionColdInCallGraph(&F, *BFI))
       F.setSectionPrefix(".unlikely");
   }
 
   /// This optimization identifies DIV instructions that can be

llvm/lib/CodeGen/LLVMTargetMachine.cpp

void LLVMTargetMachine::initAsmInfo() {
   if (Options.DisableIntegratedAS)
     TmpAsmInfo->setUseIntegratedAssembler(false);
 
   TmpAsmInfo->setPreserveAsmComments(Options.MCOptions.PreserveAsmComments);
 
   TmpAsmInfo->setCompressDebugSections(Options.CompressDebugSections);
 
   TmpAsmInfo->setRelaxELFRelocations(Options.RelaxELFRelocations);
+  TmpAsmInfo->setRelocateWithSymbols(Options.MCOptions.MCRelocateWithSymbols);
 
   if (Options.ExceptionModel != ExceptionHandling::None)
     TmpAsmInfo->setExceptionsType(Options.ExceptionModel);
 
   AsmInfo.reset(TmpAsmInfo);
 }
 
 LLVMTargetMachine::LLVMTargetMachine(const Target &T,

llvm/lib/CodeGen/MachineBasicBlock.cpp

 }
 
 /// Return the MCSymbol for this basic block.
 MCSymbol *MachineBasicBlock::getSymbol() const {
   if (!CachedMCSymbol) {
     const MachineFunction *MF = getParent();
     MCContext &Ctx = MF->getContext();
     auto Prefix = Ctx.getAsmInfo()->getPrivateLabelPrefix();
+
+    bool BasicBlockSymbols = MF->getBasicBlockSections() ||
+                             MF->getBasicBlockLabels();
+    auto Delimiter = BasicBlockSymbols ? "." : "_";
     assert(getNumber() >= 0 && "cannot get label for unreachable MBB");
+
+    // With Basic Block Sections, we emit a symbol for every basic block. To
+    // keep the size of strtab small, we choose a unary encoding which can
+    // compress the symbol names significantly.  The basic blocks for function
+    // foo are named a.BB.foo, aa.BB.foo, and so on.
+    if (BasicBlockSymbols) {
+      std::function<std::string(unsigned)> Unary = [&Unary](unsigned num) {
+        if (num == 0) return std::string("");
+        if (num == 1) return std::string("a");
+        std::string s = Unary(num / 2);
+        return s + s + Unary(num % 2);
+      };
+      CachedMCSymbol = Ctx.getOrCreateSymbol(Unary(getNumber()) +
+                           Twine(Delimiter) + "BB" + Twine(Delimiter) +
+                           Twine(MF->getName()));
+    } else {
       CachedMCSymbol = Ctx.getOrCreateSymbol(Twine(Prefix) + "BB" +
-                                           Twine(MF->getFunctionNumber()) +
-                                           "_" + Twine(getNumber()));
+                           Twine(MF->getFunctionNumber()) + Twine(Delimiter) +
+                           Twine(getNumber()));
+    }
   }
-
   return CachedMCSymbol;
 }
 
 
 raw_ostream &llvm::operator<<(raw_ostream &OS, const MachineBasicBlock &MBB) {
   MBB.print(OS);
   return OS;
 }

 void MachineBasicBlock::moveBefore(MachineBasicBlock *NewAfter) {
   getParent()->splice(NewAfter->getIterator(), getIterator());
 }
 
 void MachineBasicBlock::moveAfter(MachineBasicBlock *NewBefore) {
   getParent()->splice(++NewBefore->getIterator(), getIterator());
 }
 
+// Insert unconditional jumps to the basic block to which there is
+// a fall through.
+void MachineBasicBlock::insertUnconditionalFallthroughBranch() {
+  MachineBasicBlock *Fallthrough = getFallThrough();
+
+  if (Fallthrough == nullptr)
+    return;
+
+  // If this basic block and the Fallthrough basic block are in the same
+  // section then do not insert the jump.
+  if (!this->isUniqueSection() && !Fallthrough->isUniqueSection())
+    return;
+
+  const TargetInstrInfo *TII = getParent()->getSubtarget().getInstrInfo();
+  SmallVector<MachineOperand, 4> Cond;
+  MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
+
+  // If a branch to the fall through block already exists, return.
+  if (!TII->analyzeBranch(*this, TBB, FBB, Cond) &&
+      (TBB == Fallthrough || FBB == Fallthrough)) {
+    return;
+  }
+
+  Cond.clear();
+  DebugLoc DL = findBranchDebugLoc();
+  TII->insertBranch(*this, Fallthrough, nullptr, Cond, DL);
+}
+
 void MachineBasicBlock::updateTerminator() {
   const TargetInstrInfo *TII = getParent()->getSubtarget().getInstrInfo();
   // A block with no successors has no concerns with fall-through edges.
   if (this->succ_empty())
     return;
 
   MachineBasicBlock *TBB = nullptr, *FBB = nullptr;
   SmallVector<MachineOperand, 4> Cond;

llvm/lib/CodeGen/MachineBlockPlacement.cpp

else if (AlignAllNonFallThruBlocks) {
     }
   }
   if (ViewBlockLayoutWithBFI != GVDT_None &&
       (ViewBlockFreqFuncName.empty() ||
        F->getFunction().getName().equals(ViewBlockFreqFuncName))) {
     MBFI->view("MBP." + MF.getName(), false);
   }
 
-
   // We always return true as we have no way to track whether the final order
   // differs from the original order.
   return true;
 }
 
 namespace {
 
 /// A pass to compute block placement statistics.

llvm/lib/CodeGen/MachineFunction.cpp

void MachineFunction::init() {
   Alignment = STI->getTargetLowering()->getMinFunctionAlignment();
 
   // FIXME: Shouldn't use pref alignment if explicit alignment is set on F.
   // FIXME: Use Function::hasOptSize().
   if (!F.hasFnAttribute(Attribute::OptimizeForSize))
     Alignment = std::max(Alignment,
                          STI->getTargetLowering()->getPrefFunctionAlignment());
 
+  if (Target.getBasicBlockSections() == llvm::BasicBlockSection::All ||
+      F.getBasicBlockSections() ||
+      (Target.getBasicBlockSections() == llvm::BasicBlockSection::List  &&
+       Target.isFunctionInBasicBlockSectionsList(F.getName())))
+    BasicBlockSections = true;
+
+  if (Target.getBasicBlockSections() == llvm::BasicBlockSection::Labels ||
+      F.getBasicBlockLabels())
+    BasicBlockLabels = true;
+
   if (AlignAllFunctions)
     Alignment = llvm::Align(1ULL << AlignAllFunctions);
 
   JumpTableInfo = nullptr;
 
   if (isFuncletEHPersonality(classifyEHPersonality(
           F.hasPersonalityFn() ? F.getPersonalityFn() : nullptr))) {
     WinEHInfo = new (Allocator) WinEHFuncInfo();
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);
 }
 
+/// HasEHInfo - Return true is this Machine Basic Block is a landing pad or
+/// it has EHLabels used in exception tables.
+static bool HasEHInfo(const MachineBasicBlock &MBB) {
+  if (MBB.isEHPad() || MBB.isEHFuncletEntry())
+    return true;
+  for (auto &MI : MBB) {
+    if (MI.isEHLabel())
+      return true;
+  }
+  return false;
+}
+
+bool MachineFunction::sortBasicBlockSections() {
+  // This should only be done once no matter how many times it is called.
+  if (this->BBSectionsSorted || !this->getBasicBlockSections())
+    return false;
+
+  DenseMap<const MachineBasicBlock *, unsigned> MBBOrder;
+  unsigned MBBOrderN = 0;
+
+  for (auto &MBB : *this) {
+    // A unique BB section can only be created if this basic block is not
+    // used for exception table computations.
+    if (!MBB.pred_empty() && !HasEHInfo(MBB))
+      MBB.setIsUniqueSection();
+    MBBOrder[&MBB] = MBBOrderN++;
+  }
+
+  // With -fbasicblock-sections, fall through blocks must be made
+  // explicitly reachable.  Do this after unique sections is set as
+  // unnecessary fallthroughs can be avoided.
+  for (auto &MBB : *this) {
+    MBB.insertUnconditionalFallthroughBranch();
+  }
+
+  this->sort(([&](MachineBasicBlock &X, MachineBasicBlock &Y) {
+    return (X.isUniqueSection() == Y.isUniqueSection()) ?
+           (MBBOrder[&X] < MBBOrder[&Y]) : !X.isUniqueSection();
+  }));
+
+  this->BBSectionsSorted = true;
+  return true;
+}
+
 /// Allocate a new MachineInstr. Use this instead of `new MachineInstr'.
 MachineInstr *MachineFunction::CreateMachineInstr(const MCInstrDesc &MCID,
                                                   const DebugLoc &DL,
                                                   bool NoImp) {
   return new (InstructionRecycler.Allocate<MachineInstr>(Allocator))
     MachineInstr(*this, MCID, DL, NoImp);
 }
 

llvm/lib/CodeGen/TargetLoweringObjectFileImpl.cpp

 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/BinaryFormat/COFF.h"
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/BinaryFormat/ELF.h"
 #include "llvm/BinaryFormat/MachO.h"
+#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/CodeGen/MachineBasicBlock.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/MachineModuleInfoImpls.h"
 #include "llvm/IR/Comdat.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalAlias.h"
if (Kind.isMergeableConst32() && MergeableConst32Section)
     return MergeableConst32Section;
   if (Kind.isReadOnly())
     return ReadOnlySection;
 
   assert(Kind.isReadOnlyWithRel() && "Unknown section kind");
   return DataRelROSection;
 }
 
+MCSection *TargetLoweringObjectFileELF::getSectionForMachineBasicBlock(
+    const Function &F, const MachineBasicBlock &MBB, const TargetMachine &TM)
+    const {
+  SmallString<128> Name;
+  Name = (static_cast<MCSectionELF*>(MBB.getParent()->getSection()))->getSectionName();
+  if (TM.getUniqueBBSectionNames()) {
+    Name += ".";
+    Name += MBB.getSymbol()->getName();
+  }
+  unsigned UniqueID = NextUniqueID++;
+  unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_EXECINSTR;
+  std::string GroupName = "";
+  if (F.hasComdat()) {
+    Flags |= ELF::SHF_GROUP;
+    GroupName = F.getComdat()->getName();
+  }
+  return getContext().getELFSection(Name, ELF::SHT_PROGBITS,
+      Flags, 0, GroupName, UniqueID);
+}
+
 static MCSectionELF *getStaticStructorSection(MCContext &Ctx, bool UseInitArray,
                                               bool IsCtor, unsigned Priority,
                                               const MCSymbol *KeySym) {
   std::string Name;
   unsigned Type;
   unsigned Flags = ELF::SHF_ALLOC | ELF::SHF_WRITE;
   StringRef COMDAT = KeySym ? KeySym->getName() : "";
 

llvm/lib/IR/BasicBlock.cpp

 #include "llvm/IR/BasicBlock.h"
 #include "SymbolTableListTraitsImpl.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/IR/CFG.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/Type.h"
 #include <algorithm>
 
 using namespace llvm;
 
 ValueSymbolTable *BasicBlock::getValueSymbolTable() {
   if (Function *F = getParent())
     return F->getValueSymbolTable();

llvm/lib/IR/Globals.cpp

bool GlobalValue::isDeclaration() const {
   // Globals are definitions if they have an initializer.
   if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(this))
     return GV->getNumOperands() == 0;
 
   // Functions are definitions if they have a body.
   if (const Function *F = dyn_cast<Function>(this))
     return F->empty() && !F->isMaterializable();
 
+  // A basic block is always defined.
+  if (dyn_cast<BasicBlock>(this))
+    return false;
+
   // Aliases and ifuncs are always definitions.
   assert(isa<GlobalIndirectSymbol>(this));
   return false;
 }
 
 bool GlobalValue::canIncreaseAlignment() const {
   // Firstly, can only increase the alignment of a global if it
   // is a strong definition.

llvm/lib/IR/Mangler.cpp

void Mangler::getNameWithPrefix(raw_ostream &OS, const GlobalValue *GV,
   ManglerPrefixTy PrefixTy = Default;
   if (GV->hasPrivateLinkage()) {
     if (CannotUsePrivateLabel)
       PrefixTy = LinkerPrivate;
     else
       PrefixTy = Private;
   }
 
-  const DataLayout &DL = GV->getParent()->getDataLayout();
+  const DataLayout &DL = (isa<BasicBlock>(GV) ?
+      dyn_cast<BasicBlock>(GV)->getParent()->getParent()->getDataLayout() :
+      GV->getParent()->getDataLayout());
+
   if (!GV->hasName()) {
     // Get the ID for the global, assigning a new one if we haven't got one
     // already.
     unsigned &ID = AnonGlobalIDs[GV];
     if (ID == 0)
       ID = AnonGlobalIDs.size();
 
     // Must mangle the global into a unique ID.

llvm/lib/MC/ELFObjectWriter.cpp

 #include "llvm/MC/MCSectionELF.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/MCSymbolELF.h"
 #include "llvm/MC/MCValue.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Support/Alignment.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Compression.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/SMLoc.h"
bool ELFObjectWriter::shouldRelocateWithSymbol(const MCAssembler &Asm,
                                                const MCSymbolELF *Sym,
                                                uint64_t C,
                                                unsigned Type) const {
   // A PCRel relocation to an absolute value has no symbol (or section). We
   // represent that with a relocation to a null section.
   if (!RefA)
     return false;
 
+  const auto &MAI = Asm.getContext().getAsmInfo();
   MCSymbolRefExpr::VariantKind Kind = RefA->getKind();
   switch (Kind) {
   default:
     break;
   // The .odp creation emits a relocation against the symbol ".TOC." which
   // create a R_PPC64_TOC relocation. However the relocation symbol name
   // in final object creation should be NULL, since the symbol does not
   // really exist, it is just the reference to TOC base for the current
   // object file. Since the symbol is undefined, returning false results
   // in a relocation with a null section which is the desired result.
   case MCSymbolRefExpr::VK_PPC_TOCBASE:
     return false;
 
   // These VariantKind cause the relocation to refer to something other than
   // the symbol itself, like a linker generated table. Since the address of
   // symbol is not relevant, we cannot replace the symbol with the
   // section and patch the difference in the addend.
   case MCSymbolRefExpr::VK_GOT:
   case MCSymbolRefExpr::VK_PLT:
   case MCSymbolRefExpr::VK_GOTPCREL:
   case MCSymbolRefExpr::VK_PPC_GOT_LO:
   case MCSymbolRefExpr::VK_PPC_GOT_HI:
   case MCSymbolRefExpr::VK_PPC_GOT_HA:
     return true;
+
+  case MCSymbolRefExpr::VK_SIZE:
+    if (MAI->shouldRelocateWithSymbols())
+      return true;
+    else
+      break;
   }
 
   // An undefined symbol is not in any section, so the relocation has to point
   // to the symbol itself.
   assert(Sym && "Expected a symbol");
   if (Sym->isUndefined())
     return true;
 
bool ELFObjectWriter::shouldRelocateWithSymbol(const MCAssembler &Asm,
   // bit. With a symbol that is done by just having the symbol have that bit
   // set, so we would lose the bit if we relocated with the section.
   // FIXME: We could use the section but add the bit to the relocation value.
   if (Asm.isThumbFunc(Sym))
     return true;
 
   if (TargetObjectWriter->needsRelocateWithSymbol(*Sym, Type))
     return true;
-  return false;
+  return MAI->shouldRelocateWithSymbols();
 }
 
 void ELFObjectWriter::recordRelocation(MCAssembler &Asm,
                                        const MCAsmLayout &Layout,
                                        const MCFragment *Fragment,
                                        const MCFixup &Fixup, MCValue Target,
                                        uint64_t &FixedValue) {
   MCAsmBackend &Backend = Asm.getBackend();

llvm/lib/MC/MCDwarf.cpp

 #include "llvm/MC/MCObjectFileInfo.h"
 #include "llvm/MC/MCObjectStreamer.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSection.h"
 #include "llvm/MC/MCStreamer.h"
 #include "llvm/MC/MCSymbol.h"
 #include "llvm/MC/StringTableBuilder.h"
 #include "llvm/Support/Casting.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Endian.h"
 #include "llvm/Support/EndianStream.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/LEB128.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/SourceMgr.h"
 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 #include <cstdint>
+#include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
 using namespace llvm;
 
+static cl::opt<bool> NoDedupFDEToCIE(
+    "no-dedup-fde-to-cie",
+    cl::desc("Moves FDE instructions at the beginning of an FDE to CIE"),
+    cl::init(false), cl::Hidden);
+
 /// Manage the .debug_line_str section contents, if we use it.
 class llvm::MCDwarfLineStr {
   MCSymbol *LineStrLabel = nullptr;
   StringTableBuilder LineStrings{StringTableBuilder::DWARF};
   bool UseRelocs = false;
 
 public:
   /// Construct an instance that can emit .debug_line_str (for use in a normal
static void EmitGenDwarfAbbrev(MCStreamer *MCOS) {
   MCOS->EmitULEB128IntValue(dwarf::DW_TAG_unspecified_parameters);
   MCOS->EmitIntValue(dwarf::DW_CHILDREN_no, 1);
   EmitAbbrev(MCOS, 0, 0);
 
   // Terminate the abbreviations for this compilation unit.
   MCOS->EmitIntValue(0, 1);
 }
 
+static const MCExpr *MakeSizeExpr(MCStreamer &MCOS, MCSymbol &Start,
+                                  const MCSymbol &End) {
+  const MCExpr *Range = MakeStartMinusEndExpr(MCOS, Start, End, 0);
+
+  auto MAI = MCOS.getContext().getAsmInfo();
+  if (!MAI->shouldRelocateWithSizeRelocs())
+    return forceExpAbs(MCOS, Range);
+
+  MCOS.emitELFSize(&Start, Range);
+  const MCExpr *RelocatableRange = MCSymbolRefExpr::create(
+      &Start, MCSymbolRefExpr::VK_SIZE, MCOS.getContext());
+  return RelocatableRange;
+}
+
 // When generating dwarf for assembly source files this emits the data for
 // .debug_aranges section. This section contains a header and a table of pairs
 // of PointerSize'ed values for the address and size of section(s) with line
 // table entries.
 static void EmitGenDwarfAranges(MCStreamer *MCOS,
                                 const MCSymbol *InfoSectionSymbol) {
   MCContext &context = MCOS->getContext();
 
static void EmitGenDwarfAranges(MCStreamer *MCOS,
   MCOS->EmitIntValue(0, 1);
   // Align the header with the padding if needed, before we put out the table.
   for(int i = 0; i < Pad; i++)
     MCOS->EmitIntValue(0, 1);
 
   // Now emit the table of pairs of PointerSize'ed values for the section
   // addresses and sizes.
   for (MCSection *Sec : Sections) {
-    const MCSymbol *StartSymbol = Sec->getBeginSymbol();
+    MCSymbol *StartSymbol = Sec->getBeginSymbol();
     MCSymbol *EndSymbol = Sec->getEndSymbol(context);
     assert(StartSymbol && "StartSymbol must not be NULL");
     assert(EndSymbol && "EndSymbol must not be NULL");
 
     const MCExpr *Addr = MCSymbolRefExpr::create(
       StartSymbol, MCSymbolRefExpr::VK_None, context);
-    const MCExpr *Size = MakeStartMinusEndExpr(*MCOS,
-      *StartSymbol, *EndSymbol, 0);
+    const MCExpr *Size = MakeSizeExpr(*MCOS, *StartSymbol, *EndSymbol);
     MCOS->EmitValue(Addr, AddrSize);
-    emitAbsValue(*MCOS, Size, AddrSize);
+    MCOS->EmitValue(Size, AddrSize);
   }
 
   // And finally the pair of terminating zeros.
   MCOS->EmitIntValue(0, AddrSize);
   MCOS->EmitIntValue(0, AddrSize);
 }
 
 // When generating dwarf for assembly source files this emits the data for
static void EmitGenDwarfRanges(MCStreamer *MCOS) {
   auto &Sections = context.getGenDwarfSectionSyms();
 
   const MCAsmInfo *AsmInfo = context.getAsmInfo();
   int AddrSize = AsmInfo->getCodePointerSize();
 
   MCOS->SwitchSection(context.getObjectFileInfo()->getDwarfRangesSection());
 
   for (MCSection *Sec : Sections) {
-    const MCSymbol *StartSymbol = Sec->getBeginSymbol();
+    MCSymbol *StartSymbol = Sec->getBeginSymbol();
     MCSymbol *EndSymbol = Sec->getEndSymbol(context);
     assert(StartSymbol && "StartSymbol must not be NULL");
     assert(EndSymbol && "EndSymbol must not be NULL");
 
     // Emit a base address selection entry for the start of this section
     const MCExpr *SectionStartAddr = MCSymbolRefExpr::create(
       StartSymbol, MCSymbolRefExpr::VK_None, context);
     MCOS->emitFill(AddrSize, 0xFF);
     MCOS->EmitValue(SectionStartAddr, AddrSize);
 
     // Emit a range list entry spanning this section
-    const MCExpr *SectionSize = MakeStartMinusEndExpr(*MCOS,
-      *StartSymbol, *EndSymbol, 0);
+    const MCExpr *SectionSize = MakeSizeExpr(*MCOS, *StartSymbol, *EndSymbol);
+
     MCOS->EmitIntValue(0, AddrSize);
-    emitAbsValue(*MCOS, SectionSize, AddrSize);
+    MCOS->EmitValue(SectionSize, AddrSize);
   }
 
   // Emit end of list entry
   MCOS->EmitIntValue(0, AddrSize);
   MCOS->EmitIntValue(0, AddrSize);
 }
 
 //
public:
 
   /// Emit the unwind information in a compact way.
   void EmitCompactUnwind(const MCDwarfFrameInfo &frame);
 
   const MCSymbol &EmitCIE(const MCDwarfFrameInfo &F);
   void EmitFDE(const MCSymbol &cieStart, const MCDwarfFrameInfo &frame,
                bool LastInSection, const MCSymbol &SectionStart);
   void EmitCFIInstructions(ArrayRef<MCCFIInstruction> Instrs,
-                           MCSymbol *BaseLabel);
+                           MCSymbol *BaseLabel, bool EmitDeduped,
+                           bool EmitNotDeduped);
   void EmitCFIInstruction(const MCCFIInstruction &Instr);
 };
 
 } // end anonymous namespace
 
 static void emitEncodingByte(MCObjectStreamer &Streamer, unsigned Encoding) {
   Streamer.EmitIntValue(Encoding, 1);
 }
void FrameEmitterImpl::EmitCFIInstruction(const MCCFIInstruction &Instr) {
 
   case MCCFIInstruction::OpEscape:
     Streamer.EmitBytes(Instr.getValues());
     return;
   }
   llvm_unreachable("Unhandled case in switch");
 }
 
+static bool ShouldBeDeduped(const MCCFIInstruction &Instr,
+                            const MCSymbol *BaseLabel,
+                            const MCObjectStreamer &Streamer) {
+  if (NoDedupFDEToCIE ||
+      !Streamer.getContext().getAsmInfo()->shouldRelocateWithSymbols())
+    return false;
+
+  if (!BaseLabel || !BaseLabel->isDefined() || !BaseLabel->isInSection())
+    return false;
+
+  MCSymbol *Label = Instr.getLabel();
+
+  if (!Label || !Label->isDefined() || !Label->isInSection())
+    return false;
+
+  return &Label->getSection() == &BaseLabel->getSection() &&
+         Label->getOffset() == BaseLabel->getOffset();
+}
+
 /// Emit frame instructions to describe the layout of the frame.
 void FrameEmitterImpl::EmitCFIInstructions(ArrayRef<MCCFIInstruction> Instrs,
-                                           MCSymbol *BaseLabel) {
+                                           MCSymbol *BaseLabel,
+                                           bool EmitDeduped = true,
+                                           bool EmitNotDeduped = true) {
+  bool InDedupedRange = true;
   for (const MCCFIInstruction &Instr : Instrs) {
     MCSymbol *Label = Instr.getLabel();
     // Throw out move if the label is invalid.
     if (Label && !Label->isDefined()) continue; // Not emitted, in dead code.
 
+    InDedupedRange &= ShouldBeDeduped(Instr, BaseLabel, Streamer);
+    if ((InDedupedRange && !EmitDeduped) ||
+        (!InDedupedRange && !EmitNotDeduped))
+      continue;
+
     // Advance row if new location.
     if (BaseLabel && Label) {
       MCSymbol *ThisSym = Label;
       if (ThisSym != BaseLabel) {
         Streamer.EmitDwarfAdvanceFrameAddr(BaseLabel, ThisSym);
         BaseLabel = ThisSym;
       }
     }
if (!DwarfEHFrameOnly && Frame.Lsda)
     Encoding |= 0x40000000;
 
   // Range Start
   unsigned FDEEncoding = MOFI->getFDEEncoding();
   unsigned Size = getSizeForEncoding(Streamer, FDEEncoding);
   Streamer.EmitSymbolValue(Frame.Begin, Size);
 
   // Range Length
-  const MCExpr *Range = MakeStartMinusEndExpr(Streamer, *Frame.Begin,
-                                              *Frame.End, 0);
-  emitAbsValue(Streamer, Range, 4);
+  const MCExpr *Range = MakeSizeExpr(Streamer, *Frame.Begin, *Frame.End);
+  Streamer.EmitValue(Range, 4);
 
   // Compact Encoding
   Size = getSizeForEncoding(Streamer, dwarf::DW_EH_PE_udata4);
   Streamer.EmitIntValue(Encoding, Size);
 
   // Personality Function
   Size = getSizeForEncoding(Streamer, dwarf::DW_EH_PE_absptr);
   if (!DwarfEHFrameOnly && Frame.Personality)
const MCSymbol &FrameEmitterImpl::EmitCIE(const MCDwarfFrameInfo &Frame) {
   }
 
   // Initial Instructions
 
   const MCAsmInfo *MAI = context.getAsmInfo();
   if (!Frame.IsSimple) {
     const std::vector<MCCFIInstruction> &Instructions =
         MAI->getInitialFrameState();
-    EmitCFIInstructions(Instructions, nullptr);
+    EmitCFIInstructions(Instructions, nullptr, true, true);
+    EmitCFIInstructions(Frame.Instructions, Frame.Begin, true, false);
   }
 
   InitialCFAOffset = CFAOffset;
 
   // Padding
   Streamer.EmitValueToAlignment(IsEH ? 4 : MAI->getCodePointerSize());
 
   Streamer.EmitLabel(sectionEnd);
void FrameEmitterImpl::EmitFDE(const MCSymbol &cieStart,
 
   // PC Begin
   unsigned PCEncoding =
       IsEH ? MOFI->getFDEEncoding() : (unsigned)dwarf::DW_EH_PE_absptr;
   unsigned PCSize = getSizeForEncoding(Streamer, PCEncoding);
   emitFDESymbol(Streamer, *frame.Begin, PCEncoding, IsEH);
 
   // PC Range
-  const MCExpr *Range =
-      MakeStartMinusEndExpr(Streamer, *frame.Begin, *frame.End, 0);
-  emitAbsValue(Streamer, Range, PCSize);
+  const MCExpr *Range = MakeSizeExpr(Streamer, *frame.Begin, *frame.End);
+  Streamer.EmitValue(Range, PCSize);
 
   if (IsEH) {
     // Augmentation Data Length
     unsigned augmentationLength = 0;
 
     if (frame.Lsda)
       augmentationLength += getSizeForEncoding(Streamer, frame.LsdaEncoding);
 
     Streamer.EmitULEB128IntValue(augmentationLength);
 
     // Augmentation Data
     if (frame.Lsda)
       emitFDESymbol(Streamer, *frame.Lsda, frame.LsdaEncoding, true);
   }
 
   // Call Frame Instructions
-  EmitCFIInstructions(frame.Instructions, frame.Begin);
+  EmitCFIInstructions(frame.Instructions, frame.Begin, false, true);
 
   // Padding
   // The size of a .eh_frame section has to be a multiple of the alignment
   // since a null CIE is interpreted as the end. Old systems overaligned
   // .eh_frame, so we do too and account for it in the last FDE.
   unsigned Align = LastInSection ? asmInfo->getCodePointerSize() : PCSize;
   Streamer.EmitValueToAlignment(Align);
 
   Streamer.EmitLabel(fdeEnd);
 }
 
 namespace {
 
 struct CIEKey {
   static const CIEKey getEmptyKey() {
     return CIEKey(nullptr, 0, -1, false, false, static_cast<unsigned>(INT_MAX),
-                  false);
+                  false, nullptr);
   }
 
   static const CIEKey getTombstoneKey() {
     return CIEKey(nullptr, -1, 0, false, false, static_cast<unsigned>(INT_MAX),
-                  false);
+                  false, nullptr);
+  }
+
+  static std::vector<MCCFIInstruction>
+  getDedupedInstructions(const std::vector<MCCFIInstruction> &Instructions,
+                         const MCSymbol *BaseSymbol,
+                         const MCObjectStreamer &Streamer) {
+    std::vector<MCCFIInstruction> DedupedInstructions;
+    for (const auto &Instr : Instructions) {
+      MCSymbol *Label = Instr.getLabel();
+      // Throw out move if the label is invalid.
+      if (Label && !Label->isDefined())
+        continue; // Not emitted, in dead code.
+
+      if (!ShouldBeDeduped(Instr, BaseSymbol, Streamer))
+        break;
+
+      DedupedInstructions.push_back(Instr.StripLabel());
+    }
+    return DedupedInstructions;
   }
 
   CIEKey(const MCSymbol *Personality, unsigned PersonalityEncoding,
          unsigned LSDAEncoding, bool IsSignalFrame, bool IsSimple,
-         unsigned RAReg, bool IsBKeyFrame)
+         unsigned RAReg, bool IsBKeyFrame,
+         const std::vector<MCCFIInstruction> *DedupedInstructions)
       : Personality(Personality), PersonalityEncoding(PersonalityEncoding),
         LsdaEncoding(LSDAEncoding), IsSignalFrame(IsSignalFrame),
-        IsSimple(IsSimple), RAReg(RAReg), IsBKeyFrame(IsBKeyFrame) {}
+        IsSimple(IsSimple), RAReg(RAReg), IsBKeyFrame(IsBKeyFrame),
+        DedupedInstructions(DedupedInstructions) {}
 
-  explicit CIEKey(const MCDwarfFrameInfo &Frame)
+  explicit CIEKey(const MCDwarfFrameInfo &Frame,
+                  const std::vector<MCCFIInstruction> *DedupedInstructions)
       : Personality(Frame.Personality),
         PersonalityEncoding(Frame.PersonalityEncoding),
         LsdaEncoding(Frame.LsdaEncoding), IsSignalFrame(Frame.IsSignalFrame),
         IsSimple(Frame.IsSimple), RAReg(Frame.RAReg),
-        IsBKeyFrame(Frame.IsBKeyFrame) {}
+        IsBKeyFrame(Frame.IsBKeyFrame),
+        DedupedInstructions(DedupedInstructions) {}
 
   StringRef PersonalityName() const {
     if (!Personality)
       return StringRef();
     return Personality->getName();
   }
 
+  const std::vector<MCCFIInstruction> GetDedupedInstructions() const {
+    if (!DedupedInstructions)
+      return {};
+    return *DedupedInstructions;
+  }
+
   bool operator<(const CIEKey &Other) const {
     return std::make_tuple(PersonalityName(), PersonalityEncoding, LsdaEncoding,
-                           IsSignalFrame, IsSimple, RAReg) <
+                           IsSignalFrame, IsSimple, RAReg,
+                           GetDedupedInstructions()) <
            std::make_tuple(Other.PersonalityName(), Other.PersonalityEncoding,
                            Other.LsdaEncoding, Other.IsSignalFrame,
-                           Other.IsSimple, Other.RAReg);
+                           Other.IsSimple, Other.RAReg,
+                           Other.GetDedupedInstructions());
   }
 
   const MCSymbol *Personality;
   unsigned PersonalityEncoding;
   unsigned LsdaEncoding;
   bool IsSignalFrame;
   bool IsSimple;
   unsigned RAReg;
   bool IsBKeyFrame;
+  const std::vector<MCCFIInstruction> *DedupedInstructions;
 };
 
 } // end anonymous namespace
 
 namespace llvm {
 
 template <> struct DenseMapInfo<CIEKey> {
   static CIEKey getEmptyKey() { return CIEKey::getEmptyKey(); }
   static CIEKey getTombstoneKey() { return CIEKey::getTombstoneKey(); }
 
   static unsigned getHashValue(const CIEKey &Key) {
+    const auto &DedupedInstructions = Key.GetDedupedInstructions();
     return static_cast<unsigned>(hash_combine(
         Key.Personality, Key.PersonalityEncoding, Key.LsdaEncoding,
-        Key.IsSignalFrame, Key.IsSimple, Key.RAReg, Key.IsBKeyFrame));
+        Key.IsSignalFrame, Key.IsSimple, Key.RAReg, Key.IsBKeyFrame,
+        hash_combine_range(DedupedInstructions.begin(),
+                           DedupedInstructions.end())));
   }
 
   static bool isEqual(const CIEKey &LHS, const CIEKey &RHS) {
     return LHS.Personality == RHS.Personality &&
            LHS.PersonalityEncoding == RHS.PersonalityEncoding &&
            LHS.LsdaEncoding == RHS.LsdaEncoding &&
            LHS.IsSignalFrame == RHS.IsSignalFrame &&
            LHS.IsSimple == RHS.IsSimple && LHS.RAReg == RHS.RAReg &&
-           LHS.IsBKeyFrame == RHS.IsBKeyFrame;
+           LHS.IsBKeyFrame == RHS.IsBKeyFrame &&
+           LHS.GetDedupedInstructions() == RHS.GetDedupedInstructions();
   }
 };
 
 } // end namespace llvm
 
 void MCDwarfFrameEmitter::Emit(MCObjectStreamer &Streamer, MCAsmBackend *MAB,
                                bool IsEH) {
   Streamer.generateCompactUnwindEncodings(MAB);
void MCDwarfFrameEmitter::Emit(MCObjectStreamer &Streamer, MCAsmBackend *MAB,
   MCSection &Section =
       IsEH ? *const_cast<MCObjectFileInfo *>(MOFI)->getEHFrameSection()
            : *MOFI->getDwarfFrameSection();
 
   Streamer.SwitchSection(&Section);
   MCSymbol *SectionStart = Context.createTempSymbol();
   Streamer.EmitLabel(SectionStart);
 
+  std::map<const MCSymbol *, std::vector<MCCFIInstruction>> DedupedInstructions;
   DenseMap<CIEKey, const MCSymbol *> CIEStarts;
 
+  for (const auto &Frame : FrameArray) {
+    DedupedInstructions[Frame.Begin] =
+        CIEKey::getDedupedInstructions(Frame.Instructions, Frame.Begin,
+                                       Streamer);
+  }
+
   const MCSymbol *DummyDebugKey = nullptr;
   bool CanOmitDwarf = MOFI->getOmitDwarfIfHaveCompactUnwind();
   // Sort the FDEs by their corresponding CIE before we emit them.
   // This isn't technically necessary according to the DWARF standard,
   // but the Android libunwindstack rejects eh_frame sections where
   // an FDE refers to a CIE other than the closest previous CIE.
   std::vector<MCDwarfFrameInfo> FrameArrayX(FrameArray.begin(), FrameArray.end());
   llvm::stable_sort(FrameArrayX,
-                    [](const MCDwarfFrameInfo &X, const MCDwarfFrameInfo &Y) {
-                      return CIEKey(X) < CIEKey(Y);
+                    [&](const MCDwarfFrameInfo &X, const MCDwarfFrameInfo &Y) {
+                      return CIEKey(X, &DedupedInstructions.at(X.Begin)) <
+                             CIEKey(Y, &DedupedInstructions.at(Y.Begin));
                     });
   for (auto I = FrameArrayX.begin(), E = FrameArrayX.end(); I != E;) {
     const MCDwarfFrameInfo &Frame = *I;
     ++I;
     if (CanOmitDwarf && Frame.CompactUnwindEncoding !=
           MOFI->getCompactUnwindDwarfEHFrameOnly())
       // Don't generate an EH frame if we don't need one. I.e., it's taken care
       // of by the compact unwind encoding.
       continue;
 
-    CIEKey Key(Frame);
+    CIEKey Key(Frame, &DedupedInstructions.at(Frame.Begin));
     const MCSymbol *&CIEStart = IsEH ? CIEStarts[Key] : DummyDebugKey;
     if (!CIEStart)
       CIEStart = &Emitter.EmitCIE(Frame);
 
     Emitter.EmitFDE(*CIEStart, Frame, I == E, *SectionStart);
   }
 }
 

llvm/lib/MC/MCTargetOptions.cpp

 #include "llvm/ADT/StringRef.h"
 
 using namespace llvm;
 
 MCTargetOptions::MCTargetOptions()
     : MCRelaxAll(false), MCNoExecStack(false), MCFatalWarnings(false),
       MCNoWarn(false), MCNoDeprecatedWarn(false), MCSaveTempLabels(false),
       MCUseDwarfDirectory(false), MCIncrementalLinkerCompatible(false),
-      MCPIECopyRelocations(false), ShowMCEncoding(false), ShowMCInst(false),
+      MCPIECopyRelocations(false), MCRelocateWithSymbols(false),
+      ShowMCEncoding(false), ShowMCInst(false),
       AsmVerbose(false), PreserveAsmComments(true) {}
 
 StringRef MCTargetOptions::getABIName() const {
   return ABIName;
 }

llvm/lib/Target/AArch64/AArch64FrameLowering.h

 
 class AArch64FrameLowering : public TargetFrameLowering {
 public:
   explicit AArch64FrameLowering()
       : TargetFrameLowering(StackGrowsDown, 16, 0, 16,
                             true /*StackRealignable*/) {}
 
   void emitCalleeSavedFrameMoves(MachineBasicBlock &MBB,
-                                 MachineBasicBlock::iterator MBBI) const;
+                                 MachineBasicBlock::iterator MBBI) const override;
 
   MachineBasicBlock::iterator
   eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB,
                                 MachineBasicBlock::iterator I) const override;
 
   /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
   /// the function.
   void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;

llvm/lib/Target/TargetLoweringObjectFile.cpp

SectionKind TargetLoweringObjectFile::getKindForGlobal(const GlobalObject *GO,
                                                        const TargetMachine &TM){
   assert(!GO->isDeclaration() && !GO->hasAvailableExternallyLinkage() &&
          "Can only be used for global definitions");
 
   // Functions are classified as text sections.
   if (isa<Function>(GO))
     return SectionKind::getText();
 
+  // Basic blocks are classified as text sections.
+  if (isa<BasicBlock>(GO))
+    return SectionKind::getText();
+
   // Global variables require more detailed analysis.
   const auto *GVar = cast<GlobalVariable>(GO);
 
   // Handle thread-local data first.
   if (GVar->isThreadLocal()) {
     if (isSuitableForBSS(GVar) && !TM.Options.NoZerosInBSS)
       return SectionKind::getThreadBSS();
     return SectionKind::getThreadData();
MCSection *TargetLoweringObjectFile::getSectionForConstant(
     const DataLayout &DL, SectionKind Kind, const Constant *C,
     unsigned &Align) const {
   if (Kind.isReadOnly() && ReadOnlySection != nullptr)
     return ReadOnlySection;
 
   return DataSection;
 }
 
+MCSection *TargetLoweringObjectFile::getSectionForMachineBasicBlock(
+    const Function &F, const MachineBasicBlock &MBB, const TargetMachine &TM)
+    const {
+ return nullptr;
+}
+
 /// getTTypeGlobalReference - Return an MCExpr to use for a
 /// reference to the specified global variable from exception
 /// handling information.
 const MCExpr *TargetLoweringObjectFile::getTTypeGlobalReference(
     const GlobalValue *GV, unsigned Encoding, const TargetMachine &TM,
     MachineModuleInfo *MMI, MCStreamer &Streamer) const {
   const MCSymbolRefExpr *Ref =
       MCSymbolRefExpr::create(TM.getSymbol(GV), getContext());

llvm/lib/Target/X86/X86FrameLowering.h

void emitStackProbe(MachineFunction &MF, MachineBasicBlock &MBB,
                       MachineBasicBlock::iterator MBBI, const DebugLoc &DL,
                       bool InProlog) const;
 
   /// Replace a StackProbe inline-stub with the actual probe code inline.
   void inlineStackProbe(MachineFunction &MF,
                         MachineBasicBlock &PrologMBB) const override;
 
   void emitCalleeSavedFrameMoves(MachineBasicBlock &MBB,
+                                 MachineBasicBlock::iterator MBBI) const override;
+
+  void emitCalleeSavedFrameMoves(MachineBasicBlock &MBB,
                                  MachineBasicBlock::iterator MBBI,
                                  const DebugLoc &DL) const;
 
   /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
   /// the function.
   void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
   void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
 

llvm/lib/Target/X86/X86FrameLowering.cpp

void X86FrameLowering::BuildCFI(MachineBasicBlock &MBB,
                                 const MCCFIInstruction &CFIInst) const {
   MachineFunction &MF = *MBB.getParent();
   unsigned CFIIndex = MF.addFrameInst(CFIInst);
   BuildMI(MBB, MBBI, DL, TII.get(TargetOpcode::CFI_INSTRUCTION))
       .addCFIIndex(CFIIndex);
 }
 
 void X86FrameLowering::emitCalleeSavedFrameMoves(
+    MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI) const {
+  emitCalleeSavedFrameMoves(MBB, MBBI, DebugLoc{});
+
+  MachineFunction &MF = *MBB.getParent();
+  if (hasFP(MF)) {
+    const MachineModuleInfo &MMI = MF.getMMI();
+    const MCRegisterInfo *MRI = MMI.getContext().getRegisterInfo();
+    const unsigned FramePtr = TRI->getFrameRegister(MF);
+    const unsigned MachineFramePtr =
+        STI.isTarget64BitILP32()
+            ? unsigned(getX86SubSuperRegister(FramePtr, 64))
+            : FramePtr;
+    unsigned DwarfReg = MRI->getDwarfRegNum(MachineFramePtr, true);
+    // Offset = space for return address + size of the frame pointer itself.
+    unsigned Offset = (Is64Bit ? 8 : 4) + (Uses64BitFramePtr ? 8 : 4);
+    BuildCFI(MBB, MBBI, DebugLoc{},
+             MCCFIInstruction::createOffset(nullptr, DwarfReg, -Offset));
+  }
+}
+
+void X86FrameLowering::emitCalleeSavedFrameMoves(
     MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
     const DebugLoc &DL) const {
   MachineFunction &MF = *MBB.getParent();
   MachineFrameInfo &MFI = MF.getFrameInfo();
   MachineModuleInfo &MMI = MF.getMMI();
   const MCRegisterInfo *MRI = MMI.getContext().getRegisterInfo();
 
   // Add callee saved registers to move list.

llvm/lib/Transforms/Utils/ModuleUtils.cpp

void llvm::filterDeadComdatFunctions(
 
   // Remove the entries that were not covering.
   erase_if(DeadComdatFunctions, [&](GlobalValue *GV) {
     return ComdatEntriesCovered.find(GV->getComdat()) ==
            ComdatEntriesCovered.end();
   });
 }
 
-std::string llvm::getUniqueModuleId(Module *M) {
+std::string llvm::getUniqueModuleId(Module *M,
+                                    bool UseModuleId) {
   MD5 Md5;
   bool ExportsSymbols = false;
   auto AddGlobal = [&](GlobalValue &GV) {
     if (GV.isDeclaration() || GV.getName().startswith("llvm.") ||
         !GV.hasExternalLinkage() || GV.hasComdat())
       return;
     ExportsSymbols = true;
     Md5.update(GV.getName());
     Md5.update(ArrayRef<uint8_t>{0});
   };
 
   for (auto &F : *M)
     AddGlobal(F);
   for (auto &GV : M->globals())
     AddGlobal(GV);
   for (auto &GA : M->aliases())
     AddGlobal(GA);
   for (auto &IF : M->ifuncs())
     AddGlobal(IF);
 
+  // Using only module id is not guaranteed to keep this unique. So we augment
+  // the hash with the module id. This also handles the case when we have
+  // multiple definitions of the same globals in different modules (allowed by
+  // the "-z muldefs" linker flag).
+  if (UseModuleId && !M->getModuleIdentifier().empty()) {
+    Md5.update(M->getModuleIdentifier());
+    Md5.update(ArrayRef<uint8_t>{0});
+  } else {
     if (!ExportsSymbols)
       return "";
+  }
 
   MD5::MD5Result R;
   Md5.final(R);
 
   SmallString<32> Str;
   MD5::stringifyResult(R, Str);
   return ("$" + Str).str();
 }

llvm/test/CodeGen/X86/basicblock-sections.ll

+; RUN: llc < %s -mtriple=x86_64-pc-linux -function-sections -basicblock-sections=all -unique-bb-section-names | FileCheck %s -check-prefix=LINUX-SECTIONS
+; RUN: llc < %s -mtriple=i386-unknown-linux-gnu  -function-sections -basicblock-sections=all -unique-bb-section-names | FileCheck %s -check-prefix=LINUX-SECTIONS
+
+define void @_Z3bazb(i1 zeroext) {
+  %2 = alloca i8, align 1
+  %3 = zext i1 %0 to i8
+  store i8 %3, i8* %2, align 1
+  %4 = load i8, i8* %2, align 1
+  %5 = trunc i8 %4 to i1
+  br i1 %5, label %6, label %8
+
+6:                                                ; preds = %1
+  %7 = call i32 @_Z3barv()
+  br label %10
+
+8:                                                ; preds = %1
+  %9 = call i32 @_Z3foov()
+  br label %10
+
+10:                                               ; preds = %8, %6
+  ret void
+}
+
+declare i32 @_Z3barv() #1
+
+declare i32 @_Z3foov() #1
+
+
+; LINUX-SECTIONS: .section        .text._Z3bazb,"ax",@progbits
+; LINUX-SECTIONS: _Z3bazb:
+; LINUX-SECTIONS: .section        .text._Z3bazb.a.BB._Z3bazb,"ax",@progbits,unique,1
+; LINUX-SECTIONS: a.BB._Z3bazb:
+; LINUX-SECTIONS: .size   a.BB._Z3bazb, .Ltmp0-a.BB._Z3bazb
+; LINUX-SECTIONS: .section        .text._Z3bazb.aa.BB._Z3bazb,"ax",@progbits,unique,2
+; LINUX-SECTIONS: aa.BB._Z3bazb:
+; LINUX-SECTIONS: .size   aa.BB._Z3bazb, .Ltmp1-aa.BB._Z3bazb

llvm/test/DebugInfo/X86/basicblock-sections-cfi.ll

+; RUN: llc -O0 %s --basicblock-sections=all -mtriple=x86_64-unknown-linux-gnu -filetype=asm -o - | FileCheck --check-prefix=SECTIONS_CFI %s
+; RUN: llc -O0 %s --basicblock-sections=all -mtriple=x86_64-unknown-linux-gnu -filetype=obj -o - | llvm-dwarfdump --debug-frame  - | FileCheck --check-prefix=DEBUG_FRAME %s
+
+; From:
+; int foo(int a) {
+;   if (a > 20)
+;     return 2;
+;   else
+;     return 0;
+; }
+
+; SECTIONS_CFI: _Z3fooi
+; SECTIONS_CFI: .cfi_startproc
+; SECTIONS_CFI: .cfi_def_cfa_offset
+; SECTIONS_CFI: .cfi_def_cfa_register
+; SECTIONS_CFI: .cfi_endproc
+
+; SECTIONS_CFI: a.BB._Z3fooi
+; SECTIONS_CFI-NEXT: .cfi_startproc
+; SECTIONS_CFI-NEXT: .cfi_def_cfa
+; SECTIONS_CFI-NEXT: .cfi_offset
+; SECTIONS_CFI: .cfi_endproc
+
+; SECTIONS_CFI: aa.BB._Z3fooi
+; SECTIONS_CFI-NEXT: .cfi_startproc
+; SECTIONS_CFI-NEXT: .cfi_def_cfa
+; SECTIONS_CFI-NEXT: .cfi_offset
+; SECTIONS_CFI: .cfi_endproc
+
+
+; There must be 2 CIEs and 4 FDEs
+
+; DEBUG_FRAME: .debug_frame contents
+
+; DEBUG_FRAME: CIE
+; DEBUG_FRAME: DW_CFA_def_cfa
+; DEBUG_FRAME: DW_CFA_offset
+
+; DEBUG_FRAME: FDE cie=
+; DEBUG_FRAME: DW_CFA_def_cfa_offset
+; DEBUG_FRAME: DW_CFA_def_cfa_register
+
+; DEBUG_FRAME: CIE
+; DEBUG_FRAME: DW_CFA_def_cfa
+; DEBUG_FRAME: DW_CFA_def_cfa
+
+; DEBUG_FRAME: FDE cie=
+
+; DEBUG_FRAME: FDE cie=
+
+; DEBUG_FRAME: FDE cie=
+; DEBUG_FRAME: DW_CFA_def_cfa
+
+
+source_filename = "debuginfo.cc"
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: noinline nounwind optnone uwtable
+define dso_local i32 @_Z3fooi(i32 %0) #0 !dbg !7 {
+  %2 = alloca i32, align 4
+  %3 = alloca i32, align 4
+  store i32 %0, i32* %3, align 4
+  call void @llvm.dbg.declare(metadata i32* %3, metadata !11, metadata !DIExpression()), !dbg !12
+  %4 = load i32, i32* %3, align 4, !dbg !13
+  %5 = icmp sgt i32 %4, 20, !dbg !15
+  br i1 %5, label %6, label %7, !dbg !16
+
+6:                                                ; preds = %1
+  store i32 2, i32* %2, align 4, !dbg !17
+  br label %8, !dbg !17
+
+7:                                                ; preds = %1
+  store i32 0, i32* %2, align 4, !dbg !18
+  br label %8, !dbg !18
+
+8:                                                ; preds = %7, %6
+  %9 = load i32, i32* %2, align 4, !dbg !19
+  ret i32 %9, !dbg !19
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+attributes #0 = { noinline nounwind optnone uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { nounwind readnone speculatable willreturn }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 10.0.0 ([e-mail]:google/llvm-propeller.git f9421ebf4b3d8b64678bf6c49d1607fdce3f50c5)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None)
+!1 = !DIFile(filename: "debuginfo.cc", directory: "/g/tmsriram/Projects_2019/github_repo/Examples")
+!2 = !{}
+!3 = !{i32 2, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 10.0.0 ([e-mail]:google/llvm-propeller.git f9421ebf4b3d8b64678bf6c49d1607fdce3f50c5)"}
+!7 = distinct !DISubprogram(name: "foo", linkageName: "_Z3fooi", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
+!8 = !DISubroutineType(types: !9)
+!9 = !{!10, !10}
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = !DILocalVariable(name: "a", arg: 1, scope: !7, file: !1, line: 1, type: !10)
+!12 = !DILocation(line: 1, column: 13, scope: !7)
+!13 = !DILocation(line: 2, column: 7, scope: !14)
+!14 = distinct !DILexicalBlock(scope: !7, file: !1, line: 2, column: 7)
+!15 = !DILocation(line: 2, column: 9, scope: !14)
+!16 = !DILocation(line: 2, column: 7, scope: !7)
+!17 = !DILocation(line: 3, column: 5, scope: !14)
+!18 = !DILocation(line: 5, column: 5, scope: !14)
+!19 = !DILocation(line: 6, column: 1, scope: !7)

llvm/test/DebugInfo/X86/basicblock-sections-cfiinstr.ll

+; RUN: llc -O3 %s -mtriple=x86_64-unknown-linux-gnu -filetype=asm --basicblock-sections=all  -stop-after=cfi-instr-inserter  -o - | FileCheck --check-prefix=CFI_INSTR %s
+
+; CFI_INSTR: _Z7computebiiiiiiiiiiii
+; CFI_INSTR: bb.0
+; CFI_INSTR: CFI_INSTRUCTION def_cfa_offset
+; CFI_INSTR: bb.1
+; CFI_INSTR: CFI_INSTRUCTION def_cfa $rsp
+; CFI_INSTR-NEXT: CFI_INSTRUCTION offset
+; CFI_INSTR-NEXT: CFI_INSTRUCTION offset
+; CFI_INSTR-NEXT: CFI_INSTRUCTION offset
+; CFI_INSTR: bb.2
+; CFI_INSTR: CFI_INSTRUCTION def_cfa $rsp
+; CFI_INSTR-NEXT: CFI_INSTRUCTION offset
+; CFI_INSTR-NEXT: CFI_INSTRUCTION offset
+; CFI_INSTR-NEXT: CFI_INSTRUCTION offset
+; CFI_INSTR: bb.3
+; CFI_INSTR: CFI_INSTRUCTION def_cfa $rsp
+; CFI_INSTR-NEXT: CFI_INSTRUCTION offset
+; CFI_INSTR-NEXT: CFI_INSTRUCTION offset
+; CFI_INSTR-NEXT: CFI_INSTRUCTION offset
+
+; From:
+; int compute(bool k, int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8, int p9, int pa, int pb, int pc) {
+;  int result;
+;  if (k)
+;    result = p1 * p2 + p3 / p4 - p5 * p6 + p7 / p8 - p9 * pa + pb / pc;
+;  else
+;    result = p1 / p2 - p3 * p4 + p5 / p6 - p7 * p8 + p9 / pa - pb * pc;
+;  return result;
+; }
+
+; ModuleID = 'use_regs.tmp.bc'
+source_filename = "use_regs.cc"
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: norecurse nounwind readnone uwtable
+define dso_local i32 @_Z7computebiiiiiiiiiiii(i1 zeroext %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5, i32 %6, i32 %7, i32 %8, i32 %9, i32 %10, i32 %11, i32 %12) local_unnamed_addr #0 !dbg !7 {
+  call void @llvm.dbg.value(metadata i1 %0, metadata !13, metadata !DIExpression()), !dbg !27
+  call void @llvm.dbg.value(metadata i32 %1, metadata !14, metadata !DIExpression()), !dbg !27
+  call void @llvm.dbg.value(metadata i32 %2, metadata !15, metadata !DIExpression()), !dbg !27
+  call void @llvm.dbg.value(metadata i32 %3, metadata !16, metadata !DIExpression()), !dbg !27
+  call void @llvm.dbg.value(metadata i32 %4, metadata !17, metadata !DIExpression()), !dbg !27
+  call void @llvm.dbg.value(metadata i32 %5, metadata !18, metadata !DIExpression()), !dbg !27
+  call void @llvm.dbg.value(metadata i32 %6, metadata !19, metadata !DIExpression()), !dbg !27
+  call void @llvm.dbg.value(metadata i32 %7, metadata !20, metadata !DIExpression()), !dbg !27
+  call void @llvm.dbg.value(metadata i32 %8, metadata !21, metadata !DIExpression()), !dbg !27
+  call void @llvm.dbg.value(metadata i32 %9, metadata !22, metadata !DIExpression()), !dbg !27
+  call void @llvm.dbg.value(metadata i32 %10, metadata !23, metadata !DIExpression()), !dbg !27
+  call void @llvm.dbg.value(metadata i32 %11, metadata !24, metadata !DIExpression()), !dbg !27
+  call void @llvm.dbg.value(metadata i32 %12, metadata !25, metadata !DIExpression()), !dbg !27
+  br i1 %0, label %14, label %22, !dbg !28
+
+14:                                               ; preds = %13
+  %15 = mul nsw i32 %2, %1, !dbg !29
+  %16 = sdiv i32 %3, %4, !dbg !31
+  %.neg28 = mul i32 %6, %5
+  %17 = sdiv i32 %7, %8, !dbg !32
+  %.neg29 = mul i32 %10, %9
+  %18 = sdiv i32 %11, %12, !dbg !33
+  %reass.add30 = add i32 %.neg29, %.neg28
+  %19 = sub i32 %15, %reass.add30, !dbg !34
+  %20 = add i32 %19, %16, !dbg !35
+  %21 = add i32 %20, %17, !dbg !36
+  br label %28, !dbg !37
+
+22:                                               ; preds = %13
+  %23 = sdiv i32 %1, %2, !dbg !38
+  %.neg = mul i32 %4, %3
+  %24 = sdiv i32 %5, %6, !dbg !39
+  %.neg25 = mul i32 %8, %7
+  %25 = sdiv i32 %9, %10, !dbg !40
+  %.neg26 = mul i32 %12, %11
+  %reass.add = add i32 %.neg25, %.neg
+  %reass.add27 = add i32 %reass.add, %.neg26
+  %26 = sub i32 %23, %reass.add27, !dbg !41
+  %27 = add i32 %26, %24, !dbg !42
+  call void @llvm.dbg.value(metadata i32 %29, metadata !26, metadata !DIExpression()), !dbg !27
+  br label %28
+
+28:                                               ; preds = %22, %14
+  %.sink32 = phi i32 [ %25, %22 ], [ %18, %14 ]
+  %.sink = phi i32 [ %27, %22 ], [ %21, %14 ]
+  %29 = add i32 %.sink, %.sink32, !dbg !43
+  call void @llvm.dbg.value(metadata i32 %29, metadata !26, metadata !DIExpression()), !dbg !27
+  ret i32 %29, !dbg !44
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.value(metadata, metadata, metadata) #1
+
+attributes #0 = { norecurse nounwind readnone uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="none" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { nounwind readnone speculatable willreturn }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 10.0.0 ([e-mail]:google/llvm-propeller.git e414756c805463af90acd9bff57e6b1c805b7925)", isOptimized: true, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None)
+!1 = !DIFile(filename: "use_regs.cc", directory: "/g/tmsriram/Projects_2019/github_repo/Examples")
+!2 = !{}
+!3 = !{i32 2, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 10.0.0 ([e-mail]:google/llvm-propeller.git e414756c805463af90acd9bff57e6b1c805b7925)"}
+!7 = distinct !DISubprogram(name: "compute", linkageName: "_Z7computebiiiiiiiiiiii", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition | DISPFlagOptimized, unit: !0, retainedNodes: !12)
+!8 = !DISubroutineType(types: !9)
+!9 = !{!10, !11, !10, !10, !10, !10, !10, !10, !10, !10, !10, !10, !10, !10}
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = !DIBasicType(name: "bool", size: 8, encoding: DW_ATE_boolean)
+!12 = !{!13, !14, !15, !16, !17, !18, !19, !20, !21, !22, !23, !24, !25, !26}
+!13 = !DILocalVariable(name: "k", arg: 1, scope: !7, file: !1, line: 1, type: !11)
+!14 = !DILocalVariable(name: "p1", arg: 2, scope: !7, file: !1, line: 1, type: !10)
+!15 = !DILocalVariable(name: "p2", arg: 3, scope: !7, file: !1, line: 1, type: !10)
+!16 = !DILocalVariable(name: "p3", arg: 4, scope: !7, file: !1, line: 1, type: !10)
+!17 = !DILocalVariable(name: "p4", arg: 5, scope: !7, file: !1, line: 1, type: !10)
+!18 = !DILocalVariable(name: "p5", arg: 6, scope: !7, file: !1, line: 1, type: !10)
+!19 = !DILocalVariable(name: "p6", arg: 7, scope: !7, file: !1, line: 1, type: !10)
+!20 = !DILocalVariable(name: "p7", arg: 8, scope: !7, file: !1, line: 1, type: !10)
+!21 = !DILocalVariable(name: "p8", arg: 9, scope: !7, file: !1, line: 1, type: !10)
+!22 = !DILocalVariable(name: "p9", arg: 10, scope: !7, file: !1, line: 1, type: !10)
+!23 = !DILocalVariable(name: "pa", arg: 11, scope: !7, file: !1, line: 1, type: !10)
+!24 = !DILocalVariable(name: "pb", arg: 12, scope: !7, file: !1, line: 1, type: !10)
+!25 = !DILocalVariable(name: "pc", arg: 13, scope: !7, file: !1, line: 1, type: !10)
+!26 = !DILocalVariable(name: "result", scope: !7, file: !1, line: 2, type: !10)
+!27 = !DILocation(line: 0, scope: !7)
+!28 = !DILocation(line: 3, column: 7, scope: !7)
+!29 = !DILocation(line: 4, column: 17, scope: !30)
+!30 = distinct !DILexicalBlock(scope: !7, file: !1, line: 3, column: 7)
+!31 = !DILocation(line: 4, column: 27, scope: !30)
+!32 = !DILocation(line: 4, column: 47, scope: !30)
+!33 = !DILocation(line: 4, column: 67, scope: !30)
+!34 = !DILocation(line: 4, column: 32, scope: !30)
+!35 = !DILocation(line: 4, column: 42, scope: !30)
+!36 = !DILocation(line: 4, column: 52, scope: !30)
+!37 = !DILocation(line: 4, column: 5, scope: !30)
+!38 = !DILocation(line: 6, column: 17, scope: !30)
+!39 = !DILocation(line: 6, column: 37, scope: !30)
+!40 = !DILocation(line: 6, column: 57, scope: !30)
+!41 = !DILocation(line: 6, column: 42, scope: !30)
+!42 = !DILocation(line: 6, column: 52, scope: !30)
+!43 = !DILocation(line: 0, scope: !30)
+!44 = !DILocation(line: 7, column: 3, scope: !7)

llvm/test/DebugInfo/X86/basicblock-sections_1.ll

+; RUN: llc -O0 %s -mtriple=x86_64-unknown-linux-gnu -filetype=obj -o %t
+; llvm-dwarfdump  -debug-abbrev %t | FileCheck --check-prefix=NO-NOSECTIONS %s
+
+; RUN: llc -O0 %s --basicblock-sections=all -mtriple=x86_64-unknown-linux-gnu -filetype=obj -o %t
+; llvm-dwarfdump  -debug-abbrev %t | FileCheck --check-prefix=BB-SECTIONS %s
+; RUN: llvm-readobj --relocations %t | FileCheck --check-prefix=BB-SECTIONS-RELOCS %s
+; From:
+; int foo(int a) {
+;   if (a > 20)
+;     return 2;
+;   else
+;     return 0;
+; }
+
+; NO-SECTIONS: DW_AT_low_pc
+; NOSECTIONS: DW_AT_high_pc
+; BB-SECTIONS: DW_AT_low_pc
+; BB-SECTIONS: DW_AT_ranges
+; BB-SECTIONS-RELOCS: R_X86_64_64 a.BB._Z3fooi
+; BB-SECTIONS-RELOCS-NEXT: R_X86_64_64
+; BB-SECTIONS-RELOCS-NEXT: R_X86_64_64 aa.BB._Z3fooi
+; BB-SECTIONS-RELOCS-NEXT: R_X86_64_64
+; BB-SECTIONS-RELOCS: R_X86_64_SIZE32
+
+source_filename = "debuginfo.cc"
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+; Function Attrs: noinline nounwind optnone uwtable
+define dso_local i32 @_Z3fooi(i32 %0) #0 !dbg !7 {
+  %2 = alloca i32, align 4
+  %3 = alloca i32, align 4
+  store i32 %0, i32* %3, align 4
+  call void @llvm.dbg.declare(metadata i32* %3, metadata !11, metadata !DIExpression()), !dbg !12
+  %4 = load i32, i32* %3, align 4, !dbg !13
+  %5 = icmp sgt i32 %4, 20, !dbg !15
+  br i1 %5, label %6, label %7, !dbg !16
+
+6:                                                ; preds = %1
+  store i32 2, i32* %2, align 4, !dbg !17
+  br label %8, !dbg !17
+
+7:                                                ; preds = %1
+  store i32 0, i32* %2, align 4, !dbg !18
+  br label %8, !dbg !18
+
+8:                                                ; preds = %7, %6
+  %9 = load i32, i32* %2, align 4, !dbg !19
+  ret i32 %9, !dbg !19
+}
+
+; Function Attrs: nounwind readnone speculatable willreturn
+declare void @llvm.dbg.declare(metadata, metadata, metadata) #1
+
+attributes #0 = { noinline nounwind optnone uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "frame-pointer"="all" "less-precise-fpmad"="false" "min-legal-vector-width"="0" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+cx8,+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+attributes #1 = { nounwind readnone speculatable willreturn }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4, !5}
+!llvm.ident = !{!6}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 10.0.0 ([e-mail]:google/llvm-propeller.git f9421ebf4b3d8b64678bf6c49d1607fdce3f50c5)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None)
+!1 = !DIFile(filename: "debuginfo.cc", directory: "/g/tmsriram/Projects_2019/github_repo/Examples")
+!2 = !{}
+!3 = !{i32 2, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{i32 1, !"wchar_size", i32 4}
+!6 = !{!"clang version 10.0.0 ([e-mail]:google/llvm-propeller.git f9421ebf4b3d8b64678bf6c49d1607fdce3f50c5)"}
+!7 = distinct !DISubprogram(name: "foo", linkageName: "_Z3fooi", scope: !1, file: !1, line: 1, type: !8, scopeLine: 1, flags: DIFlagPrototyped, spFlags: DISPFlagDefinition, unit: !0, retainedNodes: !2)
+!8 = !DISubroutineType(types: !9)
+!9 = !{!10, !10}
+!10 = !DIBasicType(name: "int", size: 32, encoding: DW_ATE_signed)
+!11 = !DILocalVariable(name: "a", arg: 1, scope: !7, file: !1, line: 1, type: !10)
+!12 = !DILocation(line: 1, column: 13, scope: !7)
+!13 = !DILocation(line: 2, column: 7, scope: !14)
+!14 = distinct !DILexicalBlock(scope: !7, file: !1, line: 2, column: 7)
+!15 = !DILocation(line: 2, column: 9, scope: !14)
+!16 = !DILocation(line: 2, column: 7, scope: !7)
+!17 = !DILocation(line: 3, column: 5, scope: !14)
+!18 = !DILocation(line: 5, column: 5, scope: !14)
+!19 = !DILocation(line: 6, column: 1, scope: !7)