compiler/cmm/MachOp.hs

   1 -----------------------------------------------------------------------------
   2 --
   3 -- (c) The University of Glasgow 2002-2004
   4 --
   5 -- Low-level machine operations, used in the Cmm datatype.
   6 --
   7 -----------------------------------------------------------------------------
   8
   9 module MachOp   (
  10         MachRep(..),
  11         machRepBitWidth,
  12         machRepByteWidth,
  13         machRepLogWidth,
  14         isFloatingRep,
  15
  16         MachHint(..),
  17
  18         MachOp(..),
  19         pprMachOp,
  20         isCommutableMachOp,
  21         isAssociativeMachOp,
  22         isComparisonMachOp,
  23         resultRepOfMachOp,
  24         machOpArgReps,
  25         maybeInvertComparison,
  26
  27         CallishMachOp(..),
  28         pprCallishMachOp,
  29
  30         wordRep,
  31         halfWordRep,
  32         cIntRep, cLongRep,
  33
  34         mo_wordAdd,
  35         mo_wordSub,
  36         mo_wordEq,
  37         mo_wordNe,
  38         mo_wordMul,
  39         mo_wordSQuot,
  40         mo_wordSRem,
  41         mo_wordSNeg,
  42         mo_wordUQuot,
  43         mo_wordURem,
  44
  45         mo_wordSGe,
  46         mo_wordSLe,
  47         mo_wordSGt,
  48         mo_wordSLt,
  49
  50         mo_wordUGe,
  51         mo_wordULe,
  52         mo_wordUGt,
  53         mo_wordULt,
  54
  55         mo_wordAnd,
  56         mo_wordOr,
  57         mo_wordXor,
  58         mo_wordNot,
  59         mo_wordShl,
  60         mo_wordSShr,
  61         mo_wordUShr,
  62
  63         mo_u_8To32,
  64         mo_s_8To32,
  65         mo_u_16To32,
  66         mo_s_16To32,
  67
  68         mo_u_8ToWord,
  69         mo_s_8ToWord,
  70         mo_u_16ToWord,
  71         mo_s_16ToWord,
  72         mo_u_32ToWord,
  73         mo_s_32ToWord,
  74
  75         mo_32To8,
  76         mo_32To16,
  77         mo_WordTo8,
  78         mo_WordTo16,
  79         mo_WordTo32,
  80   ) where
  81
  82 #include "HsVersions.h"
  83
  84 import Constants
  85 import Outputable
  86
  87 -- -----------------------------------------------------------------------------
  88 -- MachRep
  89
  90 {- |
  91 A MachRep is the "representation" of a value in Cmm.  It is used for
  92 resource allocation: eg. which kind of register a value should be
  93 stored in.
  94
  95 The primary requirement is that there exists a function
  96
  97   cmmExprRep :: CmmExpr -> MachRep
  98
  99 This means that:
 100
 101   - a register has an implicit MachRep
 102   - a literal has an implicit MachRep
 103   - an operation (MachOp) has an implicit result MachRep
 104
 105 It also means that we can check that the arguments to a MachOp have
 106 the correct MachRep, i.e. we can do a kind of lint-style type checking
 107 on Cmm.
 108 -}
 109
 110 data MachRep
 111   = I8
 112   | I16
 113   | I32
 114   | I64
 115   | I128
 116   | F32
 117   | F64
 118   | F80         -- extended double-precision, used in x86 native codegen only.
 119   deriving (Eq, Ord, Show)
 120
 121 mrStr I8   = SLIT("I8")
 122 mrStr I16  = SLIT("I16")
 123 mrStr I32  = SLIT("I32")
 124 mrStr I64  = SLIT("I64")
 125 mrStr I128 = SLIT("I128")
 126 mrStr F32  = SLIT("F32")
 127 mrStr F64  = SLIT("F64")
 128 mrStr F80  = SLIT("F80")
 129
 130 instance Outputable MachRep where
 131    ppr rep = ptext (mrStr rep)
 132
 133 {-
 134 Implementation notes:
 135
 136 It might suffice to keep just a width, without distinguishing between
 137 floating and integer types.  However, keeping the distinction will
 138 help the native code generator to assign registers more easily.
 139 -}
 140
 141 {-
 142 Should a MachRep include a signed vs. unsigned distinction?
 143
 144 This is very much like a "hint" in C-- terminology: it isn't necessary
 145 in order to generate correct code, but it might be useful in that the
 146 compiler can generate better code if it has access to higher-level
 147 hints about data.  This is important at call boundaries, because the
 148 definition of a function is not visible at all of its call sites, so
 149 the compiler cannot infer the hints.
 150
 151 Here in Cmm, we're taking a slightly different approach.  We include
 152 the int vs. float hint in the MachRep, because (a) the majority of
 153 platforms have a strong distinction between float and int registers,
 154 and (b) we don't want to do any heavyweight hint-inference in the
 155 native code backend in order to get good code.  We're treating the
 156 hint more like a type: our Cmm is always completely consistent with
 157 respect to hints.  All coercions between float and int are explicit.
 158
 159 What about the signed vs. unsigned hint?  This information might be
 160 useful if we want to keep sub-word-sized values in word-size
 161 registers, which we must do if we only have word-sized registers.
 162
 163 On such a system, there are two straightforward conventions for
 164 representing sub-word-sized values:
 165
 166 (a) Leave the upper bits undefined.  Comparison operations must
 167     sign- or zero-extend both operands before comparing them,
 168     depending on whether the comparison is signed or unsigned.
 169
 170 (b) Always keep the values sign- or zero-extended as appropriate.
 171     Arithmetic operations must narrow the result to the appropriate
 172     size.
 173
 174 A clever compiler might not use either (a) or (b) exclusively, instead
 175 it would attempt to minimize the coercions by analysis: the same kind
 176 of analysis that propagates hints around.  In Cmm we don't want to
 177 have to do this, so we plump for having richer types and keeping the
 178 type information consistent.
 179
 180 If signed/unsigned hints are missing from MachRep, then the only
 181 choice we have is (a), because we don't know whether the result of an
 182 operation should be sign- or zero-extended.
 183
 184 Many architectures have extending load operations, which work well
 185 with (b).  To make use of them with (a), you need to know whether the
 186 value is going to be sign- or zero-extended by an enclosing comparison
 187 (for example), which involves knowing above the context.  This is
 188 doable but more complex.
 189
 190 Further complicating the issue is foreign calls: a foreign calling
 191 convention can specify that signed 8-bit quantities are passed as
 192 sign-extended 32 bit quantities, for example (this is the case on the
 193 PowerPC).  So we *do* need sign information on foreign call arguments.
 194
 195 Pros for adding signed vs. unsigned to MachRep:
 196
 197   - It would let us use convention (b) above, and get easier
 198     code generation for extending loads.
 199
 200   - Less information required on foreign calls.
 201
 202   - MachOp type would be simpler
 203
 204 Cons:
 205
 206   - More complexity
 207
 208   - What is the MachRep for a VanillaReg?  Currently it is
 209     always wordRep, but now we have to decide whether it is
 210     signed or unsigned.  The same VanillaReg can thus have
 211     different MachReps in different parts of the program.
 212
 213   - Extra coercions cluttering up expressions.
 214
 215 Currently for GHC, the foreign call point is moot, because we do our
 216 own promotion of sub-word-sized values to word-sized values.  The Int8
 217 type is represnted by an Int# which is kept sign-extended at all times
 218 (this is slightly naughty, because we're making assumptions about the
 219 C calling convention rather early on in the compiler).  However, given
 220 this, the cons outweigh the pros.
 221
 222 -}
 223
 224
 225 machRepBitWidth :: MachRep -> Int
 226 machRepBitWidth I8   = 8
 227 machRepBitWidth I16  = 16
 228 machRepBitWidth I32  = 32
 229 machRepBitWidth I64  = 64
 230 machRepBitWidth I128 = 128
 231 machRepBitWidth F32  = 32
 232 machRepBitWidth F64  = 64
 233 machRepBitWidth F80  = 80
 234
 235 machRepByteWidth :: MachRep -> Int
 236 machRepByteWidth I8   = 1
 237 machRepByteWidth I16  = 2
 238 machRepByteWidth I32  = 4
 239 machRepByteWidth I64  = 8
 240 machRepByteWidth I128 = 16
 241 machRepByteWidth F32  = 4
 242 machRepByteWidth F64  = 8
 243 machRepByteWidth F80  = 10
 244
 245 -- log_2 of the width in bytes, useful for generating shifts.
 246 machRepLogWidth :: MachRep -> Int
 247 machRepLogWidth I8   = 0
 248 machRepLogWidth I16  = 1
 249 machRepLogWidth I32  = 2
 250 machRepLogWidth I64  = 3
 251 machRepLogWidth I128 = 4
 252 machRepLogWidth F32  = 2
 253 machRepLogWidth F64  = 3
 254 machRepLogWidth F80  = panic "machRepLogWidth: F80"
 255
 256 isFloatingRep :: MachRep -> Bool
 257 isFloatingRep F32 = True
 258 isFloatingRep F64 = True
 259 isFloatingRep F80 = True
 260 isFloatingRep _   = False
 261
 262 -- -----------------------------------------------------------------------------
 263 -- Hints
 264
 265 {-
 266 A hint gives a little more information about a data value.  Hints are
 267 used on the arguments to a foreign call, where the code generator needs
 268 to know some extra information on top of the MachRep of each argument in
 269 order to generate a correct call.
 270 -}
 271
 272 data MachHint
 273   = NoHint
 274   | PtrHint
 275   | SignedHint
 276   | FloatHint
 277   deriving Eq
 278
 279 mhStr NoHint     = SLIT("NoHint")
 280 mhStr PtrHint    = SLIT("PtrHint")
 281 mhStr SignedHint = SLIT("SignedHint")
 282 mhStr FloatHint  = SLIT("FloatHint")
 283
 284 instance Outputable MachHint where
 285    ppr hint = ptext (mhStr hint)
 286
 287 -- -----------------------------------------------------------------------------
 288 -- MachOp
 289
 290 {- |
 291 Machine-level primops; ones which we can reasonably delegate to the
 292 native code generators to handle.  Basically contains C's primops
 293 and no others.
 294
 295 Nomenclature: all ops indicate width and signedness, where
 296 appropriate.  Widths: 8\/16\/32\/64 means the given size, obviously.
 297 Nat means the operation works on STG word sized objects.
 298 Signedness: S means signed, U means unsigned.  For operations where
 299 signedness is irrelevant or makes no difference (for example
 300 integer add), the signedness component is omitted.
 301
 302 An exception: NatP is a ptr-typed native word.  From the point of
 303 view of the native code generators this distinction is irrelevant,
 304 but the C code generator sometimes needs this info to emit the
 305 right casts.
 306 -}
 307
 308 data MachOp
 309
 310   -- Integer operations
 311   = MO_Add    MachRep
 312   | MO_Sub    MachRep
 313   | MO_Eq     MachRep
 314   | MO_Ne     MachRep
 315   | MO_Mul    MachRep           -- low word of multiply
 316   | MO_S_MulMayOflo MachRep     -- nonzero if signed multiply overflows
 317   | MO_S_Quot MachRep           -- signed / (same semantics as IntQuotOp)
 318   | MO_S_Rem  MachRep           -- signed % (same semantics as IntRemOp)
 319   | MO_S_Neg  MachRep           -- unary -
 320   | MO_U_MulMayOflo MachRep     -- nonzero if unsigned multiply overflows
 321   | MO_U_Quot MachRep           -- unsigned / (same semantics as WordQuotOp)
 322   | MO_U_Rem  MachRep           -- unsigned % (same semantics as WordRemOp)
 323
 324   -- Signed comparisons (floating-point comparisons also use these)
 325   | MO_S_Ge MachRep
 326   | MO_S_Le MachRep
 327   | MO_S_Gt MachRep
 328   | MO_S_Lt MachRep
 329
 330   -- Unsigned comparisons
 331   | MO_U_Ge MachRep
 332   | MO_U_Le MachRep
 333   | MO_U_Gt MachRep
 334   | MO_U_Lt MachRep
 335
 336   -- Bitwise operations.  Not all of these may be supported at all sizes,
 337   -- and only integral MachReps are valid.
 338   | MO_And   MachRep
 339   | MO_Or    MachRep
 340   | MO_Xor   MachRep
 341   | MO_Not   MachRep
 342   | MO_Shl   MachRep
 343   | MO_U_Shr MachRep    -- unsigned shift right
 344   | MO_S_Shr MachRep    -- signed shift right
 345
 346   -- Conversions.  Some of these will be NOPs.
 347   -- Floating-point conversions use the signed variant.
 348   | MO_S_Conv MachRep{-from-} MachRep{-to-}     -- signed conversion
 349   | MO_U_Conv MachRep{-from-} MachRep{-to-}     -- unsigned conversion
 350
 351   deriving (Eq, Show)
 352
 353 pprMachOp :: MachOp -> SDoc
 354 pprMachOp mo = text (show mo)
 355
 356
 357 -- These MachOps tend to be implemented by foreign calls in some backends,
 358 -- so we separate them out.  In Cmm, these can only occur in a
 359 -- statement position, in contrast to an ordinary MachOp which can occur
 360 -- anywhere in an expression.
 361 data CallishMachOp
 362   = MO_F64_Pwr
 363   | MO_F64_Sin
 364   | MO_F64_Cos
 365   | MO_F64_Tan
 366   | MO_F64_Sinh
 367   | MO_F64_Cosh
 368   | MO_F64_Tanh
 369   | MO_F64_Asin
 370   | MO_F64_Acos
 371   | MO_F64_Atan
 372   | MO_F64_Log
 373   | MO_F64_Exp
 374   | MO_F64_Sqrt
 375   | MO_F32_Pwr
 376   | MO_F32_Sin
 377   | MO_F32_Cos
 378   | MO_F32_Tan
 379   | MO_F32_Sinh
 380   | MO_F32_Cosh
 381   | MO_F32_Tanh
 382   | MO_F32_Asin
 383   | MO_F32_Acos
 384   | MO_F32_Atan
 385   | MO_F32_Log
 386   | MO_F32_Exp
 387   | MO_F32_Sqrt
 388   | MO_WriteBarrier
 389   deriving (Eq, Show)
 390
 391 pprCallishMachOp :: CallishMachOp -> SDoc
 392 pprCallishMachOp mo = text (show mo)
 393
 394 -- -----------------------------------------------------------------------------
 395 -- Some common MachReps
 396
 397 -- A 'wordRep' is a machine word on the target architecture
 398 -- Specifically, it is the size of an Int#, Word#, Addr#
 399 -- and the unit of allocation on the stack and the heap
 400 -- Any pointer is also guaranteed to be a wordRep.
 401
 402 wordRep | wORD_SIZE == 4 = I32
 403         | wORD_SIZE == 8 = I64
 404         | otherwise      = panic "MachOp.wordRep: Unknown word size"
 405
 406 halfWordRep | wORD_SIZE == 4 = I16
 407             | wORD_SIZE == 8 = I32
 408             | otherwise      = panic "MachOp.halfWordRep: Unknown word size"
 409
 410 mo_wordAdd      = MO_Add wordRep
 411 mo_wordSub      = MO_Sub wordRep
 412 mo_wordEq       = MO_Eq  wordRep
 413 mo_wordNe       = MO_Ne  wordRep
 414 mo_wordMul      = MO_Mul wordRep
 415 mo_wordSQuot    = MO_S_Quot wordRep
 416 mo_wordSRem     = MO_S_Rem wordRep
 417 mo_wordSNeg     = MO_S_Neg wordRep
 418 mo_wordUQuot    = MO_U_Quot wordRep
 419 mo_wordURem     = MO_U_Rem wordRep
 420
 421 mo_wordSGe      = MO_S_Ge  wordRep
 422 mo_wordSLe      = MO_S_Le  wordRep
 423 mo_wordSGt      = MO_S_Gt  wordRep
 424 mo_wordSLt      = MO_S_Lt  wordRep
 425
 426 mo_wordUGe      = MO_U_Ge  wordRep
 427 mo_wordULe      = MO_U_Le  wordRep
 428 mo_wordUGt      = MO_U_Gt  wordRep
 429 mo_wordULt      = MO_U_Lt  wordRep
 430
 431 mo_wordAnd      = MO_And wordRep
 432 mo_wordOr       = MO_Or  wordRep
 433 mo_wordXor      = MO_Xor wordRep
 434 mo_wordNot      = MO_Not wordRep
 435 mo_wordShl      = MO_Shl wordRep
 436 mo_wordSShr     = MO_S_Shr wordRep
 437 mo_wordUShr     = MO_U_Shr wordRep
 438
 439 mo_u_8To32      = MO_U_Conv I8 I32
 440 mo_s_8To32      = MO_S_Conv I8 I32
 441 mo_u_16To32     = MO_U_Conv I16 I32
 442 mo_s_16To32     = MO_S_Conv I16 I32
 443
 444 mo_u_8ToWord    = MO_U_Conv I8  wordRep
 445 mo_s_8ToWord    = MO_S_Conv I8  wordRep
 446 mo_u_16ToWord   = MO_U_Conv I16 wordRep
 447 mo_s_16ToWord   = MO_S_Conv I16 wordRep
 448 mo_s_32ToWord   = MO_S_Conv I32 wordRep
 449 mo_u_32ToWord   = MO_U_Conv I32 wordRep
 450
 451 mo_WordTo8      = MO_U_Conv wordRep I8
 452 mo_WordTo16     = MO_U_Conv wordRep I16
 453 mo_WordTo32     = MO_U_Conv wordRep I32
 454
 455 mo_32To8        = MO_U_Conv I32 I8
 456 mo_32To16       = MO_U_Conv I32 I16
 457
 458 -- cIntRep is the MachRep for a C-language 'int'
 459 #if SIZEOF_INT == 4
 460 cIntRep = I32
 461 #elif  SIZEOF_INT == 8
 462 cIntRep = I64
 463 #endif
 464
 465 #if SIZEOF_LONG == 4
 466 cLongRep = I32
 467 #elif  SIZEOF_LONG == 8
 468 cLongRep = I64
 469 #endif
 470
 471 -- ----------------------------------------------------------------------------
 472 -- isCommutableMachOp
 473
 474 {- |
 475 Returns 'True' if the MachOp has commutable arguments.  This is used
 476 in the platform-independent Cmm optimisations.
 477
 478 If in doubt, return 'False'.  This generates worse code on the
 479 native routes, but is otherwise harmless.
 480 -}
 481 isCommutableMachOp :: MachOp -> Bool
 482 isCommutableMachOp mop =
 483   case mop of
 484         MO_Add _                -> True
 485         MO_Eq _                 -> True
 486         MO_Ne _                 -> True
 487         MO_Mul _                -> True
 488         MO_S_MulMayOflo _       -> True
 489         MO_U_MulMayOflo _       -> True
 490         MO_And _                -> True
 491         MO_Or _                 -> True
 492         MO_Xor _                -> True
 493         _other                  -> False
 494
 495 -- ----------------------------------------------------------------------------
 496 -- isAssociativeMachOp
 497
 498 {- |
 499 Returns 'True' if the MachOp is associative (i.e. @(x+y)+z == x+(y+z)@)
 500 This is used in the platform-independent Cmm optimisations.
 501
 502 If in doubt, return 'False'.  This generates worse code on the
 503 native routes, but is otherwise harmless.
 504 -}
 505 isAssociativeMachOp :: MachOp -> Bool
 506 isAssociativeMachOp mop =
 507   case mop of
 508         MO_Add r        -> not (isFloatingRep r)
 509         MO_Mul r        -> not (isFloatingRep r)
 510         MO_And _        -> True
 511         MO_Or _         -> True
 512         MO_Xor _        -> True
 513         _other          -> False
 514
 515 -- ----------------------------------------------------------------------------
 516 -- isComparisonMachOp
 517
 518 {- |
 519 Returns 'True' if the MachOp is a comparison.
 520
 521 If in doubt, return False.  This generates worse code on the
 522 native routes, but is otherwise harmless.
 523 -}
 524 isComparisonMachOp :: MachOp -> Bool
 525 isComparisonMachOp mop =
 526   case mop of
 527     MO_Eq   _  -> True
 528     MO_Ne   _  -> True
 529     MO_S_Ge _  -> True
 530     MO_S_Le _  -> True
 531     MO_S_Gt _  -> True
 532     MO_S_Lt _  -> True
 533     MO_U_Ge _  -> True
 534     MO_U_Le _  -> True
 535     MO_U_Gt _  -> True
 536     MO_U_Lt _  -> True
 537     _other     -> False
 538
 539 -- -----------------------------------------------------------------------------
 540 -- Inverting conditions
 541
 542 -- Sometimes it's useful to be able to invert the sense of a
 543 -- condition.  Not all conditional tests are invertible: in
 544 -- particular, floating point conditionals cannot be inverted, because
 545 -- there exist floating-point values which return False for both senses
 546 -- of a condition (eg. !(NaN > NaN) && !(NaN /<= NaN)).
 547
 548 maybeInvertComparison :: MachOp -> Maybe MachOp
 549 maybeInvertComparison op
 550   = case op of
 551         MO_Eq r    | not (isFloatingRep r) -> Just (MO_Ne r)
 552         MO_Ne r    | not (isFloatingRep r) -> Just (MO_Eq r)
 553         MO_U_Lt r  | not (isFloatingRep r) -> Just (MO_U_Ge r)
 554         MO_U_Gt r  | not (isFloatingRep r) -> Just (MO_U_Le r)
 555         MO_U_Le r  | not (isFloatingRep r) -> Just (MO_U_Gt r)
 556         MO_U_Ge r  | not (isFloatingRep r) -> Just (MO_U_Lt r)
 557         MO_S_Lt r  | not (isFloatingRep r) -> Just (MO_S_Ge r)
 558         MO_S_Gt r  | not (isFloatingRep r) -> Just (MO_S_Le r)
 559         MO_S_Le r  | not (isFloatingRep r) -> Just (MO_S_Gt r)
 560         MO_S_Ge r  | not (isFloatingRep r) -> Just (MO_S_Lt r)
 561         _other  -> Nothing
 562
 563 -- ----------------------------------------------------------------------------
 564 -- resultRepOfMachOp
 565
 566 {- |
 567 Returns the MachRep of the result of a MachOp.
 568 -}
 569 resultRepOfMachOp :: MachOp -> MachRep
 570 resultRepOfMachOp mop =
 571   case mop of
 572     MO_Add    r         -> r
 573     MO_Sub    r         -> r
 574     MO_Eq     r         -> comparisonResultRep
 575     MO_Ne     r         -> comparisonResultRep
 576     MO_Mul    r         -> r
 577     MO_S_MulMayOflo r   -> r
 578     MO_S_Quot r         -> r
 579     MO_S_Rem  r         -> r
 580     MO_S_Neg  r         -> r
 581     MO_U_MulMayOflo r   -> r
 582     MO_U_Quot r         -> r
 583     MO_U_Rem  r         -> r
 584
 585     MO_S_Ge r           -> comparisonResultRep
 586     MO_S_Le r           -> comparisonResultRep
 587     MO_S_Gt r           -> comparisonResultRep
 588     MO_S_Lt r           -> comparisonResultRep
 589
 590     MO_U_Ge r           -> comparisonResultRep
 591     MO_U_Le r           -> comparisonResultRep
 592     MO_U_Gt r           -> comparisonResultRep
 593     MO_U_Lt r           -> comparisonResultRep
 594
 595     MO_And   r          -> r
 596     MO_Or    r          -> r
 597     MO_Xor   r          -> r
 598     MO_Not   r          -> r
 599     MO_Shl   r          -> r
 600     MO_U_Shr r          -> r
 601     MO_S_Shr r          -> r
 602
 603     MO_S_Conv from to   -> to
 604     MO_U_Conv from to   -> to
 605
 606
 607 comparisonResultRep = wordRep  -- is it?
 608
 609
 610 -- -----------------------------------------------------------------------------
 611 -- machOpArgReps
 612
 613 -- | This function is used for debugging only: we can check whether an
 614 -- application of a MachOp is "type-correct" by checking that the MachReps of
 615 -- its arguments are the same as the MachOp expects.  This is used when
 616 -- linting a CmmExpr.
 617
 618 machOpArgReps :: MachOp -> [MachRep]
 619 machOpArgReps op =
 620   case op of
 621     MO_Add    r         -> [r,r]
 622     MO_Sub    r         -> [r,r]
 623     MO_Eq     r         -> [r,r]
 624     MO_Ne     r         -> [r,r]
 625     MO_Mul    r         -> [r,r]
 626     MO_S_MulMayOflo r   -> [r,r]
 627     MO_S_Quot r         -> [r,r]
 628     MO_S_Rem  r         -> [r,r]
 629     MO_S_Neg  r         -> [r]
 630     MO_U_MulMayOflo r   -> [r,r]
 631     MO_U_Quot r         -> [r,r]
 632     MO_U_Rem  r         -> [r,r]
 633
 634     MO_S_Ge r           -> [r,r]
 635     MO_S_Le r           -> [r,r]
 636     MO_S_Gt r           -> [r,r]
 637     MO_S_Lt r           -> [r,r]
 638
 639     MO_U_Ge r           -> [r,r]
 640     MO_U_Le r           -> [r,r]
 641     MO_U_Gt r           -> [r,r]
 642     MO_U_Lt r           -> [r,r]
 643
 644     MO_And   r          -> [r,r]
 645     MO_Or    r          -> [r,r]
 646     MO_Xor   r          -> [r,r]
 647     MO_Not   r          -> [r]
 648     MO_Shl   r          -> [r,wordRep]
 649     MO_U_Shr r          -> [r,wordRep]
 650     MO_S_Shr r          -> [r,wordRep]
 651
 652     MO_S_Conv from to   -> [from]
 653     MO_U_Conv from to   -> [from]