[BOLT] Refactor global symbol handling code.

Summary:
This is preparation work for static data reordering.

I've created a new class called BinaryData which represents a symbol
contained in a section.  It records almost all the information relevant
for dealing with data, e.g. names, address, size, alignment, profiling
data, etc.  BinaryContext still stores and manages BinaryData objects
similar to how it managed symbols and global addresses before.  The
interfaces are not changed too drastically from before either.  There is
a bit of overlap between BinaryData and BinaryFunction.  I would have
liked to do some more refactoring to make a BinaryFunctionFragment that
subclassed from BinaryData and then have BinaryFunction be composed or
associated with BinaryFunctionFragments.

I've also attempted to use (symbol + offset) for when addresses are
pointing into the middle of symbols with known sizes.  This changes the
simplify rodata loads optimization slightly since the expression on an
instruction can now also be a (symbol + offset) rather than just a symbol.

One of the overall goals for this refactoring is to make sure every
relocation is associated with a BinaryData object.  This requires adding
"hole" BinaryData's wherever there are gaps in a section's address space.
Most of the holes seem to be data that has no associated symbol info. In
this case we can't do any better than lumping all the adjacent hole
symbols into one big symbol (there may be more than one actual data
object that contributes to a hole). At least the combined holes should
be moveable.

Jump tables have similar issues. They appear to mostly be sub-objects
for top level local symbols. The main problem is that we can't recognize
jump tables at the time we scan the symbol table, we have to wait til
disassembly. When a jump table is discovered we add it as a sub-object
to the existing local symbol. If there are one or more existing
BinaryData's that appear in the address range of a newly created jump
table, those are added as sub-objects as well.

(cherry picked from FBD6362544)

bolt/BinaryBasicBlock.cpp

@@ -78,13 +78,22 @@ bool BinaryBasicBlock::validateSuccessorInvariants() {
         // Work on the assumption that jump table blocks don't
         // have a conditional successor.
         Valid = false;
+        errs() << "BOLT-WARNING: Jump table successor "
+               << Succ->getName()
+               << " not contained in the jump table.\n";
       }
     }
     // If there are any leftover entries in the jump table, they
     // must be one of the function end labels.
-    for (auto *Sym : UniqueSyms) {
-      Valid &= (Sym == Function->getFunctionEndLabel() ||
-                Sym == Function->getFunctionColdEndLabel());
+    if (Valid) {
+      for (auto *Sym : UniqueSyms) {
+        Valid &= (Sym == Function->getFunctionEndLabel() ||
+                  Sym == Function->getFunctionColdEndLabel());
+        if (!Valid) {
+          errs() << "BOLT-WARNING: Jump table contains illegal entry: "
+                 << Sym->getName() << "\n";
+        }
+      }
     }
   } else {
     const MCSymbol *TBB = nullptr;