[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 InternalLinkage
    to avoid adding '.L' prefix.
  - 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
        .p2align        3, 0x0
    __const.foo.jt1:
        .quad   .Ltmp0
        .quad   .Ltmp1
        .size   __const.foo.jt1, 16

        .type   __const.foo.jt2,@object         # @__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 = 0x10 ll
                0000000000000078:  R_BPF_64_64  .jumptables
      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  .jumptables
      23:       0f 12 00 00 00 00 00 00 r2 += r1

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

     3: 0000000000000010    16 OBJECT  LOCAL  DEFAULT     4 __const.foo.jt2
     4: 0000000000000000    16 OBJECT  LOCAL  DEFAULT     4 __const.foo.jt1
     5: 0000000000000000     0 SECTION LOCAL  DEFAULT     4 .jumptables

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 InternalLinkage can preserve the symbol name and
+    // keep the symbol in the symbol table.
+    Global.setLinkage(GlobalValue::InternalLinkage);
+  }
+  return true;
+}
+
 } // end default namespace
 
 INITIALIZE_PASS(BPFMIPreEmitPeephole, "bpf-mi-pemit-peephole",