compiler/nativeGen/X86/Regs.hs

   1 module X86.Regs (
   2         -- squeese functions for the graph allocator
   3         virtualRegSqueeze,
   4         realRegSqueeze,
   5
   6         -- immediates
   7         Imm(..),
   8         strImmLit,
   9         litToImm,
  10
  11         -- addressing modes
  12         AddrMode(..),
  13         addrOffset,
  14
  15         -- registers
  16         spRel,
  17         argRegs,
  18         allArgRegs,
  19         callClobberedRegs,
  20         allMachRegNos,
  21         classOfRealReg,
  22         showReg,
  23
  24         -- machine specific
  25         EABase(..), EAIndex(..), addrModeRegs,
  26
  27         eax, ebx, ecx, edx, esi, edi, ebp, esp,
  28         fake0, fake1, fake2, fake3, fake4, fake5, firstfake,
  29
  30         rax, rbx, rcx, rdx, rsi, rdi, rbp, rsp,
  31         r8,  r9,  r10, r11, r12, r13, r14, r15,
  32         xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7,
  33         xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15,
  34         xmm,
  35
  36         ripRel,
  37         allFPArgRegs,
  38
  39         -- horror show
  40         freeReg,
  41         globalRegMaybe,
  42
  43         get_GlobalReg_reg_or_addr,
  44         allocatableRegs
  45 )
  46
  47 where
  48
  49 #include "nativeGen/NCG.h"
  50 #include "HsVersions.h"
  51
  52 #include "../includes/stg/MachRegs.h"
  53
  54 import Reg
  55 import RegClass
  56
  57 import CgUtils          ( get_GlobalReg_addr )
  58 import BlockId
  59 import Cmm
  60 import CLabel           ( CLabel )
  61 import Pretty
  62 import Outputable       ( panic )
  63 import FastTypes
  64 import FastBool
  65
  66
  67 #if  defined(i386_TARGET_ARCH) || defined(x86_64_TARGET_ARCH)
  68 import Constants
  69 #endif
  70
  71
  72 -- | regSqueeze_class reg
  73 --      Calculuate the maximum number of register colors that could be
  74 --      denied to a node of this class due to having this reg
  75 --      as a neighbour.
  76 --
  77 {-# INLINE virtualRegSqueeze #-}
  78 virtualRegSqueeze :: RegClass -> VirtualReg -> FastInt
  79
  80 virtualRegSqueeze cls vr
  81  = case cls of
  82         RcInteger
  83          -> case vr of
  84                 VirtualRegI{}           -> _ILIT(1)
  85                 VirtualRegHi{}          -> _ILIT(1)
  86                 _other                  -> _ILIT(0)
  87
  88         RcDouble
  89          -> case vr of
  90                 VirtualRegD{}           -> _ILIT(1)
  91                 VirtualRegF{}           -> _ILIT(0)
  92                 _other                  -> _ILIT(0)
  93
  94         RcDoubleSSE
  95          -> case vr of
  96                 VirtualRegSSE{}         -> _ILIT(1)
  97                 _other                  -> _ILIT(0)
  98
  99         _other -> _ILIT(0)
 100
 101 {-# INLINE realRegSqueeze #-}
 102 realRegSqueeze :: RegClass -> RealReg -> FastInt
 103 realRegSqueeze cls rr
 104  = case cls of
 105         RcInteger
 106          -> case rr of
 107                 RealRegSingle regNo
 108                         | regNo < firstfake -> _ILIT(1)
 109                         | otherwise     -> _ILIT(0)
 110
 111                 RealRegPair{}           -> _ILIT(0)
 112
 113         RcDouble
 114          -> case rr of
 115                 RealRegSingle regNo
 116                         | regNo >= firstfake && regNo < lastfake -> _ILIT(1)
 117                         | otherwise     -> _ILIT(0)
 118
 119                 RealRegPair{}           -> _ILIT(0)
 120
 121         RcDoubleSSE
 122          -> case rr of
 123                 RealRegSingle regNo | regNo >= firstxmm -> _ILIT(1)
 124                 _otherwise                        -> _ILIT(0)
 125
 126         _other -> _ILIT(0)
 127
 128 -- -----------------------------------------------------------------------------
 129 -- Immediates
 130
 131 data Imm
 132   = ImmInt      Int
 133   | ImmInteger  Integer     -- Sigh.
 134   | ImmCLbl     CLabel      -- AbstractC Label (with baggage)
 135   | ImmLit      Doc         -- Simple string
 136   | ImmIndex    CLabel Int
 137   | ImmFloat    Rational
 138   | ImmDouble   Rational
 139   | ImmConstantSum Imm Imm
 140   | ImmConstantDiff Imm Imm
 141
 142
 143 strImmLit :: String -> Imm
 144 strImmLit s = ImmLit (text s)
 145
 146
 147 litToImm :: CmmLit -> Imm
 148 litToImm (CmmInt i w)        = ImmInteger (narrowS w i)
 149                 -- narrow to the width: a CmmInt might be out of
 150                 -- range, but we assume that ImmInteger only contains
 151                 -- in-range values.  A signed value should be fine here.
 152 litToImm (CmmFloat f W32)    = ImmFloat f
 153 litToImm (CmmFloat f W64)    = ImmDouble f
 154 litToImm (CmmLabel l)        = ImmCLbl l
 155 litToImm (CmmLabelOff l off) = ImmIndex l off
 156 litToImm (CmmLabelDiffOff l1 l2 off)
 157                              = ImmConstantSum
 158                                (ImmConstantDiff (ImmCLbl l1) (ImmCLbl l2))
 159                                (ImmInt off)
 160 litToImm (CmmBlock id)       = ImmCLbl (infoTblLbl id)
 161 litToImm _                   = panic "X86.Regs.litToImm: no match"
 162
 163 -- addressing modes ------------------------------------------------------------
 164
 165 data AddrMode
 166         = AddrBaseIndex EABase EAIndex Displacement
 167         | ImmAddr Imm Int
 168
 169 data EABase       = EABaseNone  | EABaseReg Reg | EABaseRip
 170 data EAIndex      = EAIndexNone | EAIndex Reg Int
 171 type Displacement = Imm
 172
 173
 174 addrOffset :: AddrMode -> Int -> Maybe AddrMode
 175 addrOffset addr off
 176   = case addr of
 177       ImmAddr i off0      -> Just (ImmAddr i (off0 + off))
 178
 179       AddrBaseIndex r i (ImmInt n) -> Just (AddrBaseIndex r i (ImmInt (n + off)))
 180       AddrBaseIndex r i (ImmInteger n)
 181         -> Just (AddrBaseIndex r i (ImmInt (fromInteger (n + toInteger off))))
 182
 183       AddrBaseIndex r i (ImmCLbl lbl)
 184         -> Just (AddrBaseIndex r i (ImmIndex lbl off))
 185
 186       AddrBaseIndex r i (ImmIndex lbl ix)
 187         -> Just (AddrBaseIndex r i (ImmIndex lbl (ix+off)))
 188
 189       _ -> Nothing  -- in theory, shouldn't happen
 190
 191
 192 addrModeRegs :: AddrMode -> [Reg]
 193 addrModeRegs (AddrBaseIndex b i _) =  b_regs ++ i_regs
 194   where
 195    b_regs = case b of { EABaseReg r -> [r]; _ -> [] }
 196    i_regs = case i of { EAIndex r _ -> [r]; _ -> [] }
 197 addrModeRegs _ = []
 198
 199
 200 -- registers -------------------------------------------------------------------
 201
 202 -- @spRel@ gives us a stack relative addressing mode for volatile
 203 -- temporaries and for excess call arguments.  @fpRel@, where
 204 -- applicable, is the same but for the frame pointer.
 205
 206
 207 spRel :: Int            -- ^ desired stack offset in words, positive or negative
 208       -> AddrMode
 209
 210 #if   i386_TARGET_ARCH
 211 spRel n = AddrBaseIndex (EABaseReg esp) EAIndexNone (ImmInt (n * wORD_SIZE))
 212
 213 #elif x86_64_TARGET_ARCH
 214 spRel n = AddrBaseIndex (EABaseReg rsp) EAIndexNone (ImmInt (n * wORD_SIZE))
 215
 216 #else
 217 spRel _ = panic "X86.Regs.spRel: not defined for this architecture"
 218
 219 #endif
 220
 221 -- The register numbers must fit into 32 bits on x86, so that we can
 222 -- use a Word32 to represent the set of free registers in the register
 223 -- allocator.
 224
 225 firstfake, lastfake :: RegNo
 226 firstfake = 16
 227 lastfake  = 21
 228
 229 firstxmm, lastxmm :: RegNo
 230 firstxmm  = 24
 231 #if i386_TARGET_ARCH
 232 lastxmm   = 31
 233 #else
 234 lastxmm   = 39
 235 #endif
 236
 237 lastint :: RegNo
 238 #if i386_TARGET_ARCH
 239 lastint = 7 -- not %r8..%r15
 240 #else
 241 lastint = 15
 242 #endif
 243
 244 intregnos, fakeregnos, xmmregnos, floatregnos :: [RegNo]
 245 intregnos   = [0..lastint]
 246 fakeregnos  = [firstfake .. lastfake]
 247 xmmregnos   = [firstxmm  .. lastxmm]
 248 floatregnos = fakeregnos ++ xmmregnos;
 249
 250
 251 -- argRegs is the set of regs which are read for an n-argument call to C.
 252 -- For archs which pass all args on the stack (x86), is empty.
 253 -- Sparc passes up to the first 6 args in regs.
 254 -- Dunno about Alpha.
 255 argRegs :: RegNo -> [Reg]
 256 argRegs _       = panic "MachRegs.argRegs(x86): should not be used!"
 257
 258 -- | The complete set of machine registers.
 259 allMachRegNos :: [RegNo]
 260 allMachRegNos  = intregnos ++ floatregnos
 261
 262 -- | Take the class of a register.
 263 {-# INLINE classOfRealReg      #-}
 264 classOfRealReg :: RealReg -> RegClass
 265 -- On x86, we might want to have an 8-bit RegClass, which would
 266 -- contain just regs 1-4 (the others don't have 8-bit versions).
 267 -- However, we can get away without this at the moment because the
 268 -- only allocatable integer regs are also 8-bit compatible (1, 3, 4).
 269 classOfRealReg reg
 270  = case reg of
 271         RealRegSingle i
 272           | i <= lastint  -> RcInteger
 273           | i <= lastfake -> RcDouble
 274           | otherwise     -> RcDoubleSSE
 275
 276         RealRegPair{}   -> panic "X86.Regs.classOfRealReg: RegPairs on this arch"
 277
 278 -- | Get the name of the register with this number.
 279 showReg :: RegNo -> String
 280 showReg n
 281         | n >= firstxmm  = "%xmm" ++ show (n-firstxmm)
 282         | n >= firstfake = "%fake" ++ show (n-firstfake)
 283         | n >= 8         = "%r" ++ show n
 284         | otherwise      = regNames !! n
 285
 286 regNames :: [String]
 287 regNames
 288 #if   i386_TARGET_ARCH
 289    = ["%eax", "%ebx", "%ecx", "%edx", "%esi", "%edi", "%ebp", "%esp"]
 290 #elif x86_64_TARGET_ARCH
 291    = ["%rax", "%rbx", "%rcx", "%rdx", "%rsi", "%rdi", "%rbp", "%rsp" ]
 292 #else
 293    = []
 294 #endif
 295
 296
 297
 298 -- machine specific ------------------------------------------------------------
 299
 300
 301 {-
 302 Intel x86 architecture:
 303 - All registers except 7 (esp) are available for use.
 304 - Only ebx, esi, edi and esp are available across a C call (they are callee-saves).
 305 - Registers 0-7 have 16-bit counterparts (ax, bx etc.)
 306 - Registers 0-3 have 8 bit counterparts (ah, bh etc.)
 307 - Registers fake0..fake5 are fakes; we pretend x86 has 6 conventionally-addressable
 308   fp registers, and 3-operand insns for them, and we translate this into
 309   real stack-based x86 fp code after register allocation.
 310
 311 The fp registers are all Double registers; we don't have any RcFloat class
 312 regs.  @regClass@ barfs if you give it a VirtualRegF, and mkVReg above should
 313 never generate them.
 314 -}
 315
 316 fake0, fake1, fake2, fake3, fake4, fake5,
 317        eax, ebx, ecx, edx, esp, ebp, esi, edi :: Reg
 318
 319 eax   = regSingle 0
 320 ebx   = regSingle 1
 321 ecx   = regSingle 2
 322 edx   = regSingle 3
 323 esi   = regSingle 4
 324 edi   = regSingle 5
 325 ebp   = regSingle 6
 326 esp   = regSingle 7
 327 fake0 = regSingle 16
 328 fake1 = regSingle 17
 329 fake2 = regSingle 18
 330 fake3 = regSingle 19
 331 fake4 = regSingle 20
 332 fake5 = regSingle 21
 333
 334
 335
 336 {-
 337 AMD x86_64 architecture:
 338 - Registers 0-16 have 32-bit counterparts (eax, ebx etc.)
 339 - Registers 0-7 have 16-bit counterparts (ax, bx etc.)
 340 - Registers 0-3 have 8 bit counterparts (ah, bh etc.)
 341
 342 -}
 343
 344 rax, rbx, rcx, rdx, rsp, rbp, rsi, rdi,
 345   r8, r9, r10, r11, r12, r13, r14, r15,
 346   xmm0, xmm1, xmm2, xmm3, xmm4, xmm5, xmm6, xmm7,
 347   xmm8, xmm9, xmm10, xmm11, xmm12, xmm13, xmm14, xmm15 :: Reg
 348
 349 rax   = regSingle 0
 350 rbx   = regSingle 1
 351 rcx   = regSingle 2
 352 rdx   = regSingle 3
 353 rsi   = regSingle 4
 354 rdi   = regSingle 5
 355 rbp   = regSingle 6
 356 rsp   = regSingle 7
 357 r8    = regSingle 8
 358 r9    = regSingle 9
 359 r10   = regSingle 10
 360 r11   = regSingle 11
 361 r12   = regSingle 12
 362 r13   = regSingle 13
 363 r14   = regSingle 14
 364 r15   = regSingle 15
 365 xmm0  = regSingle 24
 366 xmm1  = regSingle 25
 367 xmm2  = regSingle 26
 368 xmm3  = regSingle 27
 369 xmm4  = regSingle 28
 370 xmm5  = regSingle 29
 371 xmm6  = regSingle 30
 372 xmm7  = regSingle 31
 373 xmm8  = regSingle 32
 374 xmm9  = regSingle 33
 375 xmm10 = regSingle 34
 376 xmm11 = regSingle 35
 377 xmm12 = regSingle 36
 378 xmm13 = regSingle 37
 379 xmm14 = regSingle 38
 380 xmm15 = regSingle 39
 381
 382 allFPArgRegs :: [Reg]
 383 allFPArgRegs    = map regSingle [firstxmm .. firstxmm+7]
 384
 385 ripRel :: Displacement -> AddrMode
 386 ripRel imm      = AddrBaseIndex EABaseRip EAIndexNone imm
 387
 388
 389  -- so we can re-use some x86 code:
 390 {-
 391 eax = rax
 392 ebx = rbx
 393 ecx = rcx
 394 edx = rdx
 395 esi = rsi
 396 edi = rdi
 397 ebp = rbp
 398 esp = rsp
 399 -}
 400
 401 xmm :: RegNo -> Reg
 402 xmm n = regSingle (firstxmm+n)
 403
 404
 405
 406
 407 -- horror show -----------------------------------------------------------------
 408 freeReg                 :: RegNo -> FastBool
 409 globalRegMaybe          :: GlobalReg -> Maybe RealReg
 410 allArgRegs              :: [Reg]
 411 callClobberedRegs       :: [Reg]
 412
 413 #if defined(i386_TARGET_ARCH) || defined(x86_64_TARGET_ARCH)
 414
 415 #if i386_TARGET_ARCH
 416 #define eax 0
 417 #define ebx 1
 418 #define ecx 2
 419 #define edx 3
 420 #define esi 4
 421 #define edi 5
 422 #define ebp 6
 423 #define esp 7
 424 #endif
 425
 426 #if x86_64_TARGET_ARCH
 427 #define rax   0
 428 #define rbx   1
 429 #define rcx   2
 430 #define rdx   3
 431 #define rsi   4
 432 #define rdi   5
 433 #define rbp   6
 434 #define rsp   7
 435 #define r8    8
 436 #define r9    9
 437 #define r10   10
 438 #define r11   11
 439 #define r12   12
 440 #define r13   13
 441 #define r14   14
 442 #define r15   15
 443 #endif
 444
 445 #define fake0 16
 446 #define fake1 17
 447 #define fake2 18
 448 #define fake3 19
 449 #define fake4 20
 450 #define fake5 21
 451
 452 #define xmm0  24
 453 #define xmm1  25
 454 #define xmm2  26
 455 #define xmm3  27
 456 #define xmm4  28
 457 #define xmm5  29
 458 #define xmm6  30
 459 #define xmm7  31
 460 #define xmm8  32
 461 #define xmm9  33
 462 #define xmm10 34
 463 #define xmm11 35
 464 #define xmm12 36
 465 #define xmm13 37
 466 #define xmm14 38
 467 #define xmm15 39
 468
 469 #if i386_TARGET_ARCH
 470 freeReg esp = fastBool False  --        %esp is the C stack pointer
 471 #endif
 472
 473 #if x86_64_TARGET_ARCH
 474 freeReg rsp = fastBool False  --        %rsp is the C stack pointer
 475 #endif
 476
 477 #ifdef REG_Base
 478 freeReg REG_Base = fastBool False
 479 #endif
 480 #ifdef REG_R1
 481 freeReg REG_R1   = fastBool False
 482 #endif
 483 #ifdef REG_R2
 484 freeReg REG_R2   = fastBool False
 485 #endif
 486 #ifdef REG_R3
 487 freeReg REG_R3   = fastBool False
 488 #endif
 489 #ifdef REG_R4
 490 freeReg REG_R4   = fastBool False
 491 #endif
 492 #ifdef REG_R5
 493 freeReg REG_R5   = fastBool False
 494 #endif
 495 #ifdef REG_R6
 496 freeReg REG_R6   = fastBool False
 497 #endif
 498 #ifdef REG_R7
 499 freeReg REG_R7   = fastBool False
 500 #endif
 501 #ifdef REG_R8
 502 freeReg REG_R8   = fastBool False
 503 #endif
 504 #ifdef REG_F1
 505 freeReg REG_F1 = fastBool False
 506 #endif
 507 #ifdef REG_F2
 508 freeReg REG_F2 = fastBool False
 509 #endif
 510 #ifdef REG_F3
 511 freeReg REG_F3 = fastBool False
 512 #endif
 513 #ifdef REG_F4
 514 freeReg REG_F4 = fastBool False
 515 #endif
 516 #ifdef REG_D1
 517 freeReg REG_D1 = fastBool False
 518 #endif
 519 #ifdef REG_D2
 520 freeReg REG_D2 = fastBool False
 521 #endif
 522 #ifdef REG_Sp
 523 freeReg REG_Sp   = fastBool False
 524 #endif
 525 #ifdef REG_Su
 526 freeReg REG_Su   = fastBool False
 527 #endif
 528 #ifdef REG_SpLim
 529 freeReg REG_SpLim = fastBool False
 530 #endif
 531 #ifdef REG_Hp
 532 freeReg REG_Hp   = fastBool False
 533 #endif
 534 #ifdef REG_HpLim
 535 freeReg REG_HpLim = fastBool False
 536 #endif
 537 freeReg _               = fastBool True
 538
 539
 540 --  | Returns 'Nothing' if this global register is not stored
 541 -- in a real machine register, otherwise returns @'Just' reg@, where
 542 -- reg is the machine register it is stored in.
 543
 544 #ifdef REG_Base
 545 globalRegMaybe BaseReg                  = Just (RealRegSingle REG_Base)
 546 #endif
 547 #ifdef REG_R1
 548 globalRegMaybe (VanillaReg 1 _)         = Just (RealRegSingle REG_R1)
 549 #endif
 550 #ifdef REG_R2
 551 globalRegMaybe (VanillaReg 2 _)         = Just (RealRegSingle REG_R2)
 552 #endif
 553 #ifdef REG_R3
 554 globalRegMaybe (VanillaReg 3 _)         = Just (RealRegSingle REG_R3)
 555 #endif
 556 #ifdef REG_R4
 557 globalRegMaybe (VanillaReg 4 _)         = Just (RealRegSingle REG_R4)
 558 #endif
 559 #ifdef REG_R5
 560 globalRegMaybe (VanillaReg 5 _)         = Just (RealRegSingle REG_R5)
 561 #endif
 562 #ifdef REG_R6
 563 globalRegMaybe (VanillaReg 6 _)         = Just (RealRegSingle REG_R6)
 564 #endif
 565 #ifdef REG_R7
 566 globalRegMaybe (VanillaReg 7 _)         = Just (RealRegSingle REG_R7)
 567 #endif
 568 #ifdef REG_R8
 569 globalRegMaybe (VanillaReg 8 _)         = Just (RealRegSingle REG_R8)
 570 #endif
 571 #ifdef REG_R9
 572 globalRegMaybe (VanillaReg 9 _)         = Just (RealRegSingle REG_R9)
 573 #endif
 574 #ifdef REG_R10
 575 globalRegMaybe (VanillaReg 10 _)        = Just (RealRegSingle REG_R10)
 576 #endif
 577 #ifdef REG_F1
 578 globalRegMaybe (FloatReg 1)             = Just (RealRegSingle REG_F1)
 579 #endif
 580 #ifdef REG_F2
 581 globalRegMaybe (FloatReg 2)             = Just (RealRegSingle REG_F2)
 582 #endif
 583 #ifdef REG_F3
 584 globalRegMaybe (FloatReg 3)             = Just (RealRegSingle REG_F3)
 585 #endif
 586 #ifdef REG_F4
 587 globalRegMaybe (FloatReg 4)             = Just (RealRegSingle REG_F4)
 588 #endif
 589 #ifdef REG_D1
 590 globalRegMaybe (DoubleReg 1)            = Just (RealRegSingle REG_D1)
 591 #endif
 592 #ifdef REG_D2
 593 globalRegMaybe (DoubleReg 2)            = Just (RealRegSingle REG_D2)
 594 #endif
 595 #ifdef REG_Sp
 596 globalRegMaybe Sp                       = Just (RealRegSingle REG_Sp)
 597 #endif
 598 #ifdef REG_Lng1
 599 globalRegMaybe (LongReg 1)              = Just (RealRegSingle REG_Lng1)
 600 #endif
 601 #ifdef REG_Lng2
 602 globalRegMaybe (LongReg 2)              = Just (RealRegSingle REG_Lng2)
 603 #endif
 604 #ifdef REG_SpLim
 605 globalRegMaybe SpLim                    = Just (RealRegSingle REG_SpLim)
 606 #endif
 607 #ifdef REG_Hp
 608 globalRegMaybe Hp                       = Just (RealRegSingle REG_Hp)
 609 #endif
 610 #ifdef REG_HpLim
 611 globalRegMaybe HpLim                    = Just (RealRegSingle REG_HpLim)
 612 #endif
 613 #ifdef REG_CurrentTSO
 614 globalRegMaybe CurrentTSO               = Just (RealRegSingle REG_CurrentTSO)
 615 #endif
 616 #ifdef REG_CurrentNursery
 617 globalRegMaybe CurrentNursery           = Just (RealRegSingle REG_CurrentNursery)
 618 #endif
 619 globalRegMaybe _                        = Nothing
 620
 621 --
 622
 623 #if   i386_TARGET_ARCH
 624 allArgRegs = panic "X86.Regs.allArgRegs: should not be used!"
 625
 626 #elif x86_64_TARGET_ARCH
 627 allArgRegs = map regSingle [rdi,rsi,rdx,rcx,r8,r9]
 628
 629 #else
 630 allArgRegs  = panic "X86.Regs.allArgRegs: not defined for this architecture"
 631 #endif
 632
 633
 634 -- | these are the regs which we cannot assume stay alive over a C call.
 635
 636 #if   i386_TARGET_ARCH
 637 -- caller-saves registers
 638 callClobberedRegs
 639   = map regSingle ([eax,ecx,edx]  ++ floatregnos)
 640
 641 #elif x86_64_TARGET_ARCH
 642 -- all xmm regs are caller-saves
 643 -- caller-saves registers
 644 callClobberedRegs
 645   = map regSingle ([rax,rcx,rdx,rsi,rdi,r8,r9,r10,r11] ++ floatregnos)
 646
 647 #else
 648 callClobberedRegs
 649   = panic "X86.Regs.callClobberedRegs: not defined for this architecture"
 650 #endif
 651
 652 #else /* i386_TARGET_ARCH || x86_64_TARGET_ARCH */
 653
 654
 655
 656 freeReg _               = 0#
 657 globalRegMaybe _        = panic "X86.Regs.globalRegMaybe: not defined"
 658
 659 allArgRegs              = panic "X86.Regs.globalRegMaybe: not defined"
 660 callClobberedRegs       = panic "X86.Regs.globalRegMaybe: not defined"
 661
 662
 663 #endif
 664
 665 -- We map STG registers onto appropriate CmmExprs.  Either they map
 666 -- to real machine registers or stored as offsets from BaseReg.  Given
 667 -- a GlobalReg, get_GlobalReg_reg_or_addr produces either the real
 668 -- register it is in, on this platform, or a CmmExpr denoting the
 669 -- address in the register table holding it.
 670 -- (See also get_GlobalReg_addr in CgUtils.)
 671
 672 get_GlobalReg_reg_or_addr :: GlobalReg -> Either RealReg CmmExpr
 673 get_GlobalReg_reg_or_addr mid
 674    = case globalRegMaybe mid of
 675         Just rr -> Left rr
 676         Nothing -> Right (get_GlobalReg_addr mid)
 677
 678
 679 -- allocatableRegs is allMachRegNos with the fixed-use regs removed.
 680 -- i.e., these are the regs for which we are prepared to allow the
 681 -- register allocator to attempt to map VRegs to.
 682 allocatableRegs :: [RealReg]
 683 allocatableRegs
 684    = let isFree i = isFastTrue (freeReg i)
 685      in  map RealRegSingle $ filter isFree allMachRegNos
 686
 687