contrib/llvm/lib/Target/ARM/MCTargetDesc/ARMUnwindOpAsm.cpp

   1 //===-- ARMUnwindOpAsm.cpp - ARM Unwind Opcodes Assembler -------*- 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 implements the unwind opcode assmebler for ARM exception handling
  11 // table.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "ARMUnwindOpAsm.h"
  16
  17 #include "ARMUnwindOp.h"
  18 #include "llvm/Support/ErrorHandling.h"
  19 #include "llvm/Support/LEB128.h"
  20
  21 using namespace llvm;
  22
  23 namespace {
  24   /// UnwindOpcodeStreamer - The simple wrapper over SmallVector to emit bytes
  25   /// with MSB to LSB per uint32_t ordering.  For example, the first byte will
  26   /// be placed in Vec[3], and the following bytes will be placed in 2, 1, 0,
  27   /// 7, 6, 5, 4, 11, 10, 9, 8, and so on.
  28   class UnwindOpcodeStreamer {
  29   private:
  30     SmallVectorImpl<uint8_t> &Vec;
  31     size_t Pos;
  32
  33   public:
  34     UnwindOpcodeStreamer(SmallVectorImpl<uint8_t> &V) : Vec(V), Pos(3) {
  35     }
  36
  37     /// Emit the byte in MSB to LSB per uint32_t order.
  38     inline void EmitByte(uint8_t elem) {
  39       Vec[Pos] = elem;
  40       Pos = (((Pos ^ 0x3u) + 1) ^ 0x3u);
  41     }
  42
  43     /// Emit the size prefix.
  44     inline void EmitSize(size_t Size) {
  45       size_t SizeInWords = (Size + 3) / 4;
  46       assert(SizeInWords <= 0x100u &&
  47              "Only 256 additional words are allowed for unwind opcodes");
  48       EmitByte(static_cast<uint8_t>(SizeInWords - 1));
  49     }
  50
  51     /// Emit the personality index prefix.
  52     inline void EmitPersonalityIndex(unsigned PI) {
  53       assert(PI < NUM_PERSONALITY_INDEX && "Invalid personality prefix");
  54       EmitByte(EHT_COMPACT | PI);
  55     }
  56
  57     /// Fill the rest of bytes with FINISH opcode.
  58     inline void FillFinishOpcode() {
  59       while (Pos < Vec.size())
  60         EmitByte(UNWIND_OPCODE_FINISH);
  61     }
  62   };
  63 }
  64
  65 void UnwindOpcodeAssembler::EmitRegSave(uint32_t RegSave) {
  66   if (RegSave == 0u)
  67     return;
  68
  69   // One byte opcode to save register r14 and r11-r4
  70   if (RegSave & (1u << 4)) {
  71     // The one byte opcode will always save r4, thus we can't use the one byte
  72     // opcode when r4 is not in .save directive.
  73
  74     // Compute the consecutive registers from r4 to r11.
  75     uint32_t Range = 0;
  76     uint32_t Mask = (1u << 4);
  77     for (uint32_t Bit = (1u << 5); Bit < (1u << 12); Bit <<= 1) {
  78       if ((RegSave & Bit) == 0u)
  79         break;
  80       ++Range;
  81       Mask |= Bit;
  82     }
  83
  84     // Emit this opcode when the mask covers every registers.
  85     uint32_t UnmaskedReg = RegSave & 0xfff0u & (~Mask);
  86     if (UnmaskedReg == 0u) {
  87       // Pop r[4 : (4 + n)]
  88       EmitInt8(UNWIND_OPCODE_POP_REG_RANGE_R4 | Range);
  89       RegSave &= 0x000fu;
  90     } else if (UnmaskedReg == (1u << 14)) {
  91       // Pop r[14] + r[4 : (4 + n)]
  92       EmitInt8(UNWIND_OPCODE_POP_REG_RANGE_R4_R14 | Range);
  93       RegSave &= 0x000fu;
  94     }
  95   }
  96
  97   // Two bytes opcode to save register r15-r4
  98   if ((RegSave & 0xfff0u) != 0)
  99     EmitInt16(UNWIND_OPCODE_POP_REG_MASK_R4 | (RegSave >> 4));
 100
 101   // Opcode to save register r3-r0
 102   if ((RegSave & 0x000fu) != 0)
 103     EmitInt16(UNWIND_OPCODE_POP_REG_MASK | (RegSave & 0x000fu));
 104 }
 105
 106 /// Emit unwind opcodes for .vsave directives
 107 void UnwindOpcodeAssembler::EmitVFPRegSave(uint32_t VFPRegSave) {
 108   size_t i = 32;
 109
 110   while (i > 16) {
 111     uint32_t Bit = 1u << (i - 1);
 112     if ((VFPRegSave & Bit) == 0u) {
 113       --i;
 114       continue;
 115     }
 116
 117     uint32_t Range = 0;
 118
 119     --i;
 120     Bit >>= 1;
 121
 122     while (i > 16 && (VFPRegSave & Bit)) {
 123       --i;
 124       ++Range;
 125       Bit >>= 1;
 126     }
 127
 128     EmitInt16(UNWIND_OPCODE_POP_VFP_REG_RANGE_FSTMFDD_D16 |
 129               ((i - 16) << 4) | Range);
 130   }
 131
 132   while (i > 0) {
 133     uint32_t Bit = 1u << (i - 1);
 134     if ((VFPRegSave & Bit) == 0u) {
 135       --i;
 136       continue;
 137     }
 138
 139     uint32_t Range = 0;
 140
 141     --i;
 142     Bit >>= 1;
 143
 144     while (i > 0 && (VFPRegSave & Bit)) {
 145       --i;
 146       ++Range;
 147       Bit >>= 1;
 148     }
 149
 150     EmitInt16(UNWIND_OPCODE_POP_VFP_REG_RANGE_FSTMFDD | (i << 4) | Range);
 151   }
 152 }
 153
 154 /// Emit unwind opcodes to copy address from source register to $sp.
 155 void UnwindOpcodeAssembler::EmitSetSP(uint16_t Reg) {
 156   EmitInt8(UNWIND_OPCODE_SET_VSP | Reg);
 157 }
 158
 159 /// Emit unwind opcodes to add $sp with an offset.
 160 void UnwindOpcodeAssembler::EmitSPOffset(int64_t Offset) {
 161   if (Offset > 0x200) {
 162     uint8_t Buff[16];
 163     Buff[0] = UNWIND_OPCODE_INC_VSP_ULEB128;
 164     size_t ULEBSize = encodeULEB128((Offset - 0x204) >> 2, Buff + 1);
 165     EmitBytes(Buff, ULEBSize + 1);
 166   } else if (Offset > 0) {
 167     if (Offset > 0x100) {
 168       EmitInt8(UNWIND_OPCODE_INC_VSP | 0x3fu);
 169       Offset -= 0x100;
 170     }
 171     EmitInt8(UNWIND_OPCODE_INC_VSP | static_cast<uint8_t>((Offset - 4) >> 2));
 172   } else if (Offset < 0) {
 173     while (Offset < -0x100) {
 174       EmitInt8(UNWIND_OPCODE_DEC_VSP | 0x3fu);
 175       Offset += 0x100;
 176     }
 177     EmitInt8(UNWIND_OPCODE_DEC_VSP |
 178              static_cast<uint8_t>(((-Offset) - 4) >> 2));
 179   }
 180 }
 181
 182 void UnwindOpcodeAssembler::Finalize(unsigned &PersonalityIndex,
 183                                      SmallVectorImpl<uint8_t> &Result) {
 184
 185   UnwindOpcodeStreamer OpStreamer(Result);
 186
 187   if (HasPersonality) {
 188     // User-specifed personality routine: [ SIZE , OP1 , OP2 , ... ]
 189     PersonalityIndex = NUM_PERSONALITY_INDEX;
 190     size_t TotalSize = Ops.size() + 1;
 191     size_t RoundUpSize = (TotalSize + 3) / 4 * 4;
 192     Result.resize(RoundUpSize);
 193     OpStreamer.EmitSize(RoundUpSize);
 194   } else {
 195     if (Ops.size() <= 3) {
 196       // __aeabi_unwind_cpp_pr0: [ 0x80 , OP1 , OP2 , OP3 ]
 197       PersonalityIndex = AEABI_UNWIND_CPP_PR0;
 198       Result.resize(4);
 199       OpStreamer.EmitPersonalityIndex(PersonalityIndex);
 200     } else {
 201       // __aeabi_unwind_cpp_pr1: [ 0x81 , SIZE , OP1 , OP2 , ... ]
 202       PersonalityIndex = AEABI_UNWIND_CPP_PR1;
 203       size_t TotalSize = Ops.size() + 2;
 204       size_t RoundUpSize = (TotalSize + 3) / 4 * 4;
 205       Result.resize(RoundUpSize);
 206       OpStreamer.EmitPersonalityIndex(PersonalityIndex);
 207       OpStreamer.EmitSize(RoundUpSize);
 208     }
 209   }
 210
 211   // Copy the unwind opcodes
 212   for (size_t i = OpBegins.size() - 1; i > 0; --i)
 213     for (size_t j = OpBegins[i - 1], end = OpBegins[i]; j < end; ++j)
 214       OpStreamer.EmitByte(Ops[j]);
 215
 216   // Emit the padding finish opcodes if the size is not multiple of 4.
 217   OpStreamer.FillFinishOpcode();
 218
 219   // Reset the assembler state
 220   Reset();
 221 }