[BPF] Use visible symbols and dedicated jump tables for computed goto

For computed goto, the llvm won't generate JumpTableInfo. Note that
JumpTableInfo is generated for switch statements.

See previous example 2 and 3. Example 2 does not have jump table.
Example 3 has jump table, but the symbols are not visible in symbol
table. The section is '.rodata' and this makes it hard to inspect
binary for jump tables.

This patch addressed the issue for example 2/3. The final jump table
is similar to the example 1.

For the previous example 2,
    Compile: clang --target=bpf -mcpu=v4 -O2 -S test1.c
    Asm code:
            ...
        # %bb.0:                                # %entry
            r2 = BPF.JT.0.0 ll
            if w1 == 0 goto LBB0_2
        # %bb.1:                                # %entry
            r2 = BPF.JT.0.1 ll
        LBB0_2:                                 # %entry
            *(u64 *)(r10 - 8) = r2
            r1 = *(u64 *)(r10 - 8)
            gotox r1
            ...
            .section        .jumptables,"",@progbits
        BPF.JT.0.0:
            .long   LBB0_4
            .size   BPF.JT.0.0, 4
        BPF.JT.0.1:
            .long   LBB0_3
            .size   BPF.JT.0.1, 4

    The binary: clang --target=bpf -mcpu=v4 -O2 -c test1.c

       0:       18 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 r2 = 0x0 ll
                0000000000000000:  R_BPF_64_64  BPF.JT.0.0
       2:       16 01 02 00 00 00 00 00 if w1 == 0x0 goto +0x2 <bar+0x28>
       3:       18 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 r2 = 0x0 ll
                0000000000000018:  R_BPF_64_64  BPF.JT.0.1
       5:       7b 2a f8 ff 00 00 00 00 *(u64 *)(r10 - 0x8) = r2
       6:       79 a1 f8 ff 00 00 00 00 r1 = *(u64 *)(r10 - 0x8)
       7:       0d 01 00 00 00 00 00 00 gotox r1

        4: 0000000000000000     4 OBJECT  GLOBAL DEFAULT     4 BPF.JT.0.0
        5: 0000000000000004     4 OBJECT  GLOBAL DEFAULT     4 BPF.JT.0.1

      [ 4] .jumptables       PROGBITS        0000000000000000 0000a0 000008 00      0   0  1

For the previous example 3,
    Compile: clang --target=bpf -mcpu=v4 -O2 -S test.c
    Asm code:
            ...
            r3 = (s32)r2
            r3 <<= 3
            r2 = BPF.JT.0.0 ll
            r2 += r3
            r1 = (s32)r1
            r1 <<= 3
            r3 = BPF.JT.0.1 ll
            r3 += r1
            w0 = 0
            r1 = *(u64 *)(r3 + 0)
            gotox r1
        .Ltmp0:                                 # Block address taken
        LBB0_1:                                 # %l1
                                            # =>This Inner Loop Header: Depth=1
            w0 += 1
            ...
            .section        .jumptables,"",@progbits
        BPF.JT.0.0:
            .long   LBB0_3
            .long   LBB0_4
            .size   BPF.JT.0.0, 8
        BPF.JT.0.1:
            .long   LBB0_1
            .long   LBB0_2
            .size   BPF.JT.0.1, 8

    The binary: clang --target=bpf -mcpu=v4 -O2 -c test2.c

          12:       bf 23 20 00 00 00 00 00 r3 = (s32)r2
          13:       67 03 00 00 03 00 00 00 r3 <<= 0x3
          14:       18 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 r2 = 0x0 ll
                    0000000000000070:  R_BPF_64_64  BPF.JT.0.0
          16:       0f 32 00 00 00 00 00 00 r2 += r3
          17:       bf 11 20 00 00 00 00 00 r1 = (s32)r1
          18:       67 01 00 00 03 00 00 00 r1 <<= 0x3
          19:       18 03 00 00 00 00 00 00 00 00 00 00 00 00 00 00 r3 = 0x0 ll
                    0000000000000098:  R_BPF_64_64  BPF.JT.0.1
          21:       0f 13 00 00 00 00 00 00 r3 += r1

         4: 0000000000000000     8 OBJECT  GLOBAL DEFAULT     4 BPF.JT.0.0
         5: 0000000000000008     8 OBJECT  GLOBAL DEFAULT     4 BPF.JT.0.1

      [ 4] .jumptables       PROGBITS        0000000000000000 000160 000010 00      0   0  1

Author: Yonghong Song

llvm/lib/Target/BPF/BPFAsmPrinter.cpp

@@ -145,6 +145,71 @@ MCSymbol *BPFAsmPrinter::getJTPublicSymbol(unsigned JTI) {
   return S;
 }
 
+MCSymbol *BPFAsmPrinter::getJTPublicSymbol(const BlockAddress *BA) {
+  BasicBlock *BB = BA->getBasicBlock();
+
+  MachineBasicBlock *MBB = nullptr;
+  for (MachineBasicBlock &MB : *MF) {
+    if (MB.getBasicBlock() == BB) {
+      MBB = &MB;
+      break;
+    }
+  }
+  assert(MBB);
+
+  std::vector<MachineBasicBlock *> Targets;
+  Targets.push_back(MBB);
+
+  unsigned JTI =
+      MF->getOrCreateJumpTableInfo(MachineJumpTableInfo::EK_LabelDifference32)
+          ->createJumpTableIndex(Targets);
+  return getJTPublicSymbol(JTI);
+}
+
+MCSymbol *BPFAsmPrinter::getJTPublicSymbol(const GlobalValue *GVal) {
+  auto *GV = dyn_cast<GlobalVariable>(GVal);
+  if (!GV)
+    return NULL;
+  if (GV->getLinkage() != GlobalValue::PrivateLinkage)
+    return NULL;
+  if (!GV->isConstant() || !GV->hasInitializer())
+    return NULL;
+
+  const Constant *CV = dyn_cast<Constant>(GV->getInitializer());
+  if (!CV)
+    return NULL;
+  const ConstantArray *CA = dyn_cast<ConstantArray>(CV);
+  if (!CA)
+    return NULL;
+
+  for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i) {
+    if (!dyn_cast<BlockAddress>(CA->getOperand(i)))
+      return NULL;
+  }
+
+  std::vector<MachineBasicBlock *> Targets;
+  for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i) {
+    BlockAddress *BA = dyn_cast<BlockAddress>(CA->getOperand(i));
+    BasicBlock *BB = BA->getBasicBlock();
+
+    MachineBasicBlock *MBB = nullptr;
+    for (MachineBasicBlock &MB : *MF) {
+      if (MB.getBasicBlock() == BB) {
+        MBB = &MB;
+        break;
+      }
+    }
+
+    Targets.push_back(MBB);
+  }
+  assert(Targets.size());
+
+  unsigned JTI =
+      MF->getOrCreateJumpTableInfo(MachineJumpTableInfo::EK_LabelDifference32)
+          ->createJumpTableIndex(Targets);
+  return getJTPublicSymbol(JTI);
+}
+
 void BPFAsmPrinter::emitJumpTableInfo() {
   const MachineJumpTableInfo *MJTI = MF->getJumpTableInfo();
   if (!MJTI)

llvm/lib/Target/BPF/BPFAsmPrinter.h

@@ -30,6 +30,8 @@ class BPFAsmPrinter : public AsmPrinter {
 
   void emitInstruction(const MachineInstr *MI) override;
   MCSymbol *getJTPublicSymbol(unsigned JTI);
+  MCSymbol *getJTPublicSymbol(const BlockAddress *BA);
+  MCSymbol *getJTPublicSymbol(const GlobalValue *GVal);
   virtual void emitJumpTableInfo() override;
 
   static char ID;

llvm/lib/Target/BPF/BPFMCInstLower.cpp

@@ -28,7 +28,11 @@ using namespace llvm;
 
 MCSymbol *
 BPFMCInstLower::GetGlobalAddressSymbol(const MachineOperand &MO) const {
-  return Printer.getSymbol(MO.getGlobal());
+  const GlobalValue *GVal = MO.getGlobal();
+  MCSymbol *Sym = Printer.getJTPublicSymbol(GVal);
+  if (!Sym)
+    Sym = Printer.getSymbol(GVal);
+  return Sym;
 }
 
 MCSymbol *
@@ -85,7 +89,7 @@ void BPFMCInstLower::Lower(const MachineInstr *MI, MCInst &OutMI) const {
       break;
     case MachineOperand::MO_BlockAddress:
       MCOp = LowerSymbolOperand(
-          MO, Printer.GetBlockAddressSymbol(MO.getBlockAddress()));
+          MO, Printer.getJTPublicSymbol(MO.getBlockAddress()));
       break;
     }