[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 3. Actually compiler has generated symbols
and jump tables. But unfortunately for previous patch, the symbols
are not visible in symbol table and the section is '.rodata' and
this makes it is hard to inspect binary for jump tables.

For computed goto, to make jump table symbol visible in symbol table,
a pass is added in BPFMIPeephole.cpp such that it will
  - Change linkage from PrivateLinkage to ExternalLinkage
    to avoid adding '.L' prefix and make symbol available for relocation.
  - Change section from '.rodata' to '.jumptables'.

With the above, the following are some asm and objdump codes.
Asm code:
        ...
        r2 <<= 3
        r3 = __const.foo.jt2 ll
        r3 += r2
        r1 <<= 32
        r1 s>>= 32
        r1 <<= 3
        r2 = __const.foo.jt1 ll
        r2 += r1
        w0 = 0
        r1 = *(u64 *)(r2 + 0)
        gotox r1
        goto LBB0_4
        ...
        .type   __const.foo.jt1,@object         # @__const.foo.jt1
        .section        .jumptables,"a",@progbits
        .globl  __const.foo.jt1
        .p2align        3, 0x0
    __const.foo.jt1:
        .quad   .Ltmp0
        .quad   .Ltmp1
        .size   __const.foo.jt1, 16

        .type   __const.foo.jt2,@object         # @__const.foo.jt2
        .globl  __const.foo.jt2
        .p2align        3, 0x0
    __const.foo.jt2:
        .quad   .Ltmp2
        .quad   .Ltmp3
        .size   __const.foo.jt2, 16

objdump code:
      ...
      14:       67 02 00 00 03 00 00 00 r2 <<= 0x3
      15:       18 03 00 00 10 00 00 00 00 00 00 00 00 00 00 00 r3 = 0x0 ll
                0000000000000078:  R_BPF_64_64  __const.foo.jt2
      17:       0f 23 00 00 00 00 00 00 r3 += r2
      18:       67 01 00 00 20 00 00 00 r1 <<= 0x20
      19:       c7 01 00 00 20 00 00 00 r1 s>>= 0x20
      20:       67 01 00 00 03 00 00 00 r1 <<= 0x3
      21:       18 02 00 00 00 00 00 00 00 00 00 00 00 00 00 00 r2 = 0x0 ll
                00000000000000a8:  R_BPF_64_64  __const.foo.jt1
      23:       0f 12 00 00 00 00 00 00 r2 += r1

  [ 4] .jumptables       PROGBITS        0000000000000000 000170 000020 00   A  0   0  8

     4: 0000000000000010    16 OBJECT  GLOBAL DEFAULT     4 __const.foo.jt2
     5: 0000000000000000    16 OBJECT  GLOBAL DEFAULT     4 __const.foo.jt1

Author: Yonghong Song

llvm/lib/Target/BPF/BPFMIPeephole.cpp

@@ -30,6 +30,7 @@
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/MachineInstrBuilder.h"
 #include "llvm/CodeGen/MachineRegisterInfo.h"
+#include "llvm/IR/Module.h"
 #include "llvm/Support/Debug.h"
 #include <set>
 
@@ -308,6 +309,7 @@ struct BPFMIPreEmitPeephole : public MachineFunctionPass {
   const TargetRegisterInfo *TRI;
   const BPFInstrInfo *TII;
   bool SupportGotol;
+  bool DoneConvertPrivGlobal;
 
   BPFMIPreEmitPeephole() : MachineFunctionPass(ID) {}
 
@@ -321,6 +323,7 @@ struct BPFMIPreEmitPeephole : public MachineFunctionPass {
   bool insertMissingCallerSavedSpills();
   bool removeMayGotoZero();
   bool addExitAfterUnreachable();
+  bool convertPrivateGlobal();
 
 public:
 
@@ -338,6 +341,7 @@ struct BPFMIPreEmitPeephole : public MachineFunctionPass {
     Changed |= insertMissingCallerSavedSpills();
     Changed |= removeMayGotoZero();
     Changed |= addExitAfterUnreachable();
+    Changed |= convertPrivateGlobal();
     return Changed;
   }
 };
@@ -348,6 +352,7 @@ void BPFMIPreEmitPeephole::initialize(MachineFunction &MFParm) {
   TII = MF->getSubtarget<BPFSubtarget>().getInstrInfo();
   TRI = MF->getSubtarget<BPFSubtarget>().getRegisterInfo();
   SupportGotol = MF->getSubtarget<BPFSubtarget>().hasGotol();
+  DoneConvertPrivGlobal = false;
   LLVM_DEBUG(dbgs() << "*** BPF PreEmit peephole pass ***\n\n");
 }
 
@@ -750,6 +755,48 @@ bool BPFMIPreEmitPeephole::addExitAfterUnreachable() {
   return true;
 }
 
+bool BPFMIPreEmitPeephole::convertPrivateGlobal() {
+  if (DoneConvertPrivGlobal)
+    return false;
+  DoneConvertPrivGlobal = true;
+
+  // A jump table associated with indirectbr looks like:
+  //   @__const.foo.jt1 = private unnamed_addr constant [2 x ptr]
+  //       [ptr blockaddress(@foo, %l1), ptr blockaddress(@foo, %l2)], align 8
+  Module *M = MF->getFunction().getParent();
+  for (GlobalVariable &Global : M->globals()) {
+    if (Global.getLinkage() != GlobalValue::PrivateLinkage)
+      continue;
+    if (!Global.isConstant())
+      continue;
+    if (!Global.hasInitializer())
+      continue;
+
+    Constant *CV = dyn_cast<Constant>(Global.getInitializer());
+    if (!CV)
+      continue;
+    ConstantArray *CA = dyn_cast<ConstantArray>(CV);
+    if (!CA)
+      continue;
+
+    for (unsigned i = 1, e = CA->getNumOperands(); i != e; ++i) {
+      if (!dyn_cast<BlockAddress>(CA->getOperand(i)))
+        continue;
+    }
+
+    // All jump tables in the same .jumptables section.
+    Global.setSection(".jumptables");
+
+    // The global symbol with PrivateLinkage (e.g. __const.foo.jt1) will add
+    // a prefix like '.L' (e.g. .L__const.foo.jt1) which will prevent symbol
+    // from appearing in the symbol table. Changing linkage type from
+    // PrivateLinkage to ExternalLinkage can preserve the symbol name in the
+    // symbol table and use the symbol name in relocation.
+    Global.setLinkage(GlobalValue::ExternalLinkage);
+  }
+  return true;
+}
+
 } // end default namespace
 
 INITIALIZE_PASS(BPFMIPreEmitPeephole, "bpf-mi-pemit-peephole",