basis/compiler/cfg/linear-scan/linear-scan-tests.factor

   1 USING: tools.test random sorting sequences sets hashtables assocs
   2 kernel fry arrays splitting namespaces math accessors vectors locals
   3 math.order grouping strings strings.private classes layouts
   4 cpu.architecture
   5 compiler.cfg
   6 compiler.cfg.optimizer
   7 compiler.cfg.instructions
   8 compiler.cfg.registers
   9 compiler.cfg.predecessors
  10 compiler.cfg.rpo
  11 compiler.cfg.debugger
  12 compiler.cfg.def-use
  13 compiler.cfg.comparisons
  14 compiler.cfg.ssa.destruction.leaders
  15 compiler.cfg.linear-scan
  16 compiler.cfg.linear-scan.numbering
  17 compiler.cfg.linear-scan.live-intervals
  18 compiler.cfg.linear-scan.allocation
  19 compiler.cfg.linear-scan.allocation.state
  20 compiler.cfg.linear-scan.allocation.splitting
  21 compiler.cfg.linear-scan.allocation.spilling
  22 compiler.cfg.linear-scan.debugger
  23 compiler.cfg.utilities ;
  24 FROM: namespaces => set ;
  25 IN: compiler.cfg.linear-scan.tests
  26
  27 check-allocation? on
  28 check-numbering? on
  29
  30 ! Live interval calculation
  31
  32 ! A value is defined and never used; make sure it has the right
  33 ! live range
  34 V{
  35     T{ ##load-integer f 1 0 }
  36     T{ ##replace-imm f D 0 "hi" }
  37     T{ ##branch }
  38 } 0 test-bb
  39
  40 : test-live-intervals ( -- )
  41     0 get block>cfg
  42     [ cfg set ] [ number-instructions ] [ compute-live-intervals ] tri
  43     drop ;
  44
  45 { } [
  46     H{
  47         { 1 int-rep }
  48     } representations set
  49     H{
  50         { 1 1 }
  51     } leader-map set
  52     test-live-intervals
  53 ] unit-test
  54
  55 { 0 0 } [
  56     1 live-intervals get at [ start>> ] [ end>> ] bi
  57 ] unit-test
  58
  59 ! Live range and interval splitting
  60 {
  61     { T{ live-range f 1 10 } T{ live-range f 15 15 } }
  62     { T{ live-range f 16 20 } }
  63 } [
  64     {
  65         T{ live-range f 1 10 }
  66         T{ live-range f 15 20 }
  67     } 15 split-ranges
  68 ] unit-test
  69
  70 {
  71     { T{ live-range f 1 10 } T{ live-range f 15 16 } }
  72     { T{ live-range f 17 20 } }
  73 } [
  74     {
  75         T{ live-range f 1 10 }
  76         T{ live-range f 15 20 }
  77     } 16 split-ranges
  78 ] unit-test
  79
  80 {
  81     { T{ live-range f 1 10 } }
  82     { T{ live-range f 15 20 } }
  83 } [
  84     {
  85         T{ live-range f 1 10 }
  86         T{ live-range f 15 20 }
  87     } 12 split-ranges
  88 ] unit-test
  89
  90 {
  91     { T{ live-range f 1 10 } T{ live-range f 15 17 } }
  92     { T{ live-range f 18 20 } }
  93 } [
  94     {
  95         T{ live-range f 1 10 }
  96         T{ live-range f 15 20 }
  97     } 17 split-ranges
  98 ] unit-test
  99
 100 [
 101     { T{ live-range f 1 10 } } 0 split-ranges
 102 ] must-fail
 103
 104 {
 105     { T{ live-range f 0 0 } }
 106     { T{ live-range f 1 5 } }
 107 } [
 108     { T{ live-range f 0 5 } } 0 split-ranges
 109 ] unit-test
 110
 111 cfg new 0 >>spill-area-size 4 >>spill-area-align cfg set
 112 H{ } spill-slots set
 113
 114 H{
 115     { 1 float-rep }
 116     { 2 float-rep }
 117     { 3 float-rep }
 118 } representations set
 119
 120 : clean-up-split ( a b -- a b )
 121     [ dup [ [ >vector ] change-uses [ >vector ] change-ranges ] when ] bi@ ;
 122
 123 {
 124     T{ live-interval-state
 125        { vreg 1 }
 126        { reg-class float-regs }
 127        { start 0 }
 128        { end 2 }
 129        { uses V{ T{ vreg-use f 0 float-rep f } T{ vreg-use f 1 f float-rep } } }
 130        { ranges V{ T{ live-range f 0 2 } } }
 131        { spill-to T{ spill-slot f 0 } }
 132        { spill-rep float-rep }
 133     }
 134     T{ live-interval-state
 135        { vreg 1 }
 136        { reg-class float-regs }
 137        { start 5 }
 138        { end 5 }
 139        { uses V{ T{ vreg-use f 5 f float-rep } } }
 140        { ranges V{ T{ live-range f 5 5 } } }
 141        { reload-from T{ spill-slot f 0 } }
 142        { reload-rep float-rep }
 143     }
 144 } [
 145     T{ live-interval-state
 146        { vreg 1 }
 147        { reg-class float-regs }
 148        { start 0 }
 149        { end 5 }
 150        { uses V{ T{ vreg-use f 0 float-rep f } T{ vreg-use f 1 f float-rep } T{ vreg-use f 5 f float-rep } } }
 151        { ranges V{ T{ live-range f 0 5 } } }
 152     } 2 split-for-spill
 153     clean-up-split
 154 ] unit-test
 155
 156 {
 157     f
 158     T{ live-interval-state
 159        { vreg 2 }
 160        { reg-class float-regs }
 161        { start 1 }
 162        { end 5 }
 163        { uses V{ T{ vreg-use f 1 f float-rep } T{ vreg-use f 5 f float-rep } } }
 164        { ranges V{ T{ live-range f 1 5 } } }
 165        { reload-from T{ spill-slot f 4 } }
 166        { reload-rep float-rep }
 167     }
 168 } [
 169     T{ live-interval-state
 170        { vreg 2 }
 171        { reg-class float-regs }
 172        { start 0 }
 173        { end 5 }
 174        { uses V{ T{ vreg-use f 0 float-rep f } T{ vreg-use f 1 f float-rep } T{ vreg-use f 5 f float-rep } } }
 175        { ranges V{ T{ live-range f 0 5 } } }
 176     } 0 split-for-spill
 177     clean-up-split
 178 ] unit-test
 179
 180 {
 181     T{ live-interval-state
 182        { vreg 3 }
 183        { reg-class float-regs }
 184        { start 0 }
 185        { end 2 }
 186        { uses V{ T{ vreg-use f 0 float-rep f } T{ vreg-use f 1 f float-rep } } }
 187        { ranges V{ T{ live-range f 0 2 } } }
 188        { spill-to T{ spill-slot f 8 } }
 189        { spill-rep float-rep }
 190     }
 191     f
 192 } [
 193     T{ live-interval-state
 194        { vreg 3 }
 195        { reg-class float-regs }
 196        { start 0 }
 197        { end 5 }
 198        { uses V{ T{ vreg-use f 0 float-rep f } T{ vreg-use f 1 f float-rep } T{ vreg-use f 5 f float-rep } } }
 199        { ranges V{ T{ live-range f 0 5 } } }
 200     } 5 split-for-spill
 201     clean-up-split
 202 ] unit-test
 203
 204 {
 205     T{ live-interval-state
 206        { vreg 4 }
 207        { reg-class float-regs }
 208        { start 0 }
 209        { end 1 }
 210        { uses V{ T{ vreg-use f 0 float-rep f } } }
 211        { ranges V{ T{ live-range f 0 1 } } }
 212        { spill-to T{ spill-slot f 12 } }
 213        { spill-rep float-rep }
 214     }
 215     T{ live-interval-state
 216        { vreg 4 }
 217        { reg-class float-regs }
 218        { start 20 }
 219        { end 30 }
 220        { uses V{ T{ vreg-use f 20 f float-rep } T{ vreg-use f 30 f float-rep } } }
 221        { ranges V{ T{ live-range f 20 30 } } }
 222        { reload-from T{ spill-slot f 12 } }
 223        { reload-rep float-rep }
 224     }
 225 } [
 226     T{ live-interval-state
 227        { vreg 4 }
 228        { reg-class float-regs }
 229        { start 0 }
 230        { end 30 }
 231        { uses V{ T{ vreg-use f 0 float-rep f } T{ vreg-use f 20 f float-rep } T{ vreg-use f 30 f float-rep } } }
 232        { ranges V{ T{ live-range f 0 8 } T{ live-range f 10 18 } T{ live-range f 20 30 } } }
 233     } 10 split-for-spill
 234     clean-up-split
 235 ] unit-test
 236
 237 ! Don't insert reload if first usage is a def
 238 {
 239     T{ live-interval-state
 240        { vreg 5 }
 241        { reg-class float-regs }
 242        { start 0 }
 243        { end 1 }
 244        { uses V{ T{ vreg-use f 0 float-rep f } } }
 245        { ranges V{ T{ live-range f 0 1 } } }
 246        { spill-to T{ spill-slot f 16 } }
 247        { spill-rep float-rep }
 248     }
 249     T{ live-interval-state
 250        { vreg 5 }
 251        { reg-class float-regs }
 252        { start 20 }
 253        { end 30 }
 254        { uses V{ T{ vreg-use f 20 float-rep f } T{ vreg-use f 30 f float-rep } } }
 255        { ranges V{ T{ live-range f 20 30 } } }
 256     }
 257 } [
 258     T{ live-interval-state
 259        { vreg 5 }
 260        { reg-class float-regs }
 261        { start 0 }
 262        { end 30 }
 263        { uses V{ T{ vreg-use f 0 float-rep f } T{ vreg-use f 20 float-rep f } T{ vreg-use f 30 f float-rep } } }
 264        { ranges V{ T{ live-range f 0 8 } T{ live-range f 10 18 } T{ live-range f 20 30 } } }
 265     } 10 split-for-spill
 266     clean-up-split
 267 ] unit-test
 268
 269 ! Multiple representations
 270 {
 271     T{ live-interval-state
 272        { vreg 6 }
 273        { reg-class float-regs }
 274        { start 0 }
 275        { end 11 }
 276        { uses V{ T{ vreg-use f 0 float-rep f } T{ vreg-use f 10 double-rep float-rep } } }
 277        { ranges V{ T{ live-range f 0 11 } } }
 278        { spill-to T{ spill-slot f 24 } }
 279        { spill-rep double-rep }
 280     }
 281     T{ live-interval-state
 282        { vreg 6 }
 283        { reg-class float-regs }
 284        { start 20 }
 285        { end 20 }
 286        { uses V{ T{ vreg-use f 20 f double-rep } } }
 287        { ranges V{ T{ live-range f 20 20 } } }
 288        { reload-from T{ spill-slot f 24 } }
 289        { reload-rep double-rep }
 290     }
 291 } [
 292     T{ live-interval-state
 293        { vreg 6 }
 294        { reg-class float-regs }
 295        { start 0 }
 296        { end 20 }
 297        { uses V{ T{ vreg-use f 0 float-rep f } T{ vreg-use f 10 double-rep float-rep } T{ vreg-use f 20 f double-rep } } }
 298        { ranges V{ T{ live-range f 0 20 } } }
 299     } 15 split-for-spill
 300     clean-up-split
 301 ] unit-test
 302
 303 {
 304     f
 305     T{ live-interval-state
 306         { vreg 7 }
 307         { start 8 }
 308         { end 8 }
 309         { ranges V{ T{ live-range f 8 8 } } }
 310         { uses V{ T{ vreg-use f 8 int-rep } } }
 311         { reg-class int-regs }
 312     }
 313 } [
 314     T{ live-interval-state
 315         { vreg 7 }
 316         { start 4 }
 317         { end 8 }
 318         { ranges V{ T{ live-range f 4 8 } } }
 319         { uses V{ T{ vreg-use f 8 int-rep } } }
 320         { reg-class int-regs }
 321     } 4 split-for-spill
 322     clean-up-split
 323 ] unit-test
 324
 325 ! trim-before-ranges, trim-after-ranges
 326 {
 327     T{ live-interval-state
 328         { vreg 8 }
 329         { start 0 }
 330         { end 3 }
 331         { ranges V{ T{ live-range f 0 3 } } }
 332         { uses V{ T{ vreg-use f 0 f int-rep } T{ vreg-use f 2 f int-rep } } }
 333         { reg-class int-regs }
 334         { spill-to T{ spill-slot f 32 } }
 335         { spill-rep int-rep }
 336     }
 337     T{ live-interval-state
 338         { vreg 8 }
 339         { start 14 }
 340         { end 16 }
 341         { ranges V{ T{ live-range f 14 16 } } }
 342         { uses V{ T{ vreg-use f 14 f int-rep } } }
 343         { reg-class int-regs }
 344         { reload-from T{ spill-slot f 32 } }
 345         { reload-rep int-rep }
 346     }
 347 } [
 348     T{ live-interval-state
 349         { vreg 8 }
 350         { start 0 }
 351         { end 16 }
 352         { ranges V{ T{ live-range f 0 4 } T{ live-range f 6 10 } T{ live-range f 12 16 } } }
 353         { uses V{ T{ vreg-use f 0 f int-rep } T{ vreg-use f 2 f int-rep } T{ vreg-use f 14 f int-rep } } }
 354         { reg-class int-regs }
 355     } 8 split-for-spill
 356     clean-up-split
 357 ] unit-test
 358
 359 H{
 360     { 1 int-rep }
 361     { 2 int-rep }
 362     { 3 int-rep }
 363 } representations set
 364
 365 {
 366     {
 367         3
 368         10
 369     }
 370 } [
 371     H{
 372         { int-regs
 373           V{
 374               T{ live-interval-state
 375                  { vreg 1 }
 376                  { reg-class int-regs }
 377                  { reg 1 }
 378                  { start 1 }
 379                  { end 15 }
 380                  { uses V{ T{ vreg-use f 1 int-rep f } T{ vreg-use f 3 f int-rep } T{ vreg-use f 7 f int-rep } T{ vreg-use f 10 f int-rep } T{ vreg-use f 15 f int-rep } } }
 381               }
 382               T{ live-interval-state
 383                  { vreg 2 }
 384                  { reg-class int-regs }
 385                  { reg 2 }
 386                  { start 3 }
 387                  { end 8 }
 388                  { uses V{ T{ vreg-use f 3 int-rep f } T{ vreg-use f 4 f int-rep } T{ vreg-use f 8 f int-rep } } }
 389               }
 390               T{ live-interval-state
 391                  { vreg 3 }
 392                  { reg-class int-regs }
 393                  { reg 3 }
 394                  { start 3 }
 395                  { end 10 }
 396                  { uses V{ T{ vreg-use f 3 int-rep f } T{ vreg-use f 10 f int-rep } } }
 397               }
 398           }
 399         }
 400     } active-intervals set
 401     H{ } inactive-intervals set
 402     T{ live-interval-state
 403         { vreg 1 }
 404         { reg-class int-regs }
 405         { start 5 }
 406         { end 5 }
 407         { uses V{ T{ vreg-use f 5 int-rep f } } }
 408     }
 409     spill-status
 410 ] unit-test
 411
 412 {
 413     {
 414         1
 415         1/0.
 416     }
 417 } [
 418     H{
 419         { int-regs
 420           V{
 421               T{ live-interval-state
 422                  { vreg 1 }
 423                  { reg-class int-regs }
 424                  { reg 1 }
 425                  { start 1 }
 426                  { end 15 }
 427                  { uses V{ T{ vreg-use f 1 int-rep f } } }
 428               }
 429               T{ live-interval-state
 430                  { vreg 2 }
 431                  { reg-class int-regs }
 432                  { reg 2 }
 433                  { start 3 }
 434                  { end 8 }
 435                  { uses V{ T{ vreg-use f 3 int-rep f } T{ vreg-use f 8 f int-rep } } }
 436               }
 437           }
 438         }
 439     } active-intervals set
 440     H{ } inactive-intervals set
 441     T{ live-interval-state
 442         { vreg 3 }
 443         { reg-class int-regs }
 444         { start 5 }
 445         { end 5 }
 446         { uses V{ T{ vreg-use f 5 int-rep f } } }
 447     }
 448     spill-status
 449 ] unit-test
 450
 451 H{ { 1 int-rep } { 2 int-rep } } representations set
 452
 453 { } [
 454     {
 455         T{ live-interval-state
 456            { vreg 1 }
 457            { reg-class int-regs }
 458            { start 0 }
 459            { end 100 }
 460            { uses V{ T{ vreg-use f 0 int-rep f } T{ vreg-use f 100 f int-rep } } }
 461            { ranges V{ T{ live-range f 0 100 } } }
 462         }
 463     }
 464     H{ { int-regs { "A" } } }
 465     check-linear-scan
 466 ] unit-test
 467
 468 { } [
 469     {
 470         T{ live-interval-state
 471            { vreg 1 }
 472            { reg-class int-regs }
 473            { start 0 }
 474            { end 10 }
 475            { uses V{ T{ vreg-use f 0 int-rep f } T{ vreg-use f 10 f int-rep } } }
 476            { ranges V{ T{ live-range f 0 10 } } }
 477         }
 478         T{ live-interval-state
 479            { vreg 2 }
 480            { reg-class int-regs }
 481            { start 11 }
 482            { end 20 }
 483            { uses V{ T{ vreg-use f 11 int-rep f } T{ vreg-use f 20 f int-rep } } }
 484            { ranges V{ T{ live-range f 11 20 } } }
 485         }
 486     }
 487     H{ { int-regs { "A" } } }
 488     check-linear-scan
 489 ] unit-test
 490
 491 { } [
 492     {
 493         T{ live-interval-state
 494            { vreg 1 }
 495            { reg-class int-regs }
 496            { start 0 }
 497            { end 100 }
 498            { uses V{ T{ vreg-use f 0 int-rep f } T{ vreg-use f 100 f int-rep } } }
 499            { ranges V{ T{ live-range f 0 100 } } }
 500         }
 501         T{ live-interval-state
 502            { vreg 2 }
 503            { reg-class int-regs }
 504            { start 30 }
 505            { end 60 }
 506            { uses V{ T{ vreg-use f 30 int-rep f } T{ vreg-use f 60 f int-rep } } }
 507            { ranges V{ T{ live-range f 30 60 } } }
 508         }
 509     }
 510     H{ { int-regs { "A" } } }
 511     check-linear-scan
 512 ] unit-test
 513
 514 { } [
 515     {
 516         T{ live-interval-state
 517            { vreg 1 }
 518            { reg-class int-regs }
 519            { start 0 }
 520            { end 100 }
 521            { uses V{ T{ vreg-use f 0 int-rep f } T{ vreg-use f 100 f int-rep } } }
 522            { ranges V{ T{ live-range f 0 100 } } }
 523         }
 524         T{ live-interval-state
 525            { vreg 2 }
 526            { reg-class int-regs }
 527            { start 30 }
 528            { end 200 }
 529            { uses V{ T{ vreg-use f 30 int-rep f } T{ vreg-use f 200 f int-rep } } }
 530            { ranges V{ T{ live-range f 30 200 } } }
 531         }
 532     }
 533     H{ { int-regs { "A" } } }
 534     check-linear-scan
 535 ] unit-test
 536
 537 [
 538     {
 539         T{ live-interval-state
 540            { vreg 1 }
 541            { reg-class int-regs }
 542            { start 0 }
 543            { end 100 }
 544            { uses V{ T{ vreg-use f 0 int-rep f } T{ vreg-use f 100 f int-rep } } }
 545            { ranges V{ T{ live-range f 0 100 } } }
 546         }
 547         T{ live-interval-state
 548            { vreg 2 }
 549            { reg-class int-regs }
 550            { start 30 }
 551            { end 100 }
 552            { uses V{ T{ vreg-use f 30 int-rep f } T{ vreg-use f 100 f int-rep } } }
 553            { ranges V{ T{ live-range f 30 100 } } }
 554         }
 555     }
 556     H{ { int-regs { "A" } } }
 557     check-linear-scan
 558 ] must-fail
 559
 560 ! Problem with spilling intervals with no more usages after the spill location
 561 H{
 562     { 1 int-rep }
 563     { 2 int-rep }
 564     { 3 int-rep }
 565     { 4 int-rep }
 566     { 5 int-rep }
 567 } representations set
 568
 569 { } [
 570     {
 571         T{ live-interval-state
 572            { vreg 1 }
 573            { reg-class int-regs }
 574            { start 0 }
 575            { end 20 }
 576            { uses V{ T{ vreg-use f 0 int-rep f } T{ vreg-use f 10 f int-rep } T{ vreg-use f 20 f int-rep } } }
 577            { ranges V{ T{ live-range f 0 2 } T{ live-range f 10 20 } } }
 578         }
 579         T{ live-interval-state
 580            { vreg 2 }
 581            { reg-class int-regs }
 582            { start 0 }
 583            { end 20 }
 584            { uses V{ T{ vreg-use f 0 int-rep f } T{ vreg-use f 10 f int-rep } T{ vreg-use f 20 f int-rep } } }
 585            { ranges V{ T{ live-range f 0 2 } T{ live-range f 10 20 } } }
 586         }
 587         T{ live-interval-state
 588            { vreg 3 }
 589            { reg-class int-regs }
 590            { start 4 }
 591            { end 8 }
 592            { uses V{ T{ vreg-use f 6 int-rep f } } }
 593            { ranges V{ T{ live-range f 4 8 } } }
 594         }
 595         T{ live-interval-state
 596            { vreg 4 }
 597            { reg-class int-regs }
 598            { start 4 }
 599            { end 8 }
 600            { uses V{ T{ vreg-use f 8 int-rep f } } }
 601            { ranges V{ T{ live-range f 4 8 } } }
 602         }
 603
 604         ! This guy will invoke the 'spill partially available' code path
 605         T{ live-interval-state
 606            { vreg 5 }
 607            { reg-class int-regs }
 608            { start 4 }
 609            { end 8 }
 610            { uses V{ T{ vreg-use f 8 int-rep f } } }
 611            { ranges V{ T{ live-range f 4 8 } } }
 612         }
 613     }
 614     H{ { int-regs { "A" "B" } } }
 615     check-linear-scan
 616 ] unit-test
 617
 618 ! Test spill-new code path
 619
 620 { } [
 621     {
 622         T{ live-interval-state
 623            { vreg 1 }
 624            { reg-class int-regs }
 625            { start 0 }
 626            { end 10 }
 627            { uses V{ T{ vreg-use f 0 int-rep f } T{ vreg-use f 6 f int-rep } T{ vreg-use f 10 f int-rep } } }
 628            { ranges V{ T{ live-range f 0 10 } } }
 629         }
 630
 631         ! This guy will invoke the 'spill new' code path
 632         T{ live-interval-state
 633            { vreg 5 }
 634            { reg-class int-regs }
 635            { start 2 }
 636            { end 8 }
 637            { uses V{ T{ vreg-use f 8 int-rep f } } }
 638            { ranges V{ T{ live-range f 2 8 } } }
 639         }
 640     }
 641     H{ { int-regs { "A" } } }
 642     check-linear-scan
 643 ] unit-test
 644
 645 { f } [
 646     T{ live-range f 0 10 }
 647     T{ live-range f 20 30 }
 648     intersect-live-range
 649 ] unit-test
 650
 651 { 10 } [
 652     T{ live-range f 0 10 }
 653     T{ live-range f 10 30 }
 654     intersect-live-range
 655 ] unit-test
 656
 657 { 5 } [
 658     T{ live-range f 0 10 }
 659     T{ live-range f 5 30 }
 660     intersect-live-range
 661 ] unit-test
 662
 663 { 5 } [
 664     T{ live-range f 5 30 }
 665     T{ live-range f 0 10 }
 666     intersect-live-range
 667 ] unit-test
 668
 669 { 5 } [
 670     T{ live-range f 5 10 }
 671     T{ live-range f 0 15 }
 672     intersect-live-range
 673 ] unit-test
 674
 675 { 50 } [
 676     {
 677         T{ live-range f 0 10 }
 678         T{ live-range f 20 30 }
 679         T{ live-range f 40 50 }
 680     }
 681     {
 682         T{ live-range f 11 15 }
 683         T{ live-range f 31 35 }
 684         T{ live-range f 50 55 }
 685     }
 686     intersect-live-ranges
 687 ] unit-test
 688
 689 { f } [
 690     {
 691         T{ live-range f 0 10 }
 692         T{ live-range f 20 30 }
 693         T{ live-range f 40 50 }
 694     }
 695     {
 696         T{ live-range f 11 15 }
 697         T{ live-range f 31 36 }
 698         T{ live-range f 51 55 }
 699     }
 700     intersect-live-ranges
 701 ] unit-test
 702
 703 { 5 } [
 704     T{ live-interval-state
 705        { start 0 }
 706        { reg-class int-regs }
 707        { end 10 }
 708        { uses { 0 10 } }
 709        { ranges V{ T{ live-range f 0 10 } } }
 710     }
 711     T{ live-interval-state
 712        { start 5 }
 713        { reg-class int-regs }
 714        { end 10 }
 715        { uses { 5 10 } }
 716        { ranges V{ T{ live-range f 5 10 } } }
 717     }
 718     relevant-ranges intersect-live-ranges
 719 ] unit-test
 720
 721 ! register-status had problems because it used map>assoc where the sequence
 722 ! had multiple keys
 723 H{
 724     { 1 int-rep }
 725     { 2 int-rep }
 726     { 3 int-rep }
 727     { 4 int-rep }
 728 } representations set
 729
 730 { { 0 10 } } [
 731     H{
 732         { int-regs
 733           {
 734               T{ live-interval-state
 735                  { vreg 1 }
 736                  { reg-class int-regs }
 737                  { start 0 }
 738                  { end 20 }
 739                  { reg 0 }
 740                  { ranges V{ T{ live-range f 0 2 } T{ live-range f 10 20 } } }
 741                  { uses V{ 0 2 10 20 } }
 742               }
 743
 744               T{ live-interval-state
 745                  { vreg 2 }
 746                  { reg-class int-regs }
 747                  { start 4 }
 748                  { end 40 }
 749                  { reg 0 }
 750                  { ranges V{ T{ live-range f 4 6 } T{ live-range f 30 40 } } }
 751                  { uses V{ 4 6 30 40 } }
 752               }
 753           }
 754         }
 755     } inactive-intervals set
 756     H{
 757         { int-regs
 758           {
 759               T{ live-interval-state
 760                  { vreg 3 }
 761                  { reg-class int-regs }
 762                  { start 0 }
 763                  { end 40 }
 764                  { reg 1 }
 765                  { ranges V{ T{ live-range f 0 40 } } }
 766                  { uses V{ 0 40 } }
 767               }
 768           }
 769         }
 770     } active-intervals set
 771
 772     T{ live-interval-state
 773         { vreg 4 }
 774         { reg-class int-regs }
 775         { start 8 }
 776         { end 10 }
 777         { ranges V{ T{ live-range f 8 10 } } }
 778         { uses V{ T{ vreg-use f 8 int-rep f } T{ vreg-use f 10 f int-rep } } }
 779     }
 780     H{ { int-regs { 0 1 } } } register-status
 781 ] unit-test
 782
 783 { t } [
 784     T{ cfg { frame-pointer? f } } admissible-registers machine-registers =
 785 ] unit-test
 786
 787 { f } [
 788     T{ cfg { frame-pointer? t } } admissible-registers
 789     int-regs of frame-reg swap member?
 790 ] unit-test