hphp/ppc64-asm/isa-ppc64.h

   1 /*
   2    +----------------------------------------------------------------------+
   3    | HipHop for PHP                                                       |
   4    +----------------------------------------------------------------------+
   5    | (c) Copyright IBM Corporation 2015-2016                              |
   6    +----------------------------------------------------------------------+
   7    | This source file is subject to version 3.01 of the PHP license,      |
   8    | that is bundled with this package in the file LICENSE, and is        |
   9    | available through the world-wide-web at the following url:           |
  10    | http://www.php.net/license/3_01.txt                                  |
  11    | If you did not receive a copy of the PHP license and are unable to   |
  12    | obtain it through the world-wide-web, please send a note to          |
  13    | license@php.net so we can mail you a copy immediately.               |
  14    +----------------------------------------------------------------------+
  15 */
  16
  17 #ifndef incl_HPHP_PPC64_ASM_ISA_PPC64_H_
  18 #define incl_HPHP_PPC64_ASM_ISA_PPC64_H_
  19
  20 namespace ppc64_asm {
  21
  22 typedef uint32_t PPC64Instr;
  23
  24 // How many bytes a PPC64 instruction length is.
  25 constexpr uint8_t instr_size_in_bytes       = sizeof(PPC64Instr);
  26
  27 enum class Form {
  28   kInvalid = 0,
  29   kX,
  30   kXO,
  31   kXS,
  32   kD,
  33   kI,
  34   kB,
  35   kSC,
  36   kDS,
  37   kDQ,
  38   kXL,
  39   kXFX,
  40   kXFL,
  41   kXX1,
  42   kXX2,
  43   kXX3,
  44   kXX4,
  45   kA,
  46   kM,
  47   kMD,
  48   kMDS,
  49   kVA,
  50   kVC,
  51   kVX,
  52   kEVX,
  53   kEVS,
  54   kZ22,
  55   kZ23,
  56 };
  57
  58 /**
  59  * Instruction Format encoders
  60  */
  61 typedef union XO_format {
  62   struct {
  63     uint32_t Rc:1;
  64     uint32_t XO:9;
  65     uint32_t OE:1;
  66     uint32_t RB:5;
  67     uint32_t RA:5;
  68     uint32_t RT:5;
  69     uint32_t OP:6;
  70   };
  71   PPC64Instr instruction;
  72 } XO_form_t;
  73 static_assert(sizeof(XO_format) == sizeof(uint32_t), "XO_form_t size != 4");
  74
  75 typedef union X_format {
  76   struct {
  77     uint32_t Rc:1;
  78     uint32_t XO:10;
  79     uint32_t RB:5;
  80     uint32_t RA:5;
  81     uint32_t RT:5;
  82     uint32_t OP:6;
  83   };
  84   PPC64Instr instruction;
  85 } X_form_t;
  86 static_assert(sizeof(X_format) == sizeof(uint32_t), "X_form_t size != 4");
  87
  88 typedef union D_format {
  89   struct {
  90     uint32_t D:16;
  91     uint32_t RA:5;
  92     uint32_t RT:5;
  93     uint32_t OP:6;
  94   };
  95   PPC64Instr instruction;
  96 } D_form_t;
  97 static_assert(sizeof(D_format) == sizeof(uint32_t), "D_form_t size != 4");
  98
  99 typedef union I_format {
 100   struct {
 101     uint32_t LK:1;
 102     uint32_t AA:1;
 103     uint32_t LI:24;
 104     uint32_t OP:6;
 105   };
 106   PPC64Instr instruction;
 107 } I_form_t;
 108 static_assert(sizeof(I_format) == sizeof(uint32_t), "I_form_t size != 4");
 109
 110 typedef union B_format {
 111   struct {
 112     uint32_t LK:1;
 113     uint32_t AA:1;
 114     uint32_t BD:14;
 115     uint32_t BI:5;
 116     uint32_t BO:5;
 117     uint32_t OP:6;
 118   };
 119   PPC64Instr instruction;
 120 } B_form_t;
 121 static_assert(sizeof(B_format) == sizeof(uint32_t), "B_form_t size != 4");
 122
 123 typedef union SC_format {
 124   struct {
 125     uint32_t B31:1;
 126     uint32_t B30:1;
 127     uint32_t LEV:7;
 128     uint32_t RSV3:4;
 129     uint32_t RSV2:5;
 130     uint32_t RSV1:5;
 131     uint32_t OP:6;
 132   };
 133   PPC64Instr instruction;
 134 } SC_form_t;
 135 static_assert(sizeof(SC_format) == sizeof(uint32_t), "SC_form_t size != 4");
 136
 137 typedef union DS_format {
 138   struct {
 139     uint32_t XO:2;
 140     uint32_t DS:14;
 141     uint32_t RA:5;
 142     uint32_t RT:5;
 143     uint32_t OP:6;
 144   };
 145   PPC64Instr instruction;
 146 } DS_form_t;
 147 static_assert(sizeof(DS_format) == sizeof(uint32_t), "DS_form_t size != 4");
 148
 149 typedef union DQ_format {
 150   struct {
 151     uint32_t RSV:4;
 152     uint32_t DQ:12;
 153     uint32_t RA:5;
 154     uint32_t RTp:5;
 155     uint32_t OP:6;
 156   };
 157   PPC64Instr instruction;
 158 } DQ_form_t;
 159 static_assert(sizeof(DQ_format) == sizeof(uint32_t), "DQ_form_t size != 4");
 160
 161 typedef union XL_form {
 162   struct {
 163     uint32_t LK:1;
 164     uint32_t XO:10;
 165     uint32_t BB:5;
 166     uint32_t BA:5;
 167     uint32_t BT:5;
 168     uint32_t OP:6;
 169   };
 170   PPC64Instr instruction;
 171 } XL_form_t;
 172 static_assert(sizeof(XL_form) == sizeof(uint32_t), "XL_form size != 4");
 173
 174 typedef union XFX_format {
 175   struct {
 176     uint32_t RSV:1;
 177     uint32_t XO:10;
 178     uint32_t SPRlo:5;  // see note 1: the order of the two 5-bit halves
 179     uint32_t SPRhi:5;  // of the SPR number is reversed
 180     uint32_t RT:5;
 181     uint32_t OP:6;
 182   };
 183   PPC64Instr instruction;
 184 } XFX_form_t;
 185 static_assert(sizeof(XFX_format) == sizeof(uint32_t), "XFX_form_t size != 4");
 186
 187 typedef union XFL_format {
 188   struct {
 189     uint32_t Rc:1;
 190     uint32_t XO:10;
 191     uint32_t FRB:5;
 192     uint32_t W:1;
 193     uint32_t FLM:8;
 194     uint32_t L:1;
 195     uint32_t OP:6;
 196   };
 197   PPC64Instr instruction;
 198 } XFL_form_t;
 199 static_assert(sizeof(XFL_format) == sizeof(uint32_t), "XFL_form_t size != 4");
 200
 201 typedef union XX1_format {
 202   struct {
 203     uint32_t TX:1;
 204     uint32_t XO:10;
 205     uint32_t RB:5;
 206     uint32_t RA:5;
 207     uint32_t T:5;
 208     uint32_t OP:6;
 209   };
 210   PPC64Instr instruction;
 211 } XX1_form_t;
 212 static_assert(sizeof(XX1_format) == sizeof(uint32_t), "XX1_form_t size != 4");
 213
 214 typedef union XX2_format {
 215   struct {
 216     uint32_t TX:1;
 217     uint32_t BX:1;
 218     uint32_t XO:9;
 219     uint32_t B:5;
 220     uint32_t RSV:5;
 221     uint32_t T:5;
 222     uint32_t OP:6;
 223   };
 224   PPC64Instr instruction;
 225 } XX2_form_t;
 226 static_assert(sizeof(XX2_format) == sizeof(uint32_t), "XX2_form_t size != 4");
 227
 228 typedef union XX3_format {
 229   struct {
 230     uint32_t TX:1;
 231     uint32_t BX:1;
 232     uint32_t AX:1;
 233     uint32_t XO:8;
 234     uint32_t B:5;
 235     uint32_t A:5;
 236     uint32_t T:5;
 237     uint32_t OP:6;
 238   };
 239   PPC64Instr instruction;
 240 } XX3_form_t;
 241 static_assert(sizeof(XX3_format) == sizeof(uint32_t), "XX3_form_t size != 4");
 242
 243 typedef union XX4_format {
 244   struct {
 245     uint32_t TX:1;
 246     uint32_t BX:1;
 247     uint32_t AX:1;
 248     uint32_t CX:1;
 249     uint32_t XO:2;
 250     uint32_t C:5;
 251     uint32_t B:5;
 252     uint32_t A:5;
 253     uint32_t T:5;
 254     uint32_t OP:6;
 255   };
 256   PPC64Instr instruction;
 257 } XX4_form_t;
 258 static_assert(sizeof(XX4_format) == sizeof(uint32_t), "XX4_form_t size != 4");
 259
 260 typedef union XS_format {
 261   struct {
 262     uint32_t Rc:1;
 263     uint32_t sh:1;
 264     uint32_t XO:9;
 265     uint32_t SH:5;
 266     uint32_t RA:5;
 267     uint32_t RS:5;
 268     uint32_t OP:6;
 269   };
 270   PPC64Instr instruction;
 271 } XS_form_t;
 272 static_assert(sizeof(XS_format) == sizeof(uint32_t), "XS_form_t size != 4");
 273
 274 typedef union A_format {
 275   struct {
 276     uint32_t Rc:1;
 277     uint32_t XO:5;
 278     uint32_t FRC:5;
 279     uint32_t FRB:5;
 280     uint32_t FRA:5;
 281     uint32_t FRT:5;
 282     uint32_t OP:6;
 283   };
 284   PPC64Instr instruction;
 285 } A_form_t;
 286 static_assert(sizeof(A_format) == sizeof(uint32_t), "A_form_t size != 4");
 287
 288 typedef union M_format {
 289   struct {
 290     uint32_t Rc:1;
 291     uint32_t ME:5;
 292     uint32_t MB:5;
 293     uint32_t RB:5;
 294     uint32_t RA:5;
 295     uint32_t RS:5;
 296     uint32_t OP:6;
 297   };
 298   PPC64Instr instruction;
 299 } M_form_t;
 300 static_assert(sizeof(M_format) == sizeof(uint32_t), "M_form_t size != 4");
 301
 302 typedef union MD_format {
 303   struct {
 304     uint32_t Rc:1;
 305     uint32_t sh:1;
 306     uint32_t XO:3;
 307     uint32_t MB:6;
 308     uint32_t SH:5;
 309     uint32_t RA:5;
 310     uint32_t RS:5;
 311     uint32_t OP:6;
 312   };
 313   PPC64Instr instruction;
 314 } MD_form_t;
 315 static_assert(sizeof(MD_format) == sizeof(uint32_t), "MD_form_t size != 4");
 316
 317 typedef union MDS_format {
 318   struct {
 319     uint32_t Rc:1;
 320     uint32_t XO:4;
 321     uint32_t MB:6;
 322     uint32_t RB:5;
 323     uint32_t RA:5;
 324     uint32_t RS:5;
 325     uint32_t OP:6;
 326   };
 327   PPC64Instr instruction;
 328 } MDS_form_t;
 329 static_assert(sizeof(MDS_format) == sizeof(uint32_t), "MDS_form_t size != 4");
 330
 331 typedef union VA_format {
 332   struct {
 333     uint32_t XO:6;
 334     uint32_t VRC:5;
 335     uint32_t VRB:5;
 336     uint32_t VRA:5;
 337     uint32_t VRT:5;
 338     uint32_t OP:6;
 339   };
 340   PPC64Instr instruction;
 341 } VA_form_t;
 342 static_assert(sizeof(VA_format) == sizeof(uint32_t), "VA_form_t size != 4");
 343
 344 typedef union VC_format {
 345   struct {
 346     uint32_t XO:10;
 347     uint32_t Rc:1;
 348     uint32_t VRB:5;
 349     uint32_t VRA:5;
 350     uint32_t VRT:5;
 351     uint32_t OP:6;
 352   };
 353   PPC64Instr instruction;
 354 } VC_form_t;
 355 static_assert(sizeof(VC_format) == sizeof(uint32_t), "VC_form_t size != 4");
 356
 357 typedef union VX_format {
 358   struct {
 359     uint32_t XO:11;
 360     uint32_t VRB:5;
 361     uint32_t VRA:5;
 362     uint32_t VRT:5;
 363     uint32_t OP:6;
 364   };
 365   PPC64Instr instruction;
 366 } VX_form_t;
 367 static_assert(sizeof(VX_format) == sizeof(uint32_t), "VX_form_t size != 4");
 368
 369 typedef union EVX_format {
 370   struct {
 371     uint32_t XO:11;
 372     uint32_t RB:5;
 373     uint32_t RA:5;
 374     uint32_t RS:5;
 375     uint32_t OP:6;
 376   };
 377   PPC64Instr instruction;
 378 } EVX_form_t;
 379 static_assert(sizeof(EVX_format) == sizeof(uint32_t), "EVX_form_t size != 4");
 380
 381 typedef union EVS_format {
 382   struct {
 383     uint32_t BFA:3;
 384     uint32_t XO:8;
 385     uint32_t RB:5;
 386     uint32_t RA:5;
 387     uint32_t RS:5;
 388     uint32_t OP:6;
 389   };
 390   PPC64Instr instruction;
 391 } EVS_form_t;
 392 static_assert(sizeof(EVS_format) == sizeof(uint32_t), "EVS_form_t size != 4");
 393
 394 typedef union Z22_format {
 395   struct {
 396     //TODO:
 397     uint32_t OP:6;
 398   };
 399   PPC64Instr instruction;
 400 } Z22_form_t;
 401 static_assert(sizeof(Z22_format) == sizeof(uint32_t), "Z22_form_t size != 4");
 402
 403 typedef union Z23_format {
 404   struct {
 405     //TODO:
 406     uint32_t OP:6;
 407   };
 408   PPC64Instr instruction;
 409 } Z23_form_t;
 410 static_assert(sizeof(Z23_format) == sizeof(uint32_t), "Z23_form_t size != 4");
 411
 412 } // namespace ppc64_asm
 413
 414 #endif