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