[Propeller] Add HasIndirectBranch to BBEntry::Metadata.

[rahmanl]

Summary

This information helps to avoid considering cloning for blocks with indirect branches.

[rahmanl]

Fix comment.

[jhenderson]

Implementation in this change looks good, but I don't feel like I have enough knowledge of what this is for etc to give a thumbs up on that side, so somebody else should review too.

llvm/include/llvm/Object/ELFTypes.h

 };
 
 // Struct representing the BBAddrMap for one function.
 struct BBAddrMap {
   uint64_t Addr; // Function address
   // Struct representing the BBAddrMap information for one basic block.
   struct BBEntry {
     struct Metadata {
-      bool HasReturn : 1;   // If this block ends with a return (or tail call).
-      bool HasTailCall : 1; // If this block ends with a tail call.
-      bool IsEHPad : 1;     // If this is an exception handling block.
-      bool CanFallThrough : 1; // If this block can fall through to its next.
+      bool HasReturn : 1;         // If this block ends with a return (or tail
+                                  // call).
+      bool HasTailCall : 1;       // If this block ends with a tail call.
+      bool IsEHPad : 1;           // If this is an exception handling block.
+      bool CanFallThrough : 1;    // If this block can fall through to its next.
+      bool HasIndirectBranch : 1; // If this block ends with an indirect branch
+                                  // (branch via a register).
 
       bool operator==(const Metadata &Other) const {
         return HasReturn == Other.HasReturn &&
                HasTailCall == Other.HasTailCall && IsEHPad == Other.IsEHPad &&
-               CanFallThrough == Other.CanFallThrough;
+               CanFallThrough == Other.CanFallThrough &&
+               HasIndirectBranch == Other.HasIndirectBranch;
       }
 
       // Encodes this struct as a uint32_t value.
       uint32_t encode() const {
         return static_cast<uint32_t>(HasReturn) |
                (static_cast<uint32_t>(HasTailCall) << 1) |
                (static_cast<uint32_t>(IsEHPad) << 2) |
-               (static_cast<uint32_t>(CanFallThrough) << 3);
+               (static_cast<uint32_t>(CanFallThrough) << 3) |
+               (static_cast<uint32_t>(HasIndirectBranch) << 4);
       }
 
       // Decodes and returns a Metadata struct from a uint32_t value.
       static Expected<Metadata> decode(uint32_t V) {
         Metadata MD{/*HasReturn=*/static_cast<bool>(V & 1),
                     /*HasTailCall=*/static_cast<bool>(V & (1 << 1)),
                     /*IsEHPad=*/static_cast<bool>(V & (1 << 2)),
-                    /*CanFallThrough=*/static_cast<bool>(V & (1 << 3))};
+                    /*CanFallThrough=*/static_cast<bool>(V & (1 << 3)),
+                    /*HasIndirectBranch=*/static_cast<bool>(V & (1 << 4))};
         if (MD.encode() != V)
           return createStringError(
               std::error_code(), "invalid encoding for BBEntry::Metadata: 0x%x",
               V);
         return MD;
       }
     };
 

llvm/lib/CodeGen/AsmPrinter/AsmPrinter.cpp

 
 /// Returns the BB metadata to be emitted in the SHT_LLVM_BB_ADDR_MAP section
 /// for a given basic block. This can be used to capture more precise profile
 /// information.
 static uint32_t getBBAddrMapMetadata(const MachineBasicBlock &MBB) {
   const TargetInstrInfo *TII = MBB.getParent()->getSubtarget().getInstrInfo();
   return object::BBAddrMap::BBEntry::Metadata{
       MBB.isReturnBlock(), !MBB.empty() && TII->isTailCall(MBB.back()),
-      MBB.isEHPad(), const_cast<MachineBasicBlock &>(MBB).canFallThrough()}
+      MBB.isEHPad(), const_cast<MachineBasicBlock &>(MBB).canFallThrough(),
+      !MBB.empty() && MBB.rbegin()->isIndirectBranch()}
       .encode();
 }
 
 void AsmPrinter::emitBBAddrMapSection(const MachineFunction &MF) {
   MCSection *BBAddrMapSection =
       getObjFileLowering().getBBAddrMapSection(*MF.getSection());
   assert(BBAddrMapSection && ".llvm_bb_addr_map section is not initialized.");
 

llvm/test/CodeGen/X86/basic-block-sections-labels.ll

 ; Check the basic block sections labels option
 ; RUN: llc < %s -mtriple=x86_64 -function-sections -unique-section-names=true -basic-block-sections=labels | FileCheck %s --check-prefixes=CHECK,UNIQ
 ; RUN: llc < %s -mtriple=x86_64 -function-sections -unique-section-names=false -basic-block-sections=labels | FileCheck %s --check-prefixes=CHECK,NOUNIQ
 ; RUN: llc < %s -mtriple=x86_64 -function-sections -unique-section-names=true -basic-block-sections=labels -split-machine-functions | FileCheck %s --check-prefixes=CHECK,UNIQ
 
-define void @_Z3bazb(i1 zeroext) personality ptr @__gxx_personality_v0 {
-  br i1 %0, label %2, label %7
+define void @_Z3bazb(i1 zeroext, i1 zeroext) personality ptr @__gxx_personality_v0 {
+  br i1 %0, label %3, label %8
 
-2:
-  %3 = invoke i32 @_Z3barv()
-          to label %7 unwind label %5
-  br label %9
+3:
+  %4 = invoke i32 @_Z3barv()
+          to label %8 unwind label %6
+  br label %10
 
-5:
+6:
   landingpad { ptr, i32 }
           catch ptr null
-  br label %9
+  br label %12
 
-7:
-  %8 = call i32 @_Z3foov()
-  br label %9
+8:
+  %9 = call i32 @_Z3foov()
+  br i1 %1, label %12, label %10
 
-9:
+10:
+  %11 = select i1 %1, ptr blockaddress(@_Z3bazb, %3), ptr blockaddress(@_Z3bazb, %12) ; <ptr> [#uses=1]
+  indirectbr ptr %11, [label %3, label %12]
+
+12:
   ret void
 }
 
 declare i32 @_Z3barv() #1
 
 declare i32 @_Z3foov() #1
 
 declare i32 @__gxx_personality_v0(...)

 ; CHECK-LABEL:  .Lfunc_end0:
 
 ; UNIQ:     .section  .llvm_bb_addr_map,"o",@llvm_bb_addr_map,.text._Z3bazb{{$}}
 ;; Verify that with -unique-section-names=false, the unique id of the text section gets assigned to the llvm_bb_addr_map section.
 ; NOUNIQ:   .section  .llvm_bb_addr_map,"o",@llvm_bb_addr_map,.text,unique,1
 ; CHECK-NEXT:   .byte   2   # version
 ; CHECK-NEXT:   .byte   0   # feature
 ; CHECK-NEXT: .quad .Lfunc_begin0 # function address
-; CHECK-NEXT: .byte 4   # number of basic blocks
+; CHECK-NEXT: .byte 6   # number of basic blocks
 ; CHECK-NEXT:   .byte 0   # BB id
 ; CHECK-NEXT: .uleb128 .Lfunc_begin0-.Lfunc_begin0
 ; CHECK-NEXT: .uleb128 .LBB_END0_0-.Lfunc_begin0
 ; CHECK-NEXT: .byte 8
 ; CHECK-NEXT:   .byte 1   # BB id
 ; CHECK-NEXT: .uleb128 .LBB0_1-.LBB_END0_0
 ; CHECK-NEXT: .uleb128 .LBB_END0_1-.LBB0_1
 ; CHECK-NEXT: .byte 8
 ; CHECK-NEXT:   .byte 3   # BB id
 ; CHECK-NEXT: .uleb128 .LBB0_2-.LBB_END0_1
 ; CHECK-NEXT: .uleb128 .LBB_END0_2-.LBB0_2
-; CHECK-NEXT: .byte 1
-; CHECK-NEXT:   .byte 2   # BB id
+; CHECK-NEXT: .byte 8
+; CHECK-NEXT:   .byte 4   # BB id
 ; CHECK-NEXT: .uleb128 .LBB0_3-.LBB_END0_2
 ; CHECK-NEXT: .uleb128 .LBB_END0_3-.LBB0_3
+; CHECK-NEXT: .byte 16
+; CHECK-NEXT:   .byte 5   # BB id
+; CHECK-NEXT: .uleb128 .LBB0_4-.LBB_END0_3
+; CHECK-NEXT: .uleb128 .LBB_END0_4-.LBB0_4
+; CHECK-NEXT: .byte 1
+; CHECK-NEXT:   .byte 2   # BB id
+; CHECK-NEXT: .uleb128 .LBB0_5-.LBB_END0_4
+; CHECK-NEXT: .uleb128 .LBB_END0_5-.LBB0_5
 ; CHECK-NEXT: .byte 5

llvm/test/tools/llvm-readobj/ELF/bb-addr-map-relocatable.test

 # CHECK-NEXT:       {
 # CHECK-NEXT:         ID: 0
 # CHECK-NEXT:         Offset: 0x0
 # CHECK-NEXT:         Size: 0xF
 # CHECK-NEXT:         HasReturn: Yes
 # CHECK-NEXT:         HasTailCall: No
 # CHECK-NEXT:         IsEHPad: No
 # CHECK-NEXT:         CanFallThrough: No
+# CHECK-NEXT:         HasIndirectBranch: No
 # CHECK-NEXT:       }
 # CHECK-NEXT:     ]
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Function {
 # CHECK-NEXT:     At: 0x10
 # CHECK-NEXT:     Name: <?>
 # CHECK-NEXT:     BB entries [
 # CHECK-NEXT:       {
 # CHECK-NEXT:         ID: 0
 # CHECK-NEXT:         Offset: 0x0
 # CHECK-NEXT:         Size: 0x11
 # CHECK-NEXT:         HasReturn: No
 # CHECK-NEXT:         HasTailCall: No
 # CHECK-NEXT:         IsEHPad: No
 # CHECK-NEXT:         CanFallThrough: Yes
+# CHECK-NEXT:         HasIndirectBranch: No
 # CHECK-NEXT:       }
 # CHECK-NEXT:     ]
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64

 # ET-DYN-NO-WARNING:       {
 # ET-DYN-NO-WARNING:         ID: 0
 # ET-DYN-NO-WARNING:         Offset: 0x0
 # ET-DYN-NO-WARNING:         Size: 0xF
 # ET-DYN-NO-WARNING:         HasReturn: Yes
 # ET-DYN-NO-WARNING:         HasTailCall: No
 # ET-DYN-NO-WARNING:         IsEHPad: No
 # ET-DYN-NO-WARNING:         CanFallThrough: No
+# ET-DYN-NO-WARNING:         HasIndirectBranch: No
 # ET-DYN-NO-WARNING:       }
 # ET-DYN-NO-WARNING:     ]
 # ET-DYN-NO-WARNING:   }
 # ET-DYN-NO-WARNING: ]

llvm/test/tools/llvm-readobj/ELF/bb-addr-map.test

 # CHECK-NEXT:       {
 # CHECK-NEXT:         ID: 0
 # CHECK-NEXT:         Offset: 0x0
 # CHECK-NEXT:         Size: 0x1
 # CHECK-NEXT:         HasReturn: No
 # CHECK-NEXT:         HasTailCall: Yes
 # CHECK-NEXT:         IsEHPad: No
 # CHECK-NEXT:         CanFallThrough: No
+# CHECK-NEXT:         HasIndirectBranch: No
 # CHECK-NEXT:       }
 # CHECK-NEXT:       {
 # CHECK-NEXT:         ID: 2
 # CHECK-NEXT:         Offset: 0x4
 # CHECK-NEXT:         Size: 0x4
 # CHECK-NEXT:         HasReturn: Yes
 # CHECK-NEXT:         HasTailCall: No
 # CHECK-NEXT:         IsEHPad: Yes
 # CHECK-NEXT:         CanFallThrough: No
+# CHECK-NEXT:         HasIndirectBranch: Yes
 # CHECK-NEXT:       }
 # CHECK-NEXT:     ]
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Function {
 # CHECK-NEXT:     At: 0x22222
 # CHECK-NEXT:     Name: foo
 # CHECK-NEXT:     BB entries [
 # CHECK-NEXT:       {
 # CHECK-NEXT:         ID: 4
 # CHECK-NEXT:         Offset: 0x6
 # CHECK-NEXT:         Size: 0x7
 # CHECK-NEXT:         HasReturn: No
 # CHECK-NEXT:         HasTailCall: No
 # CHECK-NEXT:         IsEHPad: No
 # CHECK-NEXT:         CanFallThrough: Yes
+# CHECK-NEXT:         HasIndirectBranch: No
 # CHECK-NEXT:       }
 # CHECK-NEXT:     ]
 # CHECK-NEXT:   }
 # CHECK-NEXT: ]
 
 # GNU: GNUStyle::printBBAddrMaps not implemented
 
 # TRUNCATED:      BBAddrMap [
 # TRUNCATED-NEXT:   warning: '[[FILE]]': unable to dump SHT_LLVM_BB_ADDR_MAP section with index 3: unable to decode LEB128 at offset [[OFFSET]]: malformed uleb128, extends past end
 # TRUNCATED-NEXT: ]
 ## Check that the other valid section is properly dumped.
 # TRUNCATED-NEXT: BBAddrMap [
 # TRUNCATED-NEXT:   Function {
 # TRUNCATED-NEXT:     At: 0x33333
 # TRUNCATED-NEXT:     Name: bar
 # TRUNCATED-NEXT:     BB entries [
 # TRUNCATED-NEXT:       {
 # TRUNCATED-NEXT:         ID: 6
 # TRUNCATED-NEXT:         Offset: 0x9
 # TRUNCATED-NEXT:         Size: 0xA
 # TRUNCATED-NEXT:         HasReturn: Yes
 # TRUNCATED-NEXT:         HasTailCall: Yes
 # TRUNCATED-NEXT:         IsEHPad: No
 # TRUNCATED-NEXT:         CanFallThrough: Yes
+# TRUNCATED-NEXT:         HasIndirectBranch: Yes
 # TRUNCATED-NEXT:       }
 # TRUNCATED-NEXT:       {
 # TRUNCATED-NEXT:         ID: 7
 # TRUNCATED-NEXT:         Offset: 0x1F
 # TRUNCATED-NEXT:         Size: 0xD
 # TRUNCATED-NEXT:         HasReturn: No
 # TRUNCATED-NEXT:         HasTailCall: Yes
 # TRUNCATED-NEXT:         IsEHPad: Yes
 # TRUNCATED-NEXT:         CanFallThrough: Yes
+# TRUNCATED-NEXT:         HasIndirectBranch: No
 # TRUNCATED-NEXT:       }
 # TRUNCATED-NEXT:     ]
 # TRUNCATED-NEXT:   }
 # TRUNCATED-NEXT: ]
 
 # INVALIDMD:      BBAddrMap [
 # INVALIDMD-NEXT:   warning: '[[FILE]]': unable to dump SHT_LLVM_BB_ADDR_MAP section with index 3: invalid encoding for BBEntry::Metadata: 0xf000002
 
Entries:
         BBEntries:
           - ID:            0
             AddressOffset: 0x0
             Size:          0x1
             Metadata:      [[METADATA=0x2]]
           - ID:            2
             AddressOffset: 0x3
             Size:          0x4
-            Metadata:      0x5
+            Metadata:      0x15
       - Version: 2
         Address: 0x22222
         BBEntries:
           - ID:            4
             AddressOffset: 0x6
             Size:          0x7
             Metadata:      0x8
   - Name: dummy_section
     Type: SHT_PROGBITS
     Size: 16
   - Name: '.llvm_bb_addr_map (1)'
     Type: SHT_LLVM_BB_ADDR_MAP
     Link: .text.bar
     Entries:
       - Version: 2
         Address: 0x33333
         BBEntries:
           - ID:            6
             AddressOffset: 0x9
             Size:          0xa
-            Metadata:      0xb
+            Metadata:      0x1b
           - ID:            7
             AddressOffset: 0xc
             Size:          0xd
             Metadata:      0xe
 Symbols:
   - Name:    foo
     Section: .text
     Type:    STT_FUNC

 # V0-NEXT:       {
 # V0-NEXT:         ID: 0
 # V0-NEXT:         Offset: 0x1
 # V0-NEXT:         Size: 0x2
 # V0-NEXT:         HasReturn:
 # V0-NEXT:         HasTailCall:
 # V0-NEXT:         IsEHPad:
 # V0-NEXT:         CanFallThrough:
+# V0-NEXT:         HasIndirectBranch:
 # V0-NEXT:       }
 # V0-NEXT:       {
 # V0-NEXT:         ID: 1
 # V0-NEXT:         Offset: 0x4
 # V0-NEXT:         Size: 0x5
 # V0-NEXT:         HasReturn:
 # V0-NEXT:         HasTailCall:
 # V0-NEXT:         IsEHPad:
 # V0-NEXT:         CanFallThrough:
+# V0-NEXT:         HasIndirectBranch:
 # V0-NEXT:       }
 # V0-NEXT:     ]
 # V0-NEXT:   }
 
 ## Check version 1 (without BB IDs).
 # RUN: yaml2obj --docnum=2 %s -DVERSION=1 -DSECTION_TYPE=SHT_LLVM_BB_ADDR_MAP -o %t3
 # RUN: llvm-readobj %t3 --bb-addr-map 2>&1 | FileCheck %s --check-prefix=V1
 
 # V1:      BBAddrMap [
 # V1-NEXT:   Function {
 # V1-NEXT:     At:   0x11111
 # V1-NEXT:     Name: foo
 # V1-NEXT:     BB entries [
 # V1-NEXT:       {
 # V1-NEXT:         ID: 0
 # V1-NEXT:         Offset: 0x1
 # V1-NEXT:         Size: 0x2
 # V1-NEXT:         HasReturn:
 # V1-NEXT:         HasTailCall:
 # V1-NEXT:         IsEHPad:
 # V1-NEXT:         CanFallThrough:
+# V1-NEXT:         HasIndirectBranch:
 # V1-NEXT:       }
 # V1-NEXT:       {
 # V1-NEXT:         ID: 1
 # V1-NEXT:         Offset: 0x7
 # V1-NEXT:         Size: 0x5
 # V1-NEXT:         HasReturn:
 # V1-NEXT:         HasTailCall:
 # V1-NEXT:         IsEHPad:
 # V1-NEXT:         CanFallThrough:
+# V1-NEXT:         HasIndirectBranch:
 # V1-NEXT:       }
 # V1-NEXT:     ]
 # V1-NEXT:   }
 
 --- !ELF
 FileHeader:
   Class: ELFCLASS64
   Data:  ELFDATA2LSB

llvm/tools/llvm-readobj/ELFDumper.cpp

for (const BBAddrMap &AM : *BBAddrMapOrErr) {
         DictScope L(W);
         W.printNumber("ID", BBE.ID);
         W.printHex("Offset", BBE.Offset);
         W.printHex("Size", BBE.Size);
         W.printBoolean("HasReturn", BBE.hasReturn());
         W.printBoolean("HasTailCall", BBE.hasTailCall());
         W.printBoolean("IsEHPad", BBE.isEHPad());
         W.printBoolean("CanFallThrough", BBE.canFallThrough());
+        W.printBoolean("HasIndirectBranch", BBE.MD.HasIndirectBranch);
       }
     }
   }
 }
 
 template <class ELFT> void LLVMELFDumper<ELFT>::printAddrsig() {
   ListScope L(W, "Addrsig");
   if (!this->DotAddrsigSec)

llvm/unittests/Object/ELFObjectFileTest.cpp

Sections:
   # Link: 0 (by default, can be overriden)
     Entries:
       - Version: 0
         Address: 0x44444
         BBEntries:
           - ID:            0
             AddressOffset: 0x0
             Size:          0x4
-            Metadata:      0x8
+            Metadata:      0x18
 )");
 
-  BBAddrMap E1 = {0x11111, {{1, 0x0, 0x1, {false, true, false, false}}}};
-  BBAddrMap E2 = {0x22222, {{2, 0x0, 0x2, {false, false, true, false}}}};
-  BBAddrMap E3 = {0x33333, {{0, 0x0, 0x3, {false, true, true, false}}}};
-  BBAddrMap E4 = {0x44444, {{0, 0x0, 0x4, {false, false, false, true}}}};
+  BBAddrMap E1 = {0x11111, {{1, 0x0, 0x1, {false, true, false, false, false}}}};
+  BBAddrMap E2 = {0x22222, {{2, 0x0, 0x2, {false, false, true, false, false}}}};
+  BBAddrMap E3 = {0x33333, {{0, 0x0, 0x3, {false, true, true, false, false}}}};
+  BBAddrMap E4 = {0x44444, {{0, 0x0, 0x4, {false, false, false, true, true}}}};
 
   std::vector<BBAddrMap> Section0BBAddrMaps = {E4};
   std::vector<BBAddrMap> Section1BBAddrMaps = {E3};
   std::vector<BBAddrMap> Section2BBAddrMaps = {E1, E2};
   std::vector<BBAddrMap> AllBBAddrMaps = {E1, E2, E3, E4};
 
   auto DoCheckSucceeds = [&](StringRef YamlString,
                              std::optional<unsigned> TextSectionIndex,

llvm/unittests/Object/ELFTypesTest.cpp

TEST(ELFTypesTest, NoteTest) {
   EXPECT_EQ(Note2.getName(), "");
 
   auto Note3 =
       TestData.getElfNote("AMD", ELF::NT_AMDGPU_METADATA, ArrayRef<uint8_t>());
   EXPECT_EQ(Note3.getDescAsStringRef(4), StringRef(""));
 }
 
 TEST(ELFTypesTest, BBEntryMetadataEncodingTest) {
-  const std::array<BBAddrMap::BBEntry::Metadata, 6> Decoded = {
-      {{false, false, false, false},
-       {true, false, false, false},
-       {false, true, false, false},
-       {false, false, true, false},
-       {false, false, false, true},
-       {true, true, true, true}}};
-  const std::array<uint32_t, 6> Encoded = {{0, 1, 2, 4, 8, 15}};
+  const std::array<BBAddrMap::BBEntry::Metadata, 7> Decoded = {
+      {{false, false, false, false, false},
+       {true, false, false, false, false},
+       {false, true, false, false, false},
+       {false, false, true, false, false},
+       {false, false, false, true, false},
+       {false, false, false, false, true},
+       {true, true, true, true, true}}};
+  const std::array<uint32_t, 7> Encoded = {{0, 1, 2, 4, 8, 16, 31}};
   for (size_t i = 0; i < Decoded.size(); ++i)
     EXPECT_EQ(Decoded[i].encode(), Encoded[i]);
   for (size_t i = 0; i < Encoded.size(); ++i) {
     Expected<BBAddrMap::BBEntry::Metadata> MetadataOrError =
         BBAddrMap::BBEntry::Metadata::decode(Encoded[i]);
     ASSERT_THAT_EXPECTED(MetadataOrError, Succeeded());
     EXPECT_EQ(*MetadataOrError, Decoded[i]);
   }