basis/cpu/architecture/architecture.factor

   1 ! Copyright (C) 2006, 2010 Slava Pestov.
   2 ! See https://factorcode.org/license.txt for BSD license.
   3 USING: accessors arrays assocs generic kernel kernel.private
   4 math math.order memory namespaces make sequences layouts system
   5 hashtables classes alien byte-arrays combinators words sets fry
   6 ;
   7 IN: cpu.architecture
   8
   9 ! Representations -- these are like low-level types
  10
  11 ! Unknown representation; this is used for ##copy instructions which
  12 ! get eliminated later
  13 SINGLETON: any-rep
  14
  15 ! Integer registers can contain data with one of these three representations
  16 ! tagged-rep: tagged pointer or fixnum
  17 ! int-rep: untagged fixnum, not a pointer
  18 SINGLETONS: tagged-rep int-rep ;
  19
  20 ! Floating point registers can contain data with
  21 ! one of these representations
  22 SINGLETONS: float-rep double-rep ;
  23
  24 ! On x86, floating point registers are really vector registers
  25 SINGLETONS:
  26     char-16-rep
  27     uchar-16-rep
  28     short-8-rep
  29     ushort-8-rep
  30     int-4-rep
  31     uint-4-rep
  32     longlong-2-rep
  33     ulonglong-2-rep ;
  34
  35 ! Scalar values in the high component of a vector register
  36 SINGLETONS:
  37     char-scalar-rep
  38     uchar-scalar-rep
  39     short-scalar-rep
  40     ushort-scalar-rep
  41     int-scalar-rep
  42     uint-scalar-rep
  43     longlong-scalar-rep
  44     ulonglong-scalar-rep ;
  45
  46 SINGLETONS:
  47     float-4-rep
  48     double-2-rep ;
  49
  50 UNION: int-vector-rep
  51     char-16-rep
  52     uchar-16-rep
  53     short-8-rep
  54     ushort-8-rep
  55     int-4-rep
  56     uint-4-rep
  57     longlong-2-rep
  58     ulonglong-2-rep ;
  59
  60 UNION: signed-int-vector-rep
  61     char-16-rep
  62     short-8-rep
  63     int-4-rep
  64     longlong-2-rep ;
  65
  66 UNION: unsigned-int-vector-rep
  67     uchar-16-rep
  68     ushort-8-rep
  69     uint-4-rep
  70     ulonglong-2-rep ;
  71
  72 UNION: scalar-rep
  73     char-scalar-rep
  74     uchar-scalar-rep
  75     short-scalar-rep
  76     ushort-scalar-rep
  77     int-scalar-rep
  78     uint-scalar-rep
  79     longlong-scalar-rep
  80     ulonglong-scalar-rep ;
  81
  82 UNION: float-vector-rep
  83     float-4-rep
  84     double-2-rep ;
  85
  86 UNION: vector-rep
  87     int-vector-rep
  88     float-vector-rep ;
  89
  90 CONSTANT: vector-reps
  91     {
  92         char-16-rep
  93         uchar-16-rep
  94         short-8-rep
  95         ushort-8-rep
  96         int-4-rep
  97         uint-4-rep
  98         longlong-2-rep
  99         ulonglong-2-rep
 100         float-4-rep
 101         double-2-rep
 102     }
 103
 104 UNION: representation
 105     any-rep
 106     tagged-rep
 107     int-rep
 108     float-rep
 109     double-rep
 110     vector-rep
 111     scalar-rep ;
 112
 113 : signed-rep ( rep -- rep' )
 114     {
 115         { uint-4-rep           int-4-rep }
 116         { ulonglong-2-rep      longlong-2-rep }
 117         { ushort-8-rep         short-8-rep }
 118         { uchar-16-rep         char-16-rep }
 119         { uchar-scalar-rep     char-scalar-rep }
 120         { ushort-scalar-rep    short-scalar-rep }
 121         { uint-scalar-rep      int-scalar-rep }
 122         { ulonglong-scalar-rep longlong-scalar-rep }
 123     } ?at drop ; foldable
 124
 125 : widen-vector-rep ( rep -- rep' )
 126     {
 127         { char-16-rep     short-8-rep     }
 128         { short-8-rep     int-4-rep       }
 129         { int-4-rep       longlong-2-rep  }
 130         { uchar-16-rep    ushort-8-rep    }
 131         { ushort-8-rep    uint-4-rep      }
 132         { uint-4-rep      ulonglong-2-rep }
 133         { float-4-rep     double-2-rep    }
 134     } at ; foldable
 135
 136 : narrow-vector-rep ( rep -- rep' )
 137     {
 138         { short-8-rep     char-16-rep     }
 139         { int-4-rep       short-8-rep     }
 140         { longlong-2-rep  int-4-rep       }
 141         { ushort-8-rep    uchar-16-rep    }
 142         { uint-4-rep      ushort-8-rep    }
 143         { ulonglong-2-rep uint-4-rep      }
 144         { double-2-rep    float-4-rep     }
 145     } at ; foldable
 146
 147 ! Register classes
 148 SINGLETONS: int-regs float-regs ;
 149
 150 UNION: reg-class int-regs float-regs ;
 151 CONSTANT: reg-classes { int-regs float-regs }
 152
 153 GENERIC: reg-class-of ( rep -- reg-class )
 154
 155 M: tagged-rep reg-class-of drop int-regs ;
 156 M: int-rep reg-class-of drop int-regs ;
 157 M: float-rep reg-class-of drop float-regs ;
 158 M: double-rep reg-class-of drop float-regs ;
 159
 160 ! Note that on PowerPC, vectors and floats are stored in different
 161 ! register banks. But Factor doesn't support SIMD on that platform.
 162 M: vector-rep reg-class-of drop float-regs ;
 163 M: scalar-rep reg-class-of drop float-regs ;
 164
 165 GENERIC: rep-size ( rep -- n ) foldable
 166
 167 M: tagged-rep rep-size drop cell ;
 168 M: int-rep rep-size drop cell ;
 169 M: float-rep rep-size drop 4 ;
 170 M: double-rep rep-size drop 8 ;
 171 M: vector-rep rep-size drop 16 ;
 172 M: char-scalar-rep rep-size drop 1 ;
 173 M: uchar-scalar-rep rep-size drop 1 ;
 174 M: short-scalar-rep rep-size drop 2 ;
 175 M: ushort-scalar-rep rep-size drop 2 ;
 176 M: int-scalar-rep rep-size drop 4 ;
 177 M: uint-scalar-rep rep-size drop 4 ;
 178 M: longlong-scalar-rep rep-size drop 8 ;
 179 M: ulonglong-scalar-rep rep-size drop 8 ;
 180
 181 GENERIC: rep-length ( rep -- n ) foldable
 182
 183 M: char-16-rep rep-length drop 16 ;
 184 M: uchar-16-rep rep-length drop 16 ;
 185 M: short-8-rep rep-length drop 8 ;
 186 M: ushort-8-rep rep-length drop 8 ;
 187 M: int-4-rep rep-length drop 4 ;
 188 M: uint-4-rep rep-length drop 4 ;
 189 M: longlong-2-rep rep-length drop 2 ;
 190 M: ulonglong-2-rep rep-length drop 2 ;
 191 M: float-4-rep rep-length drop 4 ;
 192 M: double-2-rep rep-length drop 2 ;
 193
 194 GENERIC: rep-component-type ( rep -- n )
 195
 196 ! Methods defined in alien.c-types
 197
 198 GENERIC: scalar-rep-of ( rep -- rep' )
 199
 200 M: float-4-rep scalar-rep-of drop float-rep ;
 201 M: double-2-rep scalar-rep-of drop double-rep ;
 202 M: char-16-rep scalar-rep-of drop char-scalar-rep ;
 203 M: uchar-16-rep scalar-rep-of drop uchar-scalar-rep ;
 204 M: short-8-rep scalar-rep-of drop short-scalar-rep ;
 205 M: ushort-8-rep scalar-rep-of drop ushort-scalar-rep ;
 206 M: int-4-rep scalar-rep-of drop int-scalar-rep ;
 207 M: uint-4-rep scalar-rep-of drop uint-scalar-rep ;
 208 M: longlong-2-rep scalar-rep-of drop longlong-scalar-rep ;
 209 M: ulonglong-2-rep scalar-rep-of drop ulonglong-scalar-rep ;
 210
 211 HOOK: machine-registers cpu ( -- assoc )
 212
 213 ! Callbacks are not allowed to clobber this
 214 HOOK: frame-reg cpu ( -- reg )
 215
 216 HOOK: vm-stack-space cpu ( -- n )
 217
 218 M: object vm-stack-space 0 ;
 219
 220 HOOK: complex-addressing? cpu ( -- ? )
 221
 222 HOOK: gc-root-offset cpu ( spill-slot -- n )
 223
 224 HOOK: %load-immediate cpu ( reg val -- )
 225 HOOK: %load-reference cpu ( reg obj -- )
 226 HOOK: %load-float cpu ( reg val -- )
 227 HOOK: %load-double cpu ( reg val -- )
 228 HOOK: %load-vector cpu ( reg val rep -- )
 229
 230 HOOK: %peek cpu ( vreg loc -- )
 231 HOOK: %replace cpu ( vreg loc -- )
 232 HOOK: %replace-imm cpu ( src loc -- )
 233 HOOK: %clear cpu ( loc -- )
 234 HOOK: %inc cpu ( loc -- )
 235
 236 HOOK: stack-frame-size cpu ( stack-frame -- n )
 237 HOOK: %call cpu ( word -- )
 238 HOOK: %jump cpu ( word -- )
 239 HOOK: %jump-label cpu ( label -- )
 240 HOOK: %return cpu ( -- )
 241
 242 HOOK: %dispatch cpu ( src temp -- )
 243
 244 HOOK: %slot cpu ( dst obj slot scale tag -- )
 245 HOOK: %slot-imm cpu ( dst obj slot tag -- )
 246 HOOK: %set-slot cpu ( src obj slot scale tag -- )
 247 HOOK: %set-slot-imm cpu ( src obj slot tag -- )
 248
 249 HOOK: %add     cpu ( dst src1 src2 -- )
 250 HOOK: %add-imm cpu ( dst src1 src2 -- )
 251 HOOK: %sub     cpu ( dst src1 src2 -- )
 252 HOOK: %sub-imm cpu ( dst src1 src2 -- )
 253 HOOK: %mul     cpu ( dst src1 src2 -- )
 254 HOOK: %mul-imm cpu ( dst src1 src2 -- )
 255 HOOK: %and     cpu ( dst src1 src2 -- )
 256 HOOK: %and-imm cpu ( dst src1 src2 -- )
 257 HOOK: %or      cpu ( dst src1 src2 -- )
 258 HOOK: %or-imm  cpu ( dst src1 src2 -- )
 259 HOOK: %xor     cpu ( dst src1 src2 -- )
 260 HOOK: %xor-imm cpu ( dst src1 src2 -- )
 261 HOOK: %shl     cpu ( dst src1 src2 -- )
 262 HOOK: %shl-imm cpu ( dst src1 src2 -- )
 263 HOOK: %shr     cpu ( dst src1 src2 -- )
 264 HOOK: %shr-imm cpu ( dst src1 src2 -- )
 265 HOOK: %sar     cpu ( dst src1 src2 -- )
 266 HOOK: %sar-imm cpu ( dst src1 src2 -- )
 267 HOOK: %min     cpu ( dst src1 src2 -- )
 268 HOOK: %max     cpu ( dst src1 src2 -- )
 269 HOOK: %not     cpu ( dst src -- )
 270 HOOK: %neg     cpu ( dst src -- )
 271 HOOK: %log2    cpu ( dst src -- )
 272 HOOK: %bit-count cpu ( dst src -- )
 273 HOOK: %bit-test cpu ( dst src1 src2 temp -- )
 274
 275 HOOK: %copy cpu ( dst src rep -- )
 276
 277 : %tagged>integer ( dst src -- ) int-rep %copy ;
 278
 279 HOOK: %fixnum-add cpu ( label dst src1 src2 cc -- )
 280 HOOK: %fixnum-sub cpu ( label dst src1 src2 cc -- )
 281 HOOK: %fixnum-mul cpu ( label dst src1 src2 cc -- )
 282
 283 HOOK: %add-float cpu ( dst src1 src2 -- )
 284 HOOK: %sub-float cpu ( dst src1 src2 -- )
 285 HOOK: %mul-float cpu ( dst src1 src2 -- )
 286 HOOK: %div-float cpu ( dst src1 src2 -- )
 287 HOOK: %min-float cpu ( dst src1 src2 -- )
 288 HOOK: %max-float cpu ( dst src1 src2 -- )
 289 HOOK: %sqrt cpu ( dst src -- )
 290
 291 HOOK: %single>double-float cpu ( dst src -- )
 292 HOOK: %double>single-float cpu ( dst src -- )
 293
 294 HOOK: integer-float-needs-stack-frame? cpu ( -- ? )
 295
 296 HOOK: %integer>float cpu ( dst src -- )
 297 HOOK: %float>integer cpu ( dst src -- )
 298
 299 HOOK: %zero-vector cpu ( dst rep -- )
 300 HOOK: %fill-vector cpu ( dst rep -- )
 301 HOOK: %gather-vector-2 cpu ( dst src1 src2 rep -- )
 302 HOOK: %gather-int-vector-2 cpu ( dst src1 src2 rep -- )
 303 HOOK: %gather-vector-4 cpu ( dst src1 src2 src3 src4 rep -- )
 304 HOOK: %gather-int-vector-4 cpu ( dst src1 src2 src3 src4 rep -- )
 305 HOOK: %select-vector cpu ( dst src n rep -- )
 306 HOOK: %shuffle-vector cpu ( dst src shuffle rep -- )
 307 HOOK: %shuffle-vector-imm cpu ( dst src shuffle rep -- )
 308 HOOK: %shuffle-vector-halves-imm cpu ( dst src1 src2 shuffle rep -- )
 309 HOOK: %tail>head-vector cpu ( dst src rep -- )
 310 HOOK: %merge-vector-head cpu ( dst src1 src2 rep -- )
 311 HOOK: %merge-vector-tail cpu ( dst src1 src2 rep -- )
 312 HOOK: %float-pack-vector cpu ( dst src rep -- )
 313 HOOK: %signed-pack-vector cpu ( dst src1 src2 rep -- )
 314 HOOK: %unsigned-pack-vector cpu ( dst src1 src2 rep -- )
 315 HOOK: %unpack-vector-head cpu ( dst src rep -- )
 316 HOOK: %unpack-vector-tail cpu ( dst src rep -- )
 317 HOOK: %integer>float-vector cpu ( dst src rep -- )
 318 HOOK: %float>integer-vector cpu ( dst src rep -- )
 319 HOOK: %compare-vector cpu ( dst src1 src2 rep cc -- )
 320 HOOK: %move-vector-mask cpu ( dst src rep -- )
 321 HOOK: %test-vector cpu ( dst src1 temp rep vcc -- )
 322 HOOK: %test-vector-branch cpu ( label src1 temp rep vcc -- )
 323 HOOK: %add-vector cpu ( dst src1 src2 rep -- )
 324 HOOK: %saturated-add-vector cpu ( dst src1 src2 rep -- )
 325 HOOK: %add-sub-vector cpu ( dst src1 src2 rep -- )
 326 HOOK: %sub-vector cpu ( dst src1 src2 rep -- )
 327 HOOK: %saturated-sub-vector cpu ( dst src1 src2 rep -- )
 328 HOOK: %mul-vector cpu ( dst src1 src2 rep -- )
 329 HOOK: %mul-high-vector cpu ( dst src1 src2 rep -- )
 330 HOOK: %mul-horizontal-add-vector cpu ( dst src1 src2 rep -- )
 331 HOOK: %saturated-mul-vector cpu ( dst src1 src2 rep -- )
 332 HOOK: %div-vector cpu ( dst src1 src2 rep -- )
 333 HOOK: %min-vector cpu ( dst src1 src2 rep -- )
 334 HOOK: %max-vector cpu ( dst src1 src2 rep -- )
 335 HOOK: %avg-vector cpu ( dst src1 src2 rep -- )
 336 HOOK: %dot-vector cpu ( dst src1 src2 rep -- )
 337 HOOK: %sad-vector cpu ( dst src1 src2 rep -- )
 338 HOOK: %sqrt-vector cpu ( dst src rep -- )
 339 HOOK: %horizontal-add-vector cpu ( dst src1 src2 rep -- )
 340 HOOK: %horizontal-sub-vector cpu ( dst src1 src2 rep -- )
 341 HOOK: %abs-vector cpu ( dst src rep -- )
 342 HOOK: %and-vector cpu ( dst src1 src2 rep -- )
 343 HOOK: %andn-vector cpu ( dst src1 src2 rep -- )
 344 HOOK: %or-vector cpu ( dst src1 src2 rep -- )
 345 HOOK: %xor-vector cpu ( dst src1 src2 rep -- )
 346 HOOK: %not-vector cpu ( dst src rep -- )
 347 HOOK: %shl-vector cpu ( dst src1 src2 rep -- )
 348 HOOK: %shr-vector cpu ( dst src1 src2 rep -- )
 349 HOOK: %shl-vector-imm cpu ( dst src1 src2 rep -- )
 350 HOOK: %shr-vector-imm cpu ( dst src1 src2 rep -- )
 351 HOOK: %horizontal-shl-vector-imm cpu ( dst src1 src2 rep -- )
 352 HOOK: %horizontal-shr-vector-imm cpu ( dst src1 src2 rep -- )
 353
 354 HOOK: %integer>scalar cpu ( dst src rep -- )
 355 HOOK: %scalar>integer cpu ( dst src rep -- )
 356 HOOK: %vector>scalar cpu ( dst src rep -- )
 357 HOOK: %scalar>vector cpu ( dst src rep -- )
 358
 359 HOOK: %zero-vector-reps cpu ( -- reps )
 360 HOOK: %fill-vector-reps cpu ( -- reps )
 361 HOOK: %gather-vector-2-reps cpu ( -- reps )
 362 HOOK: %gather-int-vector-2-reps cpu ( -- reps )
 363 HOOK: %gather-vector-4-reps cpu ( -- reps )
 364 HOOK: %gather-int-vector-4-reps cpu ( -- reps )
 365 HOOK: %select-vector-reps cpu ( -- reps )
 366 HOOK: %alien-vector-reps cpu ( -- reps )
 367 HOOK: %shuffle-vector-reps cpu ( -- reps )
 368 HOOK: %shuffle-vector-imm-reps cpu ( -- reps )
 369 HOOK: %shuffle-vector-halves-imm-reps cpu ( -- reps )
 370 HOOK: %merge-vector-reps cpu ( -- reps )
 371 HOOK: %float-pack-vector-reps cpu ( -- reps )
 372 HOOK: %signed-pack-vector-reps cpu ( -- reps )
 373 HOOK: %unsigned-pack-vector-reps cpu ( -- reps )
 374 HOOK: %unpack-vector-head-reps cpu ( -- reps )
 375 HOOK: %unpack-vector-tail-reps cpu ( -- reps )
 376 HOOK: %integer>float-vector-reps cpu ( -- reps )
 377 HOOK: %float>integer-vector-reps cpu ( -- reps )
 378 HOOK: %compare-vector-reps cpu ( cc -- reps )
 379 HOOK: %compare-vector-ccs cpu ( rep cc -- {cc,swap?}s not? )
 380 HOOK: %move-vector-mask-reps cpu ( -- reps )
 381 HOOK: %test-vector-reps cpu ( -- reps )
 382 HOOK: %add-vector-reps cpu ( -- reps )
 383 HOOK: %saturated-add-vector-reps cpu ( -- reps )
 384 HOOK: %add-sub-vector-reps cpu ( -- reps )
 385 HOOK: %sub-vector-reps cpu ( -- reps )
 386 HOOK: %saturated-sub-vector-reps cpu ( -- reps )
 387 HOOK: %mul-vector-reps cpu ( -- reps )
 388 HOOK: %mul-high-vector-reps cpu ( -- reps )
 389 HOOK: %mul-horizontal-add-vector-reps cpu ( -- reps )
 390 HOOK: %saturated-mul-vector-reps cpu ( -- reps )
 391 HOOK: %div-vector-reps cpu ( -- reps )
 392 HOOK: %min-vector-reps cpu ( -- reps )
 393 HOOK: %max-vector-reps cpu ( -- reps )
 394 HOOK: %avg-vector-reps cpu ( -- reps )
 395 HOOK: %dot-vector-reps cpu ( -- reps )
 396 HOOK: %sad-vector-reps cpu ( -- reps )
 397 HOOK: %sqrt-vector-reps cpu ( -- reps )
 398 HOOK: %horizontal-add-vector-reps cpu ( -- reps )
 399 HOOK: %horizontal-sub-vector-reps cpu ( -- reps )
 400 HOOK: %abs-vector-reps cpu ( -- reps )
 401 HOOK: %and-vector-reps cpu ( -- reps )
 402 HOOK: %andn-vector-reps cpu ( -- reps )
 403 HOOK: %or-vector-reps cpu ( -- reps )
 404 HOOK: %xor-vector-reps cpu ( -- reps )
 405 HOOK: %not-vector-reps cpu ( -- reps )
 406 HOOK: %shl-vector-reps cpu ( -- reps )
 407 HOOK: %shr-vector-reps cpu ( -- reps )
 408 HOOK: %shl-vector-imm-reps cpu ( -- reps )
 409 HOOK: %shr-vector-imm-reps cpu ( -- reps )
 410 HOOK: %horizontal-shl-vector-imm-reps cpu ( -- reps )
 411 HOOK: %horizontal-shr-vector-imm-reps cpu ( -- reps )
 412
 413 M: object %zero-vector-reps { } ;
 414 M: object %fill-vector-reps { } ;
 415 M: object %gather-vector-2-reps { } ;
 416 M: object %gather-int-vector-2-reps { } ;
 417 M: object %gather-vector-4-reps { } ;
 418 M: object %gather-int-vector-4-reps { } ;
 419 M: object %select-vector-reps { } ;
 420 M: object %alien-vector-reps { } ;
 421 M: object %shuffle-vector-reps { } ;
 422 M: object %shuffle-vector-imm-reps { } ;
 423 M: object %shuffle-vector-halves-imm-reps { } ;
 424 M: object %merge-vector-reps { } ;
 425 M: object %float-pack-vector-reps { } ;
 426 M: object %signed-pack-vector-reps { } ;
 427 M: object %unsigned-pack-vector-reps { } ;
 428 M: object %unpack-vector-head-reps { } ;
 429 M: object %unpack-vector-tail-reps { } ;
 430 M: object %integer>float-vector-reps { } ;
 431 M: object %float>integer-vector-reps { } ;
 432 M: object %compare-vector-reps drop { } ;
 433 M: object %compare-vector-ccs 2drop { } f ;
 434 M: object %test-vector-reps { } ;
 435 M: object %add-vector-reps { } ;
 436 M: object %saturated-add-vector-reps { } ;
 437 M: object %add-sub-vector-reps { } ;
 438 M: object %sub-vector-reps { } ;
 439 M: object %saturated-sub-vector-reps { } ;
 440 M: object %mul-vector-reps { } ;
 441 M: object %saturated-mul-vector-reps { } ;
 442 M: object %div-vector-reps { } ;
 443 M: object %min-vector-reps { } ;
 444 M: object %max-vector-reps { } ;
 445 M: object %dot-vector-reps { } ;
 446 M: object %sqrt-vector-reps { } ;
 447 M: object %horizontal-add-vector-reps { } ;
 448 M: object %horizontal-sub-vector-reps { } ;
 449 M: object %abs-vector-reps { } ;
 450 M: object %and-vector-reps { } ;
 451 M: object %andn-vector-reps { } ;
 452 M: object %or-vector-reps { } ;
 453 M: object %xor-vector-reps { } ;
 454 M: object %not-vector-reps { } ;
 455 M: object %shl-vector-reps { } ;
 456 M: object %shr-vector-reps { } ;
 457 M: object %shl-vector-imm-reps { } ;
 458 M: object %shr-vector-imm-reps { } ;
 459 M: object %horizontal-shl-vector-imm-reps { } ;
 460 M: object %horizontal-shr-vector-imm-reps { } ;
 461
 462 ALIAS: %merge-vector-head-reps %merge-vector-reps
 463 ALIAS: %merge-vector-tail-reps %merge-vector-reps
 464 ALIAS: %tail>head-vector-reps %unpack-vector-head-reps
 465
 466 HOOK: %unbox-alien cpu ( dst src -- )
 467 HOOK: %unbox-any-c-ptr cpu ( dst src -- )
 468 HOOK: %box-alien cpu ( dst src temp -- )
 469 HOOK: %box-displaced-alien cpu ( dst displacement base temp base-class -- )
 470
 471 HOOK: %convert-integer cpu ( dst src c-type -- )
 472
 473 HOOK: %load-memory cpu ( dst base displacement scale offset rep c-type -- )
 474 HOOK: %load-memory-imm cpu ( dst base offset rep c-type -- )
 475 HOOK: %store-memory cpu ( value base displacement scale offset rep c-type -- )
 476 HOOK: %store-memory-imm cpu ( value base offset rep c-type -- )
 477
 478 HOOK: %alien-global cpu ( dst symbol library -- )
 479 HOOK: %vm-field cpu ( dst offset -- )
 480 HOOK: %set-vm-field cpu ( src offset -- )
 481
 482 : %context ( dst -- ) 0 %vm-field ;
 483
 484 HOOK: %allot cpu ( dst size class temp -- )
 485 HOOK: %write-barrier cpu ( src slot scale tag temp1 temp2 -- )
 486 HOOK: %write-barrier-imm cpu ( src slot tag temp1 temp2 -- )
 487
 488 ! GC checks
 489 HOOK: %check-nursery-branch cpu ( label size cc temp1 temp2 -- )
 490 HOOK: %call-gc cpu ( gc-map -- )
 491
 492 HOOK: %prologue cpu ( n -- )
 493 HOOK: %epilogue cpu ( n -- )
 494
 495 HOOK: %safepoint cpu ( -- )
 496
 497 HOOK: test-instruction? cpu ( -- ? )
 498
 499 M: object test-instruction? f ;
 500
 501 HOOK: %compare cpu ( dst src1 src2 cc temp -- )
 502 HOOK: %compare-imm cpu ( dst src1 src2 cc temp -- )
 503 HOOK: %compare-integer-imm cpu ( dst src1 src2 cc temp -- )
 504 HOOK: %test cpu ( dst src1 src2 cc temp -- )
 505 HOOK: %test-imm cpu ( dst src1 src2 cc temp -- )
 506 HOOK: %compare-float-ordered cpu ( dst src1 src2 cc temp -- )
 507 HOOK: %compare-float-unordered cpu ( dst src1 src2 cc temp -- )
 508
 509 HOOK: %compare-branch cpu ( label cc src1 src2 -- )
 510 HOOK: %compare-imm-branch cpu ( label cc src1 src2 -- )
 511 HOOK: %compare-integer-imm-branch cpu ( label cc src1 src2 -- )
 512 HOOK: %test-branch cpu ( label cc src1 src2 -- )
 513 HOOK: %test-imm-branch cpu ( label cc src1 src2 -- )
 514 HOOK: %compare-float-ordered-branch cpu ( label cc src1 src2 -- )
 515 HOOK: %compare-float-unordered-branch cpu ( label cc src1 src2 -- )
 516
 517 HOOK: %spill cpu ( src rep dst -- )
 518 HOOK: %reload cpu ( dst rep src -- )
 519
 520 HOOK: fused-unboxing? cpu ( -- ? )
 521
 522 HOOK: immediate-arithmetic? cpu ( n -- ? )
 523 HOOK: immediate-bitwise? cpu ( n -- ? )
 524 HOOK: immediate-comparand? cpu ( n -- ? )
 525 HOOK: immediate-store? cpu ( n -- ? )
 526
 527 M: object immediate-comparand?
 528     {
 529         { [ dup fixnum? ] [ tag-fixnum immediate-arithmetic? ] }
 530         { [ dup not ] [ drop t ] }
 531         [ drop f ]
 532     } cond ;
 533
 534 : immediate-shift-count? ( n -- ? )
 535     0 cell-bits 1 - between? ;
 536
 537 ! FFI stuff
 538
 539 HOOK: return-regs cpu ( -- regs )
 540
 541 HOOK: param-regs cpu ( abi -- regs )
 542
 543 HOOK: return-struct-in-registers? cpu ( c-type -- ? )
 544
 545 ! Do we pass this struct by value or hidden reference?
 546 HOOK: value-struct? cpu ( c-type -- ? )
 547
 548 ! If t, all parameters are shadowed by dummy stack parameters
 549 HOOK: dummy-stack-params? cpu ( -- ? )
 550
 551 HOOK: dummy-int-params? cpu ( -- ? )
 552 HOOK: dummy-fp-params? cpu ( -- ? )
 553
 554 ! If t, long longs are never passed in param regs
 555 HOOK: long-long-on-stack? cpu ( -- ? )
 556
 557 ! If t, long longs are aligned on an odd register. On Linux
 558 ! 32-bit PPC, long longs are 8-byte aligned but passed in
 559 ! registers so they need to be aligned on an odd numbered
 560 ! (r3, r5, etc) register.
 561 HOOK: long-long-odd-register? cpu ( -- ? )
 562
 563 ! If t, put floats in the second word of a double word on the stack
 564 HOOK: float-right-align-on-stack? cpu ( -- ? )
 565
 566 ! If t, the struct return pointer is never passed in a param reg
 567 HOOK: struct-return-on-stack? cpu ( -- ? )
 568
 569 HOOK: %unbox cpu ( dst src func rep -- )
 570
 571 HOOK: %unbox-long-long cpu ( dst1 dst2 src func -- )
 572
 573 HOOK: %local-allot cpu ( dst size align offset -- )
 574
 575 HOOK: %box cpu ( dst src func rep gc-map -- )
 576
 577 HOOK: %box-long-long cpu ( dst src1 src2 func gc-map -- )
 578
 579 HOOK: %save-context cpu ( temp1 temp2 -- )
 580
 581 HOOK: %c-invoke cpu ( symbols dll gc-map -- )
 582
 583 HOOK: %alien-invoke cpu ( varargs? reg-inputs stack-inputs
 584                           reg-outputs dead-outputs
 585                           cleanup stack-size
 586                           symbols dll gc-map -- )
 587
 588 HOOK: %alien-indirect cpu ( src
 589                             varargs? reg-inputs stack-inputs
 590                             reg-outputs dead-outputs
 591                             cleanup stack-size
 592                             gc-map -- )
 593
 594 HOOK: %alien-assembly cpu ( varargs? reg-inputs stack-inputs
 595                             reg-outputs dead-outputs
 596                             cleanup stack-size
 597                             quot -- )
 598
 599 HOOK: %callback-inputs cpu ( reg-outputs stack-outputs -- )
 600
 601 HOOK: %callback-outputs cpu ( reg-inputs -- )
 602
 603 HOOK: stack-cleanup cpu ( stack-size return abi -- n )
 604
 605 HOOK: enable-cpu-features cpu ( -- )