openpower/isa/fixedload.mdwn

   1 # Load Byte and Zero
   2
   3 D-Form
   4
   5 * lbz RT,D(RA)
   6
   7     if RA = 0 then b <-  0
   8     else           b <-  (RA)
   9     EA <- b + EXTS(D)
  10     RT <- [0]*56 || MEM(EA, 1)
  11
  12 # Load Byte and Zero Indexed
  13
  14 X-Form
  15
  16 * lbzx RT,RA,RB
  17
  18     if RA = 0 then b <- 0
  19     else           b <- (RA)
  20     EA <- b + (RB)
  21     RT <- [0] * 56 || MEM(EA, 1)
  22
  23 # Load Byte and Zero with Update
  24
  25 D-Form
  26
  27 * lbzu RT,D(RA)
  28
  29     EA <- (RA) + EXTS(D)
  30     RT <- [0] * 56 || MEM(EA, 1)
  31     RA <- EA
  32
  33 # Load Byte and Zero with Update Indexed
  34
  35 X-Form
  36
  37 * lbzux RT,RA,RB
  38
  39     EA <- (RA) + (RB)
  40     RT <- [0] * 56 || MEM(EA, 1)
  41     RA <- EA
  42
  43 # Load Halfword and Zero
  44
  45 D-Form
  46
  47 * lhz RT,D(RA)
  48
  49     if RA = 0 then b <-  0
  50     else           b <-  (RA)
  51     EA <- b + EXTS(D)
  52     RT <- [0] * 48 || MEM(EA, 2)
  53
  54 # Load Halfword and Zero Indexed
  55
  56 X-Form
  57
  58 * lhzx RT,RA,RB
  59
  60     if RA = 0 then b <- 0
  61     else           b <- (RA)
  62     EA <- b + (RB)
  63     RT <- [0] * 48 || MEM(EA, 2)
  64
  65 # Load Halfword and Zero with Update
  66
  67 D-Form
  68
  69 * lhzu RT,D(RA)
  70
  71     EA <- (RA) + EXTS(D)
  72     RT <- [0] * 48 || MEM(EA, 2)
  73     RA <- EA
  74
  75 # Load Halfword and Zero with Update Indexed
  76
  77 X-Form
  78
  79 * lhzux RT,RA,RB
  80
  81     EA <- (RA) + (RB)
  82     RT <- [0] * 48 || MEM(EA, 2)
  83     RA <- EA
  84
  85 # Load Halfword Algebraic
  86
  87 D-Form
  88
  89 * lha RT,D(RA)
  90
  91     if RA = 0 then b <-  0
  92     else           b <-  (RA)
  93     EA <- b + EXTS(D)
  94     RT <- EXTS(MEM(EA, 2))
  95
  96 # Load Halfword Algebraic Indexed
  97
  98 X-form
  99
 100 * lhax RT,RA,RB
 101
 102     if RA = 0 then b <- 0
 103     else           b <- (RA)
 104     EA <- b + (RB)
 105     RT <- EXTS(MEM(EA, 2))
 106
 107 # Load Halfword Algebraic with Update
 108
 109 D-Form
 110
 111 * lhau RT,D(RA)
 112
 113     EA <- (RA) + EXTS(D)
 114     RT <- EXTS(MEM(EA, 2))
 115     RA <- EA
 116
 117 # Load Halfword Algebraic with Update Indexed
 118
 119 X-form
 120
 121 * lhaux RT,RA,RB
 122
 123     EA <- (RA) + (RB)
 124     RT <- EXTS(MEM(EA, 2))
 125     RA <- EA
 126
 127 # Load Word and Zero
 128
 129 D-Form
 130
 131 * lwz RT,D(RA)
 132
 133     if RA = 0 then b <-  0
 134     else           b <-  (RA)
 135     EA <- b + EXTS(D)
 136     RT <- [0] * 32 || MEM(EA, 4)
 137
 138 # Load Word and Zero Indexed
 139
 140 X-form
 141
 142 * lwzx RT,RA,RB
 143
 144     if RA = 0 then b <- 0
 145     else           b <- (RA)
 146     EA <- b + (RB)
 147     RT <- [0] * 32 || MEM(EA, 4)
 148
 149 # Load Word and Zero with Update
 150
 151 D-Form
 152
 153 * lwzu RT,D(RA)
 154
 155     EA <- (RA) + EXTS(D)
 156     RT <- [0]*32 || MEM(EA, 4)
 157     RA <- EA
 158
 159 # Load Word and Zero with Update Indexed
 160
 161 X-form
 162
 163 * lwzux RT,RA,RB
 164
 165     EA <- (RA) + (RB)
 166     RT <- [0] * 32 || MEM(EA, 4)
 167     RA <- EA
 168
 169 # Load Word Algebraic
 170
 171 D-Form
 172
 173 * lwa RT,DS(RA)
 174
 175     if RA = 0 then b <-  0
 176     else           b <-  (RA)
 177     EA <- b + EXTS(DS || 0b00)
 178     RT <- EXTS(MEM(EA, 4))
 179
 180 # Load Word Algebraic Indexed
 181
 182 X-form
 183
 184 * lwax RT,RA,RB
 185
 186     if RA = 0 then b <- 0
 187     else           b <- (RA)
 188     EA <- b + (RB)
 189     RT <- EXTS(MEM(EA, 4))
 190
 191 # Load Word Algebraic with Update Indexed
 192
 193 X-form
 194
 195 * lwaux RT,RA,RB
 196
 197     EA <- (RA) + (RB)
 198     RT <- EXTS(MEM(EA, 4))
 199     RA <- EA
 200
 201 # Load Doubleword
 202
 203 DS-Form
 204
 205 * ld RT,DS(RA)
 206
 207     if RA = 0 then b <-  0
 208     else           b <-  (RA)
 209     EA <- b + EXTS(DS || 0b00)
 210     RT <- MEM(EA, 8)
 211
 212 # Load Doubleword Indexed
 213
 214 X-form
 215
 216 * ldx RT,RA,RB
 217
 218     if RA = 0 then b <- 0
 219     else           b <- (RA)
 220     EA <- b + (RB)
 221     RT <- MEM(EA, 8)
 222
 223 # Load Doubleword with Update Indexed
 224
 225 DS-Form
 226
 227 * ldu RT,DS(RA)
 228
 229     EA <- (RA) + EXTS(DS || 0b00)
 230     RT <- MEM(EA, 8)
 231     RA <- EA
 232
 233 # Load Doubleword with Update Indexed
 234
 235 X-form
 236
 237 * ldux RT,RA,RB
 238
 239     EA <- (RA) + (RB)
 240     RT <- MEM(EA, 8)
 241     RA <- EA
 242
 243 # Load Quadword
 244
 245 DQ-Form
 246
 247 * lq RTp,DQ(RA)
 248
 249     if RA = 0 then b <-  0
 250     else           b <-  (RA)
 251     EA <- b + EXTS(DQ || 0b0000)
 252     RTp <- MEM(EA, 16)
 253
 254 # Load Halfword Byte-Reverse Indexed
 255
 256 X-form
 257
 258 * lhbrx RT,RA,RB
 259
 260     if RA = 0 then b <-  0
 261     else           b <-  (RA)
 262     EA <- b + (RB)
 263     load_data <- MEM(EA, 2)
 264     RT <- [0]*48 || load_data[8:15] || load_data[0:7]
 265
 266 # Load Word Byte-Reverse Indexed
 267
 268 X-form
 269
 270 * lwbrx RT,RA,RB
 271
 272     if RA = 0 then b <-  0
 273     else           b <-  (RA)
 274     EA <- b + (RB)
 275     load_data <- MEM(EA, 4)
 276     RT <- [0] * 32 || load_data[24:31] || load_data[16:23]
 277              || load_data[8:15] || load_data[0:7]
 278
 279 # Load Doubleword Byte-Reverse Indexed
 280
 281 X-form
 282
 283 * ldbrx RT,RA,RB
 284
 285     if RA = 0 then b <-  0
 286     else           b <-  (RA)
 287     EA <- b + (RB)
 288     load_data <- MEM(EA, 8)
 289     RT <-  load_data[56:63] || load_data[48:55]
 290     || load_data[40:47 || load_data[32:39]
 291     || load_data[24:31 || load_data[16:23]
 292     || load_data[8:15  || load_data[0:7]
 293
 294 # Load Multiple Word
 295
 296 DQ-Form
 297
 298 * lmw RT,D(RA)
 299
 300     if RA = 0 then b <-  0
 301     else           b <-  (RA)
 302     EA <- b + EXTS(D)
 303     r <- RT
 304     do while r <=  31
 305         GPR(r) <- [0]*32 || MEM(EA, 4)
 306         r <- r + 1
 307         EA <- EA + 4