include/llvm/CodeGen/BinaryObject.h

   1 //===-- llvm/CodeGen/BinaryObject.h - Binary Object. -----------*- C++ -*-===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines a Binary Object Aka. "blob" for holding data from code
  11 // generators, ready for data to the object module code writters.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #ifndef LLVM_CODEGEN_BINARYOBJECT_H
  16 #define LLVM_CODEGEN_BINARYOBJECT_H
  17
  18 #include "llvm/Support/DataTypes.h"
  19
  20 #include <string>
  21 #include <vector>
  22
  23 namespace llvm {
  24
  25 class MachineRelocation;
  26 typedef std::vector<uint8_t> BinaryData;
  27
  28 class BinaryObject {
  29 protected:
  30   std::string Name;
  31   bool IsLittleEndian;
  32   bool Is64Bit;
  33   BinaryData Data;
  34   std::vector<MachineRelocation> Relocations;
  35
  36 public:
  37   /// Constructors and destructor
  38   BinaryObject() {}
  39
  40   BinaryObject(bool isLittleEndian, bool is64Bit)
  41     : IsLittleEndian(isLittleEndian), Is64Bit(is64Bit) {}
  42
  43   BinaryObject(const std::string &name, bool isLittleEndian, bool is64Bit)
  44     : Name(name), IsLittleEndian(isLittleEndian), Is64Bit(is64Bit) {}
  45
  46   ~BinaryObject() {}
  47
  48   /// getName - get name of BinaryObject
  49   inline std::string getName() const { return Name; }
  50
  51   /// get size of binary data
  52   size_t size() const {
  53     return Data.size();
  54   }
  55
  56   /// get binary data
  57   BinaryData& getData() {
  58     return Data;
  59   }
  60
  61   /// get machine relocations
  62   const std::vector<MachineRelocation>& getRelocations() const {
  63     return Relocations;
  64   }
  65
  66   /// hasRelocations - Return true if 'Relocations' is not empty
  67   bool hasRelocations() const {
  68     return !Relocations.empty();
  69   }
  70
  71   /// emitZeros - This callback is invoked to emit a arbitrary number
  72   /// of zero bytes to the data stream.
  73   inline void emitZeros(unsigned Size) {
  74     for (unsigned i=0; i < Size; ++i)
  75       emitByte(0);
  76   }
  77
  78   /// emitByte - This callback is invoked when a byte needs to be
  79   /// written to the data stream.
  80   inline void emitByte(uint8_t B) {
  81     Data.push_back(B);
  82   }
  83
  84   /// emitWord16 - This callback is invoked when a 16-bit word needs to be
  85   /// written to the data stream in correct endian format and correct size.
  86   inline void emitWord16(uint16_t W) {
  87     if (IsLittleEndian)
  88       emitWord16LE(W);
  89     else
  90       emitWord16BE(W);
  91   }
  92
  93   /// emitWord16LE - This callback is invoked when a 16-bit word needs to be
  94   /// written to the data stream in correct endian format and correct size.
  95   inline void emitWord16LE(uint16_t W) {
  96     Data.push_back((uint8_t)(W >> 0));
  97     Data.push_back((uint8_t)(W >> 8));
  98   }
  99
 100   /// emitWord16BE - This callback is invoked when a 16-bit word needs to be
 101   /// written to the data stream in correct endian format and correct size.
 102   inline void emitWord16BE(uint16_t W) {
 103     Data.push_back((uint8_t)(W >> 8));
 104     Data.push_back((uint8_t)(W >> 0));
 105   }
 106
 107   /// emitWord - This callback is invoked when a word needs to be
 108   /// written to the data stream in correct endian format and correct size.
 109   inline void emitWord(uint64_t W) {
 110     if (!Is64Bit)
 111       emitWord32(W);
 112     else
 113       emitWord64(W);
 114   }
 115
 116   /// emitWord32 - This callback is invoked when a 32-bit word needs to be
 117   /// written to the data stream in correct endian format.
 118   inline void emitWord32(uint32_t W) {
 119     if (IsLittleEndian)
 120       emitWordLE(W);
 121     else
 122       emitWordBE(W);
 123   }
 124
 125   /// emitWord64 - This callback is invoked when a 32-bit word needs to be
 126   /// written to the data stream in correct endian format.
 127   inline void emitWord64(uint64_t W) {
 128     if (IsLittleEndian)
 129       emitDWordLE(W);
 130     else
 131       emitDWordBE(W);
 132   }
 133
 134   /// emitWord64 - This callback is invoked when a x86_fp80 needs to be
 135   /// written to the data stream in correct endian format.
 136   inline void emitWordFP80(const uint64_t *W, unsigned PadSize) {
 137     if (IsLittleEndian) {
 138       emitWord64(W[0]);
 139       emitWord16(W[1]);
 140     } else {
 141       emitWord16(W[1]);
 142       emitWord64(W[0]);
 143     }
 144     emitZeros(PadSize);
 145   }
 146
 147   /// emitWordLE - This callback is invoked when a 32-bit word needs to be
 148   /// written to the data stream in little-endian format.
 149   inline void emitWordLE(uint32_t W) {
 150     Data.push_back((uint8_t)(W >>  0));
 151     Data.push_back((uint8_t)(W >>  8));
 152     Data.push_back((uint8_t)(W >> 16));
 153     Data.push_back((uint8_t)(W >> 24));
 154   }
 155
 156   /// emitWordBE - This callback is invoked when a 32-bit word needs to be
 157   /// written to the data stream in big-endian format.
 158   ///
 159   inline void emitWordBE(uint32_t W) {
 160     Data.push_back((uint8_t)(W >> 24));
 161     Data.push_back((uint8_t)(W >> 16));
 162     Data.push_back((uint8_t)(W >>  8));
 163     Data.push_back((uint8_t)(W >>  0));
 164   }
 165
 166   /// emitDWordLE - This callback is invoked when a 64-bit word needs to be
 167   /// written to the data stream in little-endian format.
 168   inline void emitDWordLE(uint64_t W) {
 169     Data.push_back((uint8_t)(W >>  0));
 170     Data.push_back((uint8_t)(W >>  8));
 171     Data.push_back((uint8_t)(W >> 16));
 172     Data.push_back((uint8_t)(W >> 24));
 173     Data.push_back((uint8_t)(W >> 32));
 174     Data.push_back((uint8_t)(W >> 40));
 175     Data.push_back((uint8_t)(W >> 48));
 176     Data.push_back((uint8_t)(W >> 56));
 177   }
 178
 179   /// emitDWordBE - This callback is invoked when a 64-bit word needs to be
 180   /// written to the data stream in big-endian format.
 181   inline void emitDWordBE(uint64_t W) {
 182     Data.push_back((uint8_t)(W >> 56));
 183     Data.push_back((uint8_t)(W >> 48));
 184     Data.push_back((uint8_t)(W >> 40));
 185     Data.push_back((uint8_t)(W >> 32));
 186     Data.push_back((uint8_t)(W >> 24));
 187     Data.push_back((uint8_t)(W >> 16));
 188     Data.push_back((uint8_t)(W >>  8));
 189     Data.push_back((uint8_t)(W >>  0));
 190   }
 191
 192   /// fixByte - This callback is invoked when a byte needs to be
 193   /// fixup the buffer.
 194   inline void fixByte(uint8_t B, uint32_t offset) {
 195     Data[offset] = B;
 196   }
 197
 198   /// fixWord16 - This callback is invoked when a 16-bit word needs to
 199   /// fixup the data stream in correct endian format.
 200   inline void fixWord16(uint16_t W, uint32_t offset) {
 201     if (IsLittleEndian)
 202       fixWord16LE(W, offset);
 203     else
 204       fixWord16BE(W, offset);
 205   }
 206
 207   /// emitWord16LE - This callback is invoked when a 16-bit word needs to
 208   /// fixup the data stream in little endian format.
 209   inline void fixWord16LE(uint16_t W, uint32_t offset) {
 210     Data[offset]   = (uint8_t)(W >> 0);
 211     Data[++offset] = (uint8_t)(W >> 8);
 212   }
 213
 214   /// fixWord16BE - This callback is invoked when a 16-bit word needs to
 215   /// fixup data stream in big endian format.
 216   inline void fixWord16BE(uint16_t W, uint32_t offset) {
 217     Data[offset]   = (uint8_t)(W >> 8);
 218     Data[++offset] = (uint8_t)(W >> 0);
 219   }
 220
 221   /// emitWord - This callback is invoked when a word needs to
 222   /// fixup the data in correct endian format and correct size.
 223   inline void fixWord(uint64_t W, uint32_t offset) {
 224     if (!Is64Bit)
 225       fixWord32(W, offset);
 226     else
 227       fixWord64(W, offset);
 228   }
 229
 230   /// fixWord32 - This callback is invoked when a 32-bit word needs to
 231   /// fixup the data in correct endian format.
 232   inline void fixWord32(uint32_t W, uint32_t offset) {
 233     if (IsLittleEndian)
 234       fixWord32LE(W, offset);
 235     else
 236       fixWord32BE(W, offset);
 237   }
 238
 239   /// fixWord32LE - This callback is invoked when a 32-bit word needs to
 240   /// fixup the data in little endian format.
 241   inline void fixWord32LE(uint32_t W, uint32_t offset) {
 242     Data[offset]   = (uint8_t)(W >>  0);
 243     Data[++offset] = (uint8_t)(W >>  8);
 244     Data[++offset] = (uint8_t)(W >> 16);
 245     Data[++offset] = (uint8_t)(W >> 24);
 246   }
 247
 248   /// fixWord32BE - This callback is invoked when a 32-bit word needs to
 249   /// fixup the data in big endian format.
 250   inline void fixWord32BE(uint32_t W, uint32_t offset) {
 251     Data[offset]   = (uint8_t)(W >> 24);
 252     Data[++offset] = (uint8_t)(W >> 16);
 253     Data[++offset] = (uint8_t)(W >>  8);
 254     Data[++offset] = (uint8_t)(W >>  0);
 255   }
 256
 257   /// fixWord64 - This callback is invoked when a 64-bit word needs to
 258   /// fixup the data in correct endian format.
 259   inline void fixWord64(uint64_t W, uint32_t offset) {
 260     if (IsLittleEndian)
 261       fixWord64LE(W, offset);
 262     else
 263       fixWord64BE(W, offset);
 264   }
 265
 266   /// fixWord64BE - This callback is invoked when a 64-bit word needs to
 267   /// fixup the data in little endian format.
 268   inline void fixWord64LE(uint64_t W, uint32_t offset) {
 269     Data[offset]   = (uint8_t)(W >>  0);
 270     Data[++offset] = (uint8_t)(W >>  8);
 271     Data[++offset] = (uint8_t)(W >> 16);
 272     Data[++offset] = (uint8_t)(W >> 24);
 273     Data[++offset] = (uint8_t)(W >> 32);
 274     Data[++offset] = (uint8_t)(W >> 40);
 275     Data[++offset] = (uint8_t)(W >> 48);
 276     Data[++offset] = (uint8_t)(W >> 56);
 277   }
 278
 279   /// fixWord64BE - This callback is invoked when a 64-bit word needs to
 280   /// fixup the data in big endian format.
 281   inline void fixWord64BE(uint64_t W, uint32_t offset) {
 282     Data[offset]   = (uint8_t)(W >> 56);
 283     Data[++offset] = (uint8_t)(W >> 48);
 284     Data[++offset] = (uint8_t)(W >> 40);
 285     Data[++offset] = (uint8_t)(W >> 32);
 286     Data[++offset] = (uint8_t)(W >> 24);
 287     Data[++offset] = (uint8_t)(W >> 16);
 288     Data[++offset] = (uint8_t)(W >>  8);
 289     Data[++offset] = (uint8_t)(W >>  0);
 290   }
 291
 292   /// emitAlignment - Pad the data to the specified alignment.
 293   void emitAlignment(unsigned Alignment, uint8_t fill = 0) {
 294     if (Alignment <= 1) return;
 295     unsigned PadSize = -Data.size() & (Alignment-1);
 296     for (unsigned i = 0; i<PadSize; ++i)
 297       Data.push_back(fill);
 298   }
 299
 300   /// emitULEB128Bytes - This callback is invoked when a ULEB128 needs to be
 301   /// written to the data stream.
 302   void emitULEB128Bytes(uint64_t Value) {
 303     do {
 304       uint8_t Byte = (uint8_t)(Value & 0x7f);
 305       Value >>= 7;
 306       if (Value) Byte |= 0x80;
 307       emitByte(Byte);
 308     } while (Value);
 309   }
 310
 311   /// emitSLEB128Bytes - This callback is invoked when a SLEB128 needs to be
 312   /// written to the data stream.
 313   void emitSLEB128Bytes(int64_t Value) {
 314     int Sign = Value >> (8 * sizeof(Value) - 1);
 315     bool IsMore;
 316
 317     do {
 318       uint8_t Byte = (uint8_t)(Value & 0x7f);
 319       Value >>= 7;
 320       IsMore = Value != Sign || ((Byte ^ Sign) & 0x40) != 0;
 321       if (IsMore) Byte |= 0x80;
 322       emitByte(Byte);
 323     } while (IsMore);
 324   }
 325
 326   /// emitString - This callback is invoked when a String needs to be
 327   /// written to the data stream.
 328   void emitString(const std::string &String) {
 329     for (unsigned i = 0, N = static_cast<unsigned>(String.size()); i<N; ++i) {
 330       unsigned char C = String[i];
 331       emitByte(C);
 332     }
 333     emitByte(0);
 334   }
 335
 336   /// getCurrentPCOffset - Return the offset from the start of the emitted
 337   /// buffer that we are currently writing to.
 338   uintptr_t getCurrentPCOffset() const {
 339     return Data.size();
 340   }
 341
 342   /// addRelocation - Whenever a relocatable address is needed, it should be
 343   /// noted with this interface.
 344   void addRelocation(const MachineRelocation& relocation) {
 345     Relocations.push_back(relocation);
 346   }
 347
 348 };
 349
 350 } // end namespace llvm
 351
 352 #endif
 353