1    :  // Copyright 2013 Google Inc. All Rights Reserved.
   2    :  //
   3    :  // Licensed under the Apache License, Version 2.0 (the "License");
   4    :  // you may not use this file except in compliance with the License.
   5    :  // You may obtain a copy of the License at
   6    :  //
   7    :  //     http://www.apache.org/licenses/LICENSE-2.0
   8    :  //
   9    :  // Unless required by applicable law or agreed to in writing, software
  10    :  // distributed under the License is distributed on an "AS IS" BASIS,
  11    :  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12    :  // See the License for the specific language governing permissions and
  13    :  // limitations under the License.
  14    :  
  15    :  #include "syzygy/assm/register.h"
  16    :  
  17    :  namespace assm {
  18    :  
  19    :  // A register factory.
  20    :  class RegisterBuilder {
  21    :   public:
  22  E :    static const Register8 Create8(RegisterId id) { return Register8(id); }
  23  E :    static const Register16 Create16(RegisterId id) { return Register16(id); }
  24  E :    static const Register32 Create32(RegisterId id) { return Register32(id); }
  25    :  };
  26    :  
  27    :  // An array of all registers.
  28    :  const Register kRegisters[kRegisterCount] = {
  29    :      // 8-bit registers.
  30  E :      RegisterBuilder::Create8(kRegisterAl),
  31  E :      RegisterBuilder::Create8(kRegisterCl),
  32  E :      RegisterBuilder::Create8(kRegisterDl),
  33  E :      RegisterBuilder::Create8(kRegisterBl),
  34  E :      RegisterBuilder::Create8(kRegisterAh),
  35  E :      RegisterBuilder::Create8(kRegisterCh),
  36  E :      RegisterBuilder::Create8(kRegisterDh),
  37  E :      RegisterBuilder::Create8(kRegisterBh),
  38    :  
  39    :      // 16-bit registers.
  40  E :      RegisterBuilder::Create16(kRegisterAx),
  41  E :      RegisterBuilder::Create16(kRegisterCx),
  42  E :      RegisterBuilder::Create16(kRegisterDx),
  43  E :      RegisterBuilder::Create16(kRegisterBx),
  44  E :      RegisterBuilder::Create16(kRegisterSp),
  45  E :      RegisterBuilder::Create16(kRegisterBp),
  46  E :      RegisterBuilder::Create16(kRegisterSi),
  47  E :      RegisterBuilder::Create16(kRegisterDi),
  48    :  
  49    :      // 32-bit registers.
  50  E :      RegisterBuilder::Create32(kRegisterEax),
  51  E :      RegisterBuilder::Create32(kRegisterEcx),
  52  E :      RegisterBuilder::Create32(kRegisterEdx),
  53  E :      RegisterBuilder::Create32(kRegisterEbx),
  54  E :      RegisterBuilder::Create32(kRegisterEsp),
  55  E :      RegisterBuilder::Create32(kRegisterEbp),
  56  E :      RegisterBuilder::Create32(kRegisterEsi),
  57  E :      RegisterBuilder::Create32(kRegisterEdi)
  58  E :  };
  59    :  
  60    :  // Slices into the array of all registers, by register size.
  61    :  typedef const Register8 (&Register8Array)[kRegister8Count];
  62    :  Register8Array kRegisters8 =
  63    :      reinterpret_cast<Register8Array>(kRegisters[kRegister8Min]);
  64    :  
  65    :  typedef const Register16 (&Register16Array)[kRegister16Count];
  66    :  Register16Array kRegisters16 =
  67    :      reinterpret_cast<Register16Array>(kRegisters[kRegister16Min]);
  68    :  
  69    :  typedef const Register32 (&Register32Array)[kRegister32Count];
  70    :  Register32Array kRegisters32 =
  71    :      reinterpret_cast<Register32Array>(kRegisters[kRegister32Min]);
  72    :  
  73    :  // Convenience constants for each individual register.
  74  E :  const Register8& al = kRegisters8[0];
  75  E :  const Register8& cl = kRegisters8[1];
  76  E :  const Register8& dl = kRegisters8[2];
  77  E :  const Register8& bl = kRegisters8[3];
  78  E :  const Register8& ah = kRegisters8[4];
  79  E :  const Register8& ch = kRegisters8[5];
  80  E :  const Register8& dh = kRegisters8[6];
  81  E :  const Register8& bh = kRegisters8[7];
  82    :  
  83  E :  const Register16& ax = kRegisters16[0];
  84  E :  const Register16& cx = kRegisters16[1];
  85  E :  const Register16& dx = kRegisters16[2];
  86  E :  const Register16& bx = kRegisters16[3];
  87  E :  const Register16& sp = kRegisters16[4];
  88  E :  const Register16& bp = kRegisters16[5];
  89  E :  const Register16& si = kRegisters16[6];
  90  E :  const Register16& di = kRegisters16[7];
  91    :  
  92  E :  const Register32& eax = kRegisters32[0];
  93  E :  const Register32& ecx = kRegisters32[1];
  94  E :  const Register32& edx = kRegisters32[2];
  95  E :  const Register32& ebx = kRegisters32[3];
  96  E :  const Register32& esp = kRegisters32[4];
  97  E :  const Register32& ebp = kRegisters32[5];
  98  E :  const Register32& esi = kRegisters32[6];
  99  E :  const Register32& edi = kRegisters32[7];
 100    :  
 101  E :  const Register& Register::Get(RegisterId id) {
 102  E :    DCHECK_LE(kRegisterMin, id);
 103  E :    DCHECK_GT(kRegisterMax, id);
 104  E :    return kRegisters[id];
 105  E :  }
 106    :  
 107    :  const Register8& CastAsRegister8(const Register& reg) {
 108    :    DCHECK_EQ(kSize8Bit, reg.size());
 109    :    return reinterpret_cast<const Register8&>(reg);
 110    :  }
 111    :  
 112    :  const Register16& CastAsRegister16(const Register& reg) {
 113    :    DCHECK_EQ(kSize16Bit, reg.size());
 114    :    return reinterpret_cast<const Register16&>(reg);
 115    :  }
 116    :  
 117  E :  const Register32& CastAsRegister32(const Register& reg) {
 118  E :    DCHECK_EQ(kSize32Bit, reg.size());
 119  E :    return reinterpret_cast<const Register32&>(reg);
 120  E :  }
 121    :  
 122    :  }  // namespace assm