basis/cpu/architecture/architecture.factor

   1 ! Copyright (C) 2006, 2010 Slava Pestov.
   2 ! See http://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 ! On x86, vectors and floats are stored in the same register bank
 154 ! On PowerPC they are distinct
 155 HOOK: vector-regs cpu ( -- reg-class )
 156
 157 GENERIC: reg-class-of ( rep -- reg-class )
 158
 159 M: tagged-rep reg-class-of drop int-regs ;
 160 M: int-rep reg-class-of drop int-regs ;
 161 M: float-rep reg-class-of drop float-regs ;
 162 M: double-rep reg-class-of drop float-regs ;
 163 M: vector-rep reg-class-of drop vector-regs ;
 164 M: scalar-rep reg-class-of drop vector-regs ;
 165
 166 GENERIC: rep-size ( rep -- n ) foldable
 167
 168 M: tagged-rep rep-size drop cell ;
 169 M: int-rep rep-size drop cell ;
 170 M: float-rep rep-size drop 4 ;
 171 M: double-rep rep-size drop 8 ;
 172 M: vector-rep rep-size drop 16 ;
 173 M: char-scalar-rep rep-size drop 1 ;
 174 M: uchar-scalar-rep rep-size drop 1 ;
 175 M: short-scalar-rep rep-size drop 2 ;
 176 M: ushort-scalar-rep rep-size drop 2 ;
 177 M: int-scalar-rep rep-size drop 4 ;
 178 M: uint-scalar-rep rep-size drop 4 ;
 179 M: longlong-scalar-rep rep-size drop 8 ;
 180 M: ulonglong-scalar-rep rep-size drop 8 ;
 181
 182 GENERIC: rep-length ( rep -- n ) foldable
 183
 184 M: char-16-rep rep-length drop 16 ;
 185 M: uchar-16-rep rep-length drop 16 ;
 186 M: short-8-rep rep-length drop 8 ;
 187 M: ushort-8-rep rep-length drop 8 ;
 188 M: int-4-rep rep-length drop 4 ;
 189 M: uint-4-rep rep-length drop 4 ;
 190 M: longlong-2-rep rep-length drop 2 ;
 191 M: ulonglong-2-rep rep-length drop 2 ;
 192 M: float-4-rep rep-length drop 4 ;
 193 M: double-2-rep rep-length drop 2 ;
 194
 195 GENERIC: rep-component-type ( rep -- n )
 196
 197 ! Methods defined in alien.c-types
 198
 199 GENERIC: scalar-rep-of ( rep -- rep' )
 200
 201 M: float-4-rep scalar-rep-of drop float-rep ;
 202 M: double-2-rep scalar-rep-of drop double-rep ;
 203 M: char-16-rep scalar-rep-of drop char-scalar-rep ;
 204 M: uchar-16-rep scalar-rep-of drop uchar-scalar-rep ;
 205 M: short-8-rep scalar-rep-of drop short-scalar-rep ;
 206 M: ushort-8-rep scalar-rep-of drop ushort-scalar-rep ;
 207 M: int-4-rep scalar-rep-of drop int-scalar-rep ;
 208 M: uint-4-rep scalar-rep-of drop uint-scalar-rep ;
 209 M: longlong-2-rep scalar-rep-of drop longlong-scalar-rep ;
 210 M: ulonglong-2-rep scalar-rep-of drop ulonglong-scalar-rep ;
 211
 212 ! Mapping from register class to machine registers
 213 HOOK: machine-registers cpu ( -- assoc )
 214
 215 ! Callbacks are not allowed to clobber this
 216 HOOK: frame-reg cpu ( -- reg )
 217
 218 ! Parameter space to reserve in anything making VM calls
 219 HOOK: vm-stack-space cpu ( -- n )
 220
 221 M: object vm-stack-space 0 ;
 222
 223 ! Specifies if %slot, %set-slot and %write-barrier accept the
 224 ! 'scale' and 'tag' parameters, and if %load-memory and
 225 ! %store-memory work
 226 HOOK: complex-addressing? cpu ( -- ? )
 227
 228 HOOK: %load-immediate cpu ( reg val -- )
 229 HOOK: %load-reference cpu ( reg obj -- )
 230 HOOK: %load-float cpu ( reg val -- )
 231 HOOK: %load-double cpu ( reg val -- )
 232 HOOK: %load-vector cpu ( reg val rep -- )
 233
 234 HOOK: %peek cpu ( vreg loc -- )
 235 HOOK: %replace cpu ( vreg loc -- )
 236 HOOK: %replace-imm cpu ( src loc -- )
 237 HOOK: %inc-d cpu ( n -- )
 238 HOOK: %inc-r cpu ( n -- )
 239
 240 HOOK: stack-frame-size cpu ( stack-frame -- n )
 241 HOOK: %call cpu ( word -- )
 242 HOOK: %jump cpu ( word -- )
 243 HOOK: %jump-label cpu ( label -- )
 244 HOOK: %return cpu ( -- )
 245
 246 HOOK: %dispatch cpu ( src temp -- )
 247
 248 HOOK: %slot cpu ( dst obj slot scale tag -- )
 249 HOOK: %slot-imm cpu ( dst obj slot tag -- )
 250 HOOK: %set-slot cpu ( src obj slot scale tag -- )
 251 HOOK: %set-slot-imm cpu ( src obj slot tag -- )
 252
 253 HOOK: %add     cpu ( dst src1 src2 -- )
 254 HOOK: %add-imm cpu ( dst src1 src2 -- )
 255 HOOK: %sub     cpu ( dst src1 src2 -- )
 256 HOOK: %sub-imm cpu ( dst src1 src2 -- )
 257 HOOK: %mul     cpu ( dst src1 src2 -- )
 258 HOOK: %mul-imm cpu ( dst src1 src2 -- )
 259 HOOK: %and     cpu ( dst src1 src2 -- )
 260 HOOK: %and-imm cpu ( dst src1 src2 -- )
 261 HOOK: %or      cpu ( dst src1 src2 -- )
 262 HOOK: %or-imm  cpu ( dst src1 src2 -- )
 263 HOOK: %xor     cpu ( dst src1 src2 -- )
 264 HOOK: %xor-imm cpu ( dst src1 src2 -- )
 265 HOOK: %shl     cpu ( dst src1 src2 -- )
 266 HOOK: %shl-imm cpu ( dst src1 src2 -- )
 267 HOOK: %shr     cpu ( dst src1 src2 -- )
 268 HOOK: %shr-imm cpu ( dst src1 src2 -- )
 269 HOOK: %sar     cpu ( dst src1 src2 -- )
 270 HOOK: %sar-imm cpu ( dst src1 src2 -- )
 271 HOOK: %min     cpu ( dst src1 src2 -- )
 272 HOOK: %max     cpu ( dst src1 src2 -- )
 273 HOOK: %not     cpu ( dst src -- )
 274 HOOK: %neg     cpu ( dst src -- )
 275 HOOK: %log2    cpu ( dst src -- )
 276 HOOK: %bit-count cpu ( dst src -- )
 277
 278 HOOK: %copy cpu ( dst src rep -- )
 279
 280 : %tagged>integer ( dst src -- ) int-rep %copy ;
 281
 282 HOOK: %fixnum-add cpu ( label dst src1 src2 cc -- )
 283 HOOK: %fixnum-sub cpu ( label dst src1 src2 cc -- )
 284 HOOK: %fixnum-mul cpu ( label dst src1 src2 cc -- )
 285
 286 HOOK: %add-float cpu ( dst src1 src2 -- )
 287 HOOK: %sub-float cpu ( dst src1 src2 -- )
 288 HOOK: %mul-float cpu ( dst src1 src2 -- )
 289 HOOK: %div-float cpu ( dst src1 src2 -- )
 290 HOOK: %min-float cpu ( dst src1 src2 -- )
 291 HOOK: %max-float cpu ( dst src1 src2 -- )
 292 HOOK: %sqrt cpu ( dst src -- )
 293 HOOK: %unary-float-function cpu ( dst src func -- )
 294 HOOK: %binary-float-function cpu ( dst src1 src2 func -- )
 295
 296 HOOK: %single>double-float cpu ( dst src -- )
 297 HOOK: %double>single-float cpu ( dst src -- )
 298
 299 HOOK: integer-float-needs-stack-frame? cpu ( -- ? )
 300
 301 HOOK: %integer>float cpu ( dst src -- )
 302 HOOK: %float>integer cpu ( dst src -- )
 303
 304 HOOK: %zero-vector cpu ( dst rep -- )
 305 HOOK: %fill-vector cpu ( dst rep -- )
 306 HOOK: %gather-vector-2 cpu ( dst src1 src2 rep -- )
 307 HOOK: %gather-int-vector-2 cpu ( dst src1 src2 rep -- )
 308 HOOK: %gather-vector-4 cpu ( dst src1 src2 src3 src4 rep -- )
 309 HOOK: %gather-int-vector-4 cpu ( dst src1 src2 src3 src4 rep -- )
 310 HOOK: %select-vector cpu ( dst src n rep -- )
 311 HOOK: %shuffle-vector cpu ( dst src shuffle rep -- )
 312 HOOK: %shuffle-vector-imm cpu ( dst src shuffle rep -- )
 313 HOOK: %shuffle-vector-halves-imm cpu ( dst src1 src2 shuffle rep -- )
 314 HOOK: %tail>head-vector cpu ( dst src rep -- )
 315 HOOK: %merge-vector-head cpu ( dst src1 src2 rep -- )
 316 HOOK: %merge-vector-tail cpu ( dst src1 src2 rep -- )
 317 HOOK: %float-pack-vector cpu ( dst src rep -- )
 318 HOOK: %signed-pack-vector cpu ( dst src1 src2 rep -- )
 319 HOOK: %unsigned-pack-vector cpu ( dst src1 src2 rep -- )
 320 HOOK: %unpack-vector-head cpu ( dst src rep -- )
 321 HOOK: %unpack-vector-tail cpu ( dst src rep -- )
 322 HOOK: %integer>float-vector cpu ( dst src rep -- )
 323 HOOK: %float>integer-vector cpu ( dst src rep -- )
 324 HOOK: %compare-vector cpu ( dst src1 src2 rep cc -- )
 325 HOOK: %test-vector cpu ( dst src1 temp rep vcc -- )
 326 HOOK: %test-vector-branch cpu ( label src1 temp rep vcc -- )
 327 HOOK: %add-vector cpu ( dst src1 src2 rep -- )
 328 HOOK: %saturated-add-vector cpu ( dst src1 src2 rep -- )
 329 HOOK: %add-sub-vector cpu ( dst src1 src2 rep -- )
 330 HOOK: %sub-vector cpu ( dst src1 src2 rep -- )
 331 HOOK: %saturated-sub-vector cpu ( dst src1 src2 rep -- )
 332 HOOK: %mul-vector cpu ( dst src1 src2 rep -- )
 333 HOOK: %mul-high-vector cpu ( dst src1 src2 rep -- )
 334 HOOK: %mul-horizontal-add-vector cpu ( dst src1 src2 rep -- )
 335 HOOK: %saturated-mul-vector cpu ( dst src1 src2 rep -- )
 336 HOOK: %div-vector cpu ( dst src1 src2 rep -- )
 337 HOOK: %min-vector cpu ( dst src1 src2 rep -- )
 338 HOOK: %max-vector cpu ( dst src1 src2 rep -- )
 339 HOOK: %avg-vector cpu ( dst src1 src2 rep -- )
 340 HOOK: %dot-vector cpu ( dst src1 src2 rep -- )
 341 HOOK: %sad-vector cpu ( dst src1 src2 rep -- )
 342 HOOK: %sqrt-vector cpu ( dst src rep -- )
 343 HOOK: %horizontal-add-vector cpu ( dst src1 src2 rep -- )
 344 HOOK: %horizontal-sub-vector cpu ( dst src1 src2 rep -- )
 345 HOOK: %abs-vector cpu ( dst src rep -- )
 346 HOOK: %and-vector cpu ( dst src1 src2 rep -- )
 347 HOOK: %andn-vector cpu ( dst src1 src2 rep -- )
 348 HOOK: %or-vector cpu ( dst src1 src2 rep -- )
 349 HOOK: %xor-vector cpu ( dst src1 src2 rep -- )
 350 HOOK: %not-vector cpu ( dst src rep -- )
 351 HOOK: %shl-vector cpu ( dst src1 src2 rep -- )
 352 HOOK: %shr-vector cpu ( dst src1 src2 rep -- )
 353 HOOK: %shl-vector-imm cpu ( dst src1 src2 rep -- )
 354 HOOK: %shr-vector-imm cpu ( dst src1 src2 rep -- )
 355 HOOK: %horizontal-shl-vector-imm cpu ( dst src1 src2 rep -- )
 356 HOOK: %horizontal-shr-vector-imm cpu ( dst src1 src2 rep -- )
 357
 358 HOOK: %integer>scalar cpu ( dst src rep -- )
 359 HOOK: %scalar>integer cpu ( dst src rep -- )
 360 HOOK: %vector>scalar cpu ( dst src rep -- )
 361 HOOK: %scalar>vector cpu ( dst src rep -- )
 362
 363 HOOK: %zero-vector-reps cpu ( -- reps )
 364 HOOK: %fill-vector-reps cpu ( -- reps )
 365 HOOK: %gather-vector-2-reps cpu ( -- reps )
 366 HOOK: %gather-int-vector-2-reps cpu ( -- reps )
 367 HOOK: %gather-vector-4-reps cpu ( -- reps )
 368 HOOK: %gather-int-vector-4-reps cpu ( -- reps )
 369 HOOK: %select-vector-reps cpu ( -- reps )
 370 HOOK: %alien-vector-reps cpu ( -- reps )
 371 HOOK: %shuffle-vector-reps cpu ( -- reps )
 372 HOOK: %shuffle-vector-imm-reps cpu ( -- reps )
 373 HOOK: %shuffle-vector-halves-imm-reps cpu ( -- reps )
 374 HOOK: %merge-vector-reps cpu ( -- reps )
 375 HOOK: %float-pack-vector-reps cpu ( -- reps )
 376 HOOK: %signed-pack-vector-reps cpu ( -- reps )
 377 HOOK: %unsigned-pack-vector-reps cpu ( -- reps )
 378 HOOK: %unpack-vector-head-reps cpu ( -- reps )
 379 HOOK: %unpack-vector-tail-reps cpu ( -- reps )
 380 HOOK: %integer>float-vector-reps cpu ( -- reps )
 381 HOOK: %float>integer-vector-reps cpu ( -- reps )
 382 HOOK: %compare-vector-reps cpu ( cc -- reps )
 383 HOOK: %compare-vector-ccs cpu ( rep cc -- {cc,swap?}s not? )
 384 HOOK: %test-vector-reps cpu ( -- reps )
 385 HOOK: %add-vector-reps cpu ( -- reps )
 386 HOOK: %saturated-add-vector-reps cpu ( -- reps )
 387 HOOK: %add-sub-vector-reps cpu ( -- reps )
 388 HOOK: %sub-vector-reps cpu ( -- reps )
 389 HOOK: %saturated-sub-vector-reps cpu ( -- reps )
 390 HOOK: %mul-vector-reps cpu ( -- reps )
 391 HOOK: %mul-high-vector-reps cpu ( -- reps )
 392 HOOK: %mul-horizontal-add-vector-reps cpu ( -- reps )
 393 HOOK: %saturated-mul-vector-reps cpu ( -- reps )
 394 HOOK: %div-vector-reps cpu ( -- reps )
 395 HOOK: %min-vector-reps cpu ( -- reps )
 396 HOOK: %max-vector-reps cpu ( -- reps )
 397 HOOK: %avg-vector-reps cpu ( -- reps )
 398 HOOK: %dot-vector-reps cpu ( -- reps )
 399 HOOK: %sad-vector-reps cpu ( -- reps )
 400 HOOK: %sqrt-vector-reps cpu ( -- reps )
 401 HOOK: %horizontal-add-vector-reps cpu ( -- reps )
 402 HOOK: %horizontal-sub-vector-reps cpu ( -- reps )
 403 HOOK: %abs-vector-reps cpu ( -- reps )
 404 HOOK: %and-vector-reps cpu ( -- reps )
 405 HOOK: %andn-vector-reps cpu ( -- reps )
 406 HOOK: %or-vector-reps cpu ( -- reps )
 407 HOOK: %xor-vector-reps cpu ( -- reps )
 408 HOOK: %not-vector-reps cpu ( -- reps )
 409 HOOK: %shl-vector-reps cpu ( -- reps )
 410 HOOK: %shr-vector-reps cpu ( -- reps )
 411 HOOK: %shl-vector-imm-reps cpu ( -- reps )
 412 HOOK: %shr-vector-imm-reps cpu ( -- reps )
 413 HOOK: %horizontal-shl-vector-imm-reps cpu ( -- reps )
 414 HOOK: %horizontal-shr-vector-imm-reps cpu ( -- reps )
 415
 416 M: object %zero-vector-reps { } ;
 417 M: object %fill-vector-reps { } ;
 418 M: object %gather-vector-2-reps { } ;
 419 M: object %gather-int-vector-2-reps { } ;
 420 M: object %gather-vector-4-reps { } ;
 421 M: object %gather-int-vector-4-reps { } ;
 422 M: object %select-vector-reps { } ;
 423 M: object %alien-vector-reps { } ;
 424 M: object %shuffle-vector-reps { } ;
 425 M: object %shuffle-vector-imm-reps { } ;
 426 M: object %shuffle-vector-halves-imm-reps { } ;
 427 M: object %merge-vector-reps { } ;
 428 M: object %float-pack-vector-reps { } ;
 429 M: object %signed-pack-vector-reps { } ;
 430 M: object %unsigned-pack-vector-reps { } ;
 431 M: object %unpack-vector-head-reps { } ;
 432 M: object %unpack-vector-tail-reps { } ;
 433 M: object %integer>float-vector-reps { } ;
 434 M: object %float>integer-vector-reps { } ;
 435 M: object %compare-vector-reps drop { } ;
 436 M: object %compare-vector-ccs 2drop { } f ;
 437 M: object %test-vector-reps { } ;
 438 M: object %add-vector-reps { } ;
 439 M: object %saturated-add-vector-reps { } ;
 440 M: object %add-sub-vector-reps { } ;
 441 M: object %sub-vector-reps { } ;
 442 M: object %saturated-sub-vector-reps { } ;
 443 M: object %mul-vector-reps { } ;
 444 M: object %saturated-mul-vector-reps { } ;
 445 M: object %div-vector-reps { } ;
 446 M: object %min-vector-reps { } ;
 447 M: object %max-vector-reps { } ;
 448 M: object %dot-vector-reps { } ;
 449 M: object %sqrt-vector-reps { } ;
 450 M: object %horizontal-add-vector-reps { } ;
 451 M: object %horizontal-sub-vector-reps { } ;
 452 M: object %abs-vector-reps { } ;
 453 M: object %and-vector-reps { } ;
 454 M: object %andn-vector-reps { } ;
 455 M: object %or-vector-reps { } ;
 456 M: object %xor-vector-reps { } ;
 457 M: object %not-vector-reps { } ;
 458 M: object %shl-vector-reps { } ;
 459 M: object %shr-vector-reps { } ;
 460 M: object %shl-vector-imm-reps { } ;
 461 M: object %shr-vector-imm-reps { } ;
 462 M: object %horizontal-shl-vector-imm-reps { } ;
 463 M: object %horizontal-shr-vector-imm-reps { } ;
 464
 465 ALIAS: %merge-vector-head-reps %merge-vector-reps
 466 ALIAS: %merge-vector-tail-reps %merge-vector-reps
 467 ALIAS: %tail>head-vector-reps %unpack-vector-head-reps
 468
 469 HOOK: %unbox-alien cpu ( dst src -- )
 470 HOOK: %unbox-any-c-ptr cpu ( dst src -- )
 471 HOOK: %box-alien cpu ( dst src temp -- )
 472 HOOK: %box-displaced-alien cpu ( dst displacement base temp base-class -- )
 473
 474 HOOK: %load-memory cpu ( dst base displacement scale offset rep c-type -- )
 475 HOOK: %load-memory-imm cpu ( dst base offset rep c-type -- )
 476 HOOK: %store-memory cpu ( value base displacement scale offset rep c-type -- )
 477 HOOK: %store-memory-imm cpu ( value base offset rep c-type -- )
 478
 479 HOOK: %alien-global cpu ( dst symbol library -- )
 480 HOOK: %vm-field cpu ( dst offset -- )
 481 HOOK: %set-vm-field cpu ( src offset -- )
 482
 483 : %context ( dst -- ) 0 %vm-field ;
 484
 485 HOOK: %allot cpu ( dst size class temp -- )
 486 HOOK: %write-barrier cpu ( src slot scale tag temp1 temp2 -- )
 487 HOOK: %write-barrier-imm cpu ( src slot tag temp1 temp2 -- )
 488
 489 ! GC checks
 490 HOOK: %check-nursery-branch cpu ( label size cc temp1 temp2 -- )
 491 HOOK: %call-gc cpu ( gc-roots -- )
 492
 493 HOOK: %prologue cpu ( n -- )
 494 HOOK: %epilogue cpu ( n -- )
 495
 496 HOOK: test-instruction? cpu ( -- ? )
 497
 498 M: object test-instruction? f ;
 499
 500 HOOK: %compare cpu ( dst src1 src2 cc temp -- )
 501 HOOK: %compare-imm cpu ( dst src1 src2 cc temp -- )
 502 HOOK: %compare-integer-imm cpu ( dst src1 src2 cc temp -- )
 503 HOOK: %test cpu ( dst src1 src2 cc temp -- )
 504 HOOK: %test-imm cpu ( dst src1 src2 cc temp -- )
 505 HOOK: %compare-float-ordered cpu ( dst src1 src2 cc temp -- )
 506 HOOK: %compare-float-unordered cpu ( dst src1 src2 cc temp -- )
 507
 508 HOOK: %compare-branch cpu ( label cc src1 src2 -- )
 509 HOOK: %compare-imm-branch cpu ( label cc src1 src2 -- )
 510 HOOK: %compare-integer-imm-branch cpu ( label cc src1 src2 -- )
 511 HOOK: %test-branch cpu ( label cc src1 src2 -- )
 512 HOOK: %test-imm-branch cpu ( label cc src1 src2 -- )
 513 HOOK: %compare-float-ordered-branch cpu ( label cc src1 src2 -- )
 514 HOOK: %compare-float-unordered-branch cpu ( label cc src1 src2 -- )
 515
 516 HOOK: %spill cpu ( src rep dst -- )
 517 HOOK: %reload cpu ( dst rep src -- )
 518
 519 HOOK: %loop-entry cpu ( -- )
 520
 521 ! Does this architecture support %load-float, %load-double,
 522 ! and %load-vector?
 523 HOOK: fused-unboxing? cpu ( -- ? )
 524
 525 ! Can this value be an immediate operand for %add-imm, %sub-imm,
 526 ! or %mul-imm?
 527 HOOK: immediate-arithmetic? cpu ( n -- ? )
 528
 529 ! Can this value be an immediate operand for %and-imm, %or-imm,
 530 ! or %xor-imm?
 531 HOOK: immediate-bitwise? cpu ( n -- ? )
 532
 533 ! Can this value be an immediate operand for %compare-imm or
 534 ! %compare-imm-branch?
 535 HOOK: immediate-comparand? cpu ( n -- ? )
 536
 537 ! Can this value be an immediate operand for %replace-imm?
 538 HOOK: immediate-store? cpu ( obj -- ? )
 539
 540 M: object immediate-comparand? ( n -- ? )
 541     {
 542         { [ dup fixnum? ] [ tag-fixnum immediate-arithmetic? ] }
 543         { [ dup not ] [ drop t ] }
 544         [ drop f ]
 545     } cond ;
 546
 547 : immediate-shift-count? ( n -- ? )
 548     0 cell-bits 1 - between? ;
 549
 550 ! FFI stuff
 551
 552 ! Return values of this class go here
 553 HOOK: return-regs cpu ( -- regs )
 554
 555 ! Registers used for parameter passing
 556 HOOK: param-regs cpu ( abi -- regs )
 557
 558 ! Is this structure small enough to be returned in registers?
 559 HOOK: return-struct-in-registers? cpu ( c-type -- ? )
 560
 561 ! Do we pass this struct by value or hidden reference?
 562 HOOK: value-struct? cpu ( c-type -- ? )
 563
 564 ! If t, all parameters are shadowed by dummy stack parameters
 565 HOOK: dummy-stack-params? cpu ( -- ? )
 566
 567 ! If t, all FP parameters are shadowed by dummy int parameters
 568 HOOK: dummy-int-params? cpu ( -- ? )
 569
 570 ! If t, all int parameters are shadowed by dummy FP parameters
 571 HOOK: dummy-fp-params? cpu ( -- ? )
 572
 573 ! If t, long longs are never passed in param regs
 574 HOOK: long-long-on-stack? cpu ( -- ? )
 575
 576 ! If t, floats are never passed in param regs
 577 HOOK: float-on-stack? cpu ( -- ? )
 578
 579 ! If t, the struct return pointer is never passed in a param reg
 580 HOOK: struct-return-on-stack? cpu ( -- ? )
 581
 582 ! Call a function to convert a tagged pointer into a value that
 583 ! can be passed to a C function, or returned from a callback
 584 HOOK: %unbox cpu ( dst src func rep -- )
 585
 586 HOOK: %unbox-long-long cpu ( src out func -- )
 587
 588 HOOK: %store-reg-param cpu ( src reg rep -- )
 589
 590 HOOK: %store-stack-param cpu ( src n rep -- )
 591
 592 HOOK: %local-allot cpu ( dst size align offset -- )
 593
 594 ! Call a function to convert a value into a tagged pointer,
 595 ! possibly allocating a bignum, float, or alien instance,
 596 ! which is then pushed on the data stack
 597 HOOK: %box cpu ( dst src func rep -- )
 598
 599 HOOK: %box-long-long cpu ( dst src1 src2 func -- )
 600
 601 HOOK: %allot-byte-array cpu ( dst size -- )
 602
 603 HOOK: %restore-context cpu ( temp1 temp2 -- )
 604
 605 HOOK: %save-context cpu ( temp1 temp2 -- )
 606
 607 HOOK: %prepare-var-args cpu ( -- )
 608
 609 M: object %prepare-var-args ;
 610
 611 HOOK: %alien-invoke cpu ( function library -- )
 612
 613 HOOK: %cleanup cpu ( n -- )
 614
 615 M: object %cleanup ( n -- ) drop ;
 616
 617 HOOK: %alien-indirect cpu ( src -- )
 618
 619 HOOK: %load-reg-param cpu ( dst reg rep -- )
 620
 621 HOOK: %load-stack-param cpu ( dst n rep -- )
 622
 623 HOOK: %begin-callback cpu ( -- )
 624
 625 HOOK: %alien-callback cpu ( quot -- )
 626
 627 HOOK: %end-callback cpu ( -- )
 628
 629 HOOK: stack-cleanup cpu ( stack-size return abi -- n )
 630
 631 M: object stack-cleanup 3drop 0 ;