cgen/rtx-funcs.scm

   1 ; Standard RTL functions.
   2 ; Copyright (C) 2000, 2009 Red Hat, Inc.
   3 ; This file is part of CGEN.
   4 ; See file COPYING.CGEN for details.
   5
   6 ; THIS FILE CONTAINS ONE BIG FUNCTION: def-rtx-funcs.
   7 ;
   8 ; It is ok for this file to use procs "internal" to rtl.scm.
   9 ;
  10 ; Each rtx functions has two leading operands: &options, &mode;
  11 ; though `&mode' may be spelled differently.
  12 ; The "&" prefix is to indicate that the parsing of these operands is handled
  13 ; differently.  They are optional and are written with leading colons
  14 ; (e.g. :SI).  The leading ":" is to help the parser - all leading optional
  15 ; operands begin with ":".  The order of the arguments is &options then &mode
  16 ; though there is no imposed order in written RTL.
  17
  18 (define (def-rtx-funcs)
  19
  20 ; Do not change the indentation here.
  21 (let
  22 (
  23  ; These are defined in rtl.scm.
  24  (drn define-rtx-node)
  25  (drsn define-rtx-syntax-node)
  26  (dron define-rtx-operand-node)
  27  (drmn define-rtx-macro-node)
  28 )
  29
  30 ; The reason for the odd indenting above is so that emacs begins indenting the
  31 ; following code at column 1.
  32 \f
  33 ; Error reporting.
  34 ; MODE is present for use in situations like non-VOID mode cond's.
  35 ; The code will expect the mode to be compatible even though `error'
  36 ; "doesn't return".  A small concession for simpler code.
  37
  38 (drn (error &options &mode message)
  39      #f
  40      (OPTIONS VOIDORNUMMODE STRING) (NA NA NA)
  41      MISC
  42      (estate-error *estate* "error in rtl" message)
  43 )
  44
  45 ; Enums
  46 ; Default mode is INT.
  47
  48 (drn (enum &options &mode enum-name)
  49      #f
  50      (OPTIONS ANYINTMODE SYMBOL) (NA NA NA) ;; FIXME: s/SYMBOL/ENUM-NAME/ ?
  51      ARG
  52      ; When computing a value, return the enum's value.
  53      (enum-lookup-val enum-name)
  54 )
  55
  56 ; Instruction fields
  57 ; These are used in the encode/decode specs of other ifields as well as in
  58 ; instruction semantics.
  59 ; Ifields are normally specified by name, but they are subsequently wrapped
  60 ; in this.
  61
  62 (dron (ifield &options &mode ifld-name)
  63       #f
  64       (OPTIONS ANYNUMMODE SYMBOL) (NA NA NA) ;; FIXME: s/SYMBOL/IFIELD-NAME/ ?
  65       ARG
  66       (let ((f (current-ifld-lookup ifld-name)))
  67         (make <operand> (obj-location f)
  68               ifld-name (string-append ifld-name " used as operand")
  69               (atlist-cons (bool-attr-make 'SEM-ONLY #t)
  70                            (obj-atlist f))
  71               (obj:name (ifld-hw-type f))
  72               (obj:name (ifld-mode f))
  73               (make <hw-index> 'anonymous 'ifield (ifld-mode f) f)
  74               nil #f #f))
  75 )
  76
  77 ; Specify an operand.
  78 ; Operands are normally specified by name, but they are subsequently wrapped
  79 ; in this.
  80
  81 (dron (operand &options &mode op-name)
  82       #f
  83       (OPTIONS ANYNUMMODE SYMBOL) (NA NA NA) ;; FIXME: s/SYMBOL/OPERAND-NAME/ ?
  84       ARG
  85       (current-op-lookup op-name)
  86 )
  87
  88 ; Operand naming/numbering.
  89 ; Operands are given names so that the operands as used in the semantics can
  90 ; be matched with arguments of function units.  With good name choices of
  91 ; operands and function unit arguments, this is rarely necessary, but
  92 ; sometimes it is.
  93 ;
  94 ; ??? This obfuscates the semantic code a fair bit.  Another way to do this
  95 ; would be to add new elements to <insn> to specify operands outside of
  96 ; the semantic code.  E.g.
  97 ; (define-insn ...
  98 ;   (inputs (in-gr1 src1) (in-gr2 src2))
  99 ;   (outputs (out-pc pc) (out-gr dr) (reg-14 (reg WI h-gr 14)))
 100 ;   ...)
 101 ; The intent here is to continue to allow the semantic code to use names
 102 ; of operands, and not overly complicate the input/output description.
 103 ;
 104 ; In instructions, operand numbers are recorded as well, to implement
 105 ; profiling and result writeback of parallel insns.
 106
 107 ; Rename operand VALUE to NEW-NAME.
 108 ; VALUE is an expression whose result is an object of type <operand>.
 109 ; It can be the name of an existing operand.
 110 ; ??? Might also support numbering by allowing NEW-NAME to be a number.
 111
 112 (drsn (name &options &mode new-name value)
 113       #f
 114       (OPTIONS ANYNUMMODE SYMBOL RTX) (NA NA NA ANY)
 115       ARG
 116       ;; FIXME: s/DFLT/&mode/ ?
 117       (let ((result (object-copy (rtx-get 'DFLT value))))
 118         (op:set-sem-name! result new-name)
 119         result)
 120 )
 121
 122 ; Operands are generally compiled to an internal form first.
 123 ; There is a fair bit of state associated with them, and it's easier to
 124 ; work with an object than source [which might get fairly complicated if
 125 ; it expresses all the state].
 126 ; Compiled operands are wrapped in this so that they still look like rtx.
 127
 128 (dron (xop &options &mode object)
 129       #f
 130       (OPTIONS ANYNUMMODE OBJECT) (NA NA NA) ;; FIXME: s/OBJECT/OPERAND/ ?
 131       ARG
 132       object
 133 )
 134
 135 ;(dron (opspec: &options &mode op-name op-num hw-ref attrs)
 136 ;      (OPTIONS ANYNUMMODE SYMBOL NUMBER RTX ATTRS) (NA NA NA NA ANY NA)
 137 ;      ARG
 138 ;      (let ((opval (rtx-eval-with-estate hw-ref (mode:lookup &mode) *estate*)))
 139 ;       (assert (operand? opval))
 140 ;       ; Set the specified mode, ensuring it's ok.
 141 ;       ; This also makes a copy as we don't want to modify predefined
 142 ;       ; operands.
 143 ;       (let ((operand (op:new-mode opval mode)))
 144 ;         (op:set-sem-name! operand op-name)
 145 ;         (op:set-num! operand op-num)
 146 ;         (op:set-cond?! operand (attr-value attrs 'COND-REF #f))
 147 ;         operand))
 148 ;)
 149
 150 ; Specify a reference to a local variable.
 151 ; Local variables are normally specified by name, but they are subsequently
 152 ; wrapped in this.
 153
 154 (dron (local &options &mode local-name)
 155       #f
 156       (OPTIONS ANYNUMMODE SYMBOL) (NA NA NA) ;; FIXME: s/SYMBOL/LOCAL-NAME/ ?
 157       ARG
 158       (rtx-temp-lookup (tstate-env *tstate*) local-name)
 159 )
 160
 161 ; FIXME: This doesn't work.  See s-operand.
 162 ;(define (s-dup estate op-name)
 163 ;  (if (not (insn? (estate-owner estate)))
 164 ;      (error "dup: not processing an insn"))
 165 ;  (vector-ref (insn:operands (current-current-context))
 166 ;              (op:lookup-num (insn:operands (estate-owner estate)) op-name))
 167 ;)
 168 ;
 169 ; ??? Since operands are given names and not numbers this isn't currently used.
 170 ;
 171 ;(drsn (dup &options &mode op-name)
 172 ;     #f
 173 ;     (OPTIONS ANYNUMMODE SYMBOL) (NA NA NA)
 174 ;     ;(s-dup *estate* op-name)
 175 ;     (begin
 176 ;       (if (not (insn? (estate-owner *estate*)))
 177 ;          (error "dup: not processing an insn"))
 178 ;       (vector-ref (insn:operands (estate-owner *estate*))
 179 ;                  (op:lookup-num (insn:operands (estate-owner *estate*)) op-name)))
 180 ;     #f
 181 ;)
 182
 183 ; Returns non-zero if operand NAME was referenced (read if input operand
 184 ; and written if output operand).
 185 ; ??? What about input/output operands.
 186
 187 (drsn (ref &options &mode name)
 188       BI
 189       (OPTIONS BIMODE SYMBOL) (NA NA NA) ;; FIXME: s/SYMBOL/OPERAND-NAME/ ?
 190       ARG
 191       #f
 192 )
 193
 194 ; Return the index of an operand.
 195 ; For registers this is the register number.
 196 ; ??? Mode handling incomplete, this doesn't handle mem, which it could.
 197 ; Until then we fix the mode of the result to INT.
 198
 199 (dron (index-of &options &mode op-rtx)
 200       INT
 201       (OPTIONS INTMODE RTX) (NA NA ANY)
 202       ARG
 203       ;; FIXME: s/DFLT/&mode/ ?
 204       (let* ((operand (rtx-eval-with-estate op-rtx DFLT *estate*))
 205              (f (hw-index:value (op:index operand)))
 206              (f-name (obj:name f)))
 207         (make <operand> (if (source-ident? f) (obj-location f) #f)
 208               f-name f-name
 209               (atlist-cons (bool-attr-make 'SEM-ONLY #t)
 210                            (obj-atlist f))
 211               (obj:name (ifld-hw-type f))
 212               (obj:name (ifld-mode f))
 213               (make <hw-index> 'anonymous
 214                     'ifield
 215                     (ifld-mode f)
 216                     ; (send (op:type op) 'get-index-mode)
 217                     f)
 218               nil #f #f))
 219 )
 220
 221 ; Same as index-of, but improves readability for registers.
 222
 223 (drmn (regno reg)
 224       (list 'index-of reg)
 225 )
 226 \f
 227 ; Hardware elements.
 228
 229 ; Describe a random hardware object.
 230 ; If INDX is missing, assume the element is a scalar.  We pass 0 so s-hw
 231 ; doesn't have to unpack the list that would be passed if it were defined as
 232 ; (hw mode hw-name . indx).  This is an internal implementation detail
 233 ; and thus harmless to the description language.
 234 ; These are implemented as syntax nodes as we must pass INDX to `s-hw'
 235 ; unevaluated.
 236 ; ??? Not currently supported.  Not sure whether it should be.
 237 ;(drsn (hw &options &mode hw-elm . indx-sel)
 238 ;      (OPTIONS ANYNUMMODE SYMBOL . RTX) (NA NA NA . INT)
 239 ;      ARG
 240 ;      (let ((indx (if (pair? indx-sel) (car indx-sel) 0))
 241 ;            (selector (if (and (pair? indx-sel) (pair? (cdr indx-sel)))
 242 ;                          (cadr indx-sel)
 243 ;                          hw-selector-default))))
 244 ;      (s-hw *estate* mode hw-elm indx selector)
 245 ;)
 246
 247 ; Register accesses.
 248 ; INDX-SEL is an optional index and possible selector.
 249 (dron (reg &options &mode hw-elm . indx-sel)
 250       #f
 251       (OPTIONS ANYNUMMODE SYMBOL . RTX) (NA NA NA . INT) ;; FIXME: s/SYMBOL/HW-NAME/ ?
 252       ARG
 253       (let ((indx (if (pair? indx-sel) (car indx-sel) 0))
 254             (selector (if (and (pair? indx-sel) (pair? (cdr indx-sel)))
 255                           (cadr indx-sel)
 256                           hw-selector-default)))
 257         (s-hw *estate* mode hw-elm indx selector))
 258 )
 259
 260 ; A raw-reg bypasses the getter/setter stuff.  It's usually used in
 261 ; getter/setter definitions.
 262
 263 (dron (raw-reg &options &mode hw-elm . indx-sel)
 264       #f
 265       (OPTIONS ANYNUMMODE SYMBOL . RTX) (NA NA NA . INT) ;; FIXME: s/SYMBOL/HW-NAME/ ?
 266       ARG
 267       (let ((indx (if (pair? indx-sel) (car indx-sel) 0))
 268             (selector (if (and (pair? indx-sel) (pair? (cdr indx-sel)))
 269                           (cadr indx-sel)
 270                           hw-selector-default)))
 271         (let ((result (s-hw *estate* mode hw-elm indx selector)))
 272           (obj-cons-attr! result (bool-attr-make 'RAW #t))
 273           result))
 274 )
 275
 276 ; Memory accesses.
 277 (dron (mem &options &mode addr . sel)
 278       #f
 279       (OPTIONS EXPLNUMMODE RTX . RTX) (NA NA AI . INT)
 280       ARG
 281       (s-hw *estate* mode 'h-memory addr
 282             (if (pair? sel) (car sel) hw-selector-default))
 283 )
 284 \f
 285 ; Instruction execution support.
 286 ; There are no jumps, per se.  A jump is a set of `pc'.
 287
 288 ; The program counter.
 289 ; ??? Hmmm... needed?  The pc is usually specified as `pc' which is shorthand
 290 ; for (operand pc).
 291 ;(dron (pc) () () ARG s-pc)
 292
 293 ; Fetch bytes from the instruction stream of size MODE.
 294 ; FIXME: Later need to augment this by passing an indicator to the mem-fetch
 295 ; routines that we're doing an ifetch.
 296 ; ??? wip!
 297
 298 (drmn (ifetch mode pc)
 299       (list 'mem mode pc) ; hw-selector-ispace
 300 )
 301
 302 ; NUM is the instruction number.  Generally it is zero but if more than one
 303 ; insn is decoded at a time, it is non-zero.  This is used, for example, to
 304 ; index into the scache [as an offset from the first insn].
 305 ; ??? wip!
 306
 307 (drmn (decode mode pc insn num)
 308       (list 'c-call mode 'EXTRACT pc insn num)
 309 )
 310
 311 ; NUM is the same number passed to `decode'.
 312 ; ??? wip!
 313
 314 (drmn (execute mode num)
 315       (list 'c-call mode 'EXECUTE num)
 316 )
 317 \f
 318 ; Control Transfer Instructions
 319
 320 ; Sets of pc are handled like other sets so there are no branch rtx's.
 321
 322 ; Indicate there are N delay slots in the processing of RTX.
 323 ; N is a `const' node.
 324 ; The mode of the result is the mode of RTX.
 325 ; ??? wip!
 326
 327 (drn (delay &options &mode n rtx)
 328      #f
 329      (OPTIONS VOIDORNUMMODE RTX RTX) (NA NA INT MATCHEXPR)
 330      MISC
 331      #f ; (s-sequence *estate* VOID '() rtx) ; wip!
 332 )
 333
 334 ; Annul the following insn if YES? is non-zero.
 335 ; PC is the address of the annuling insn.
 336 ; The target is required to define SEM_ANNUL_INSN.
 337 ; ??? wip!
 338
 339 (drmn (annul yes?)
 340       ; The pc reference here is hidden in c-code to not generate a spurious
 341       ; pc input operand.
 342       (list 'c-call 'VOID "SEM_ANNUL_INSN" (list 'c-code 'IAI "pc") yes?)
 343 )
 344
 345 ; Skip the following insn if YES? is non-zero.
 346 ; The target is required to define SEM_SKIP_INSN.
 347 ; ??? This is similar to annul.  Deletion of one of them defered.
 348 ; ??? wip!
 349
 350 (drn (skip &options &mode yes?)
 351      VOID
 352      (OPTIONS VOIDMODE RTX) (NA NA INT)
 353      MISC
 354      #f
 355 )
 356 \f
 357 ; Attribute support.
 358
 359 ; Return a boolean indicating if attribute named ATTR is VALUE in OWNER.
 360 ; If VALUE is a list, return "true" if ATTR is any of the listed values.
 361 ; ??? Don't yet support !VALUE.
 362 ; OWNER is the result of either (current-insn) or (current-mach)
 363 ; [note that canonicalization will turn them into
 364 ; (current-{insn,mach} () DFLT)].
 365 ; The result is always of mode BI.
 366 ; FIXME: wip
 367 ;
 368 ; This is a syntax node so the args are not pre-evaluated.
 369 ; We just want the symbols.
 370 ; FIXME: Hmmm... it currently isn't a syntax node.
 371
 372 (drn (eq-attr &options &mode owner attr value)
 373      BI
 374       (OPTIONS BIMODE RTX SYMBOL SYMORNUM) (NA NA ANY NA NA)
 375       MISC
 376       (let ((atval (if owner
 377                        (obj-attr-value owner attr)
 378                        (attr-lookup-default attr #f))))
 379         (if (list? value)
 380             (->bool (memq atval value))
 381             (eq? atval value)))
 382 )
 383
 384 ; Get the value of attribute ATTR-NAME, expressable as an integer.
 385 ; OBJ is the result of either (current-insn) or (current-mach).
 386 ; Note that canonicalization will turn them into
 387 ; (current-{insn,mach} () {INSN,MACH}MODE).
 388 ; FIXME:wip
 389 ; This uses INTMODE because we can't otherwise determine the
 390 ; mode of the result (if elided).
 391
 392 (drn (int-attr &options &mode obj attr-name)
 393      #f
 394      (OPTIONS INTMODE RTX SYMBOL) (NA NA ANY NA)
 395      MISC
 396      #f
 397 )
 398
 399 ;; Deprecated alias for int-attr.
 400
 401 (drmn (attr arg1 . rest)
 402       (cons 'int-attr (cons arg1 rest))
 403 )
 404
 405 ; Same as `quote', for use in attributes cus "quote" sounds too jargonish.
 406 ; [Ok, not a strong argument for using "symbol", but so what?]
 407
 408 (drsn (symbol &options &mode name)
 409       SYM
 410       (OPTIONS SYMMODE SYMBOL) (NA NA NA)
 411       ARG
 412       name
 413 )
 414
 415 ; Return the current instruction.
 416
 417 (drn (current-insn &options &mode)
 418      INSN
 419      (OPTIONS INSNMODE) (NA NA)
 420      MISC
 421      (let ((obj (estate-owner *estate*)))
 422        (if (not (insn? obj))
 423            (error "current context not an insn"))
 424        obj)
 425 )
 426
 427 ; Return the currently selected machine.
 428 ; This can either be a compile-time or run-time value.
 429
 430 (drn (current-mach &options &mode)
 431      MACH
 432      (OPTIONS MACHMODE) (NA NA)
 433      MISC
 434      -rtx-current-mach
 435 )
 436 \f
 437 ; Constants.
 438
 439 ; FIXME: Need to consider 64 bit hosts.
 440 (drn (const &options &mode c)
 441      #f
 442      (OPTIONS ANYNUMMODE NUMBER) (NA NA NA)
 443      ARG
 444      ; When computing a value, just return the constant unchanged.
 445      c
 446 )
 447 \f
 448 ; Large mode support.
 449
 450 ; Combine smaller modes into a larger one.
 451 ; Arguments are specified most significant to least significant.
 452 ; ??? May also want an endian dependent argument order.  That can be
 453 ; implemented on top of or beside this.
 454 ; ??? Not all of the combinations are supported in the simulator.
 455 ; They'll get added as necessary.
 456 (drn (join &options &out-mode in-mode arg1 . arg-rest)
 457      #f
 458      (OPTIONS ANYNUMMODE ANYNUMMODE RTX . RTX) (NA NA NA ANY . ANY)
 459      MISC
 460      ; FIXME: Ensure correct number of args for in/out modes.
 461      ; FIXME: Ensure compatible modes.
 462      #f
 463 )
 464
 465 ; GCC's subreg.
 466 ; Called subword 'cus it's not exactly subreg.
 467 ; Word numbering is from most significant (word 0) to least (word N-1).
 468 ; ??? May also want an endian dependent word ordering.  That can be
 469 ; implemented on top of or beside this.
 470 ; ??? GCC plans to switch to SUBREG_BYTE.  Keep an eye out for the switch
 471 ; (which is extensive so probably won't happen anytime soon).
 472 ;
 473 ; The mode spec of operand0 use to be MATCHEXPR, but subword is not a normal rtx.
 474 ; The mode of operand0 is not necessarily the same as the mode of the result,
 475 ; and code which analyzes it would otherwise use the result mode (specified by
 476 ; `&mode') for the mode of operand0.
 477
 478 (drn (subword &options &mode value word-num)
 479      #f
 480      (OPTIONS ANYNUMMODE RTX RTX) (NA NA ANY INT)
 481      ARG
 482      #f
 483 )
 484
 485 ; ??? The split and concat stuff is just an experiment and should not be used.
 486 ; What's there now is just "thoughts put down on paper."
 487
 488 (drmn (split split-mode in-mode di)
 489       ; FIXME: Ensure compatible modes
 490       ;(list 'c-raw-call 'BLK (string-append "SPLIT" in-mode split-mode) di)
 491       '(const 0)
 492 )
 493
 494 (drmn (concat modes arg1 . arg-rest)
 495       ; FIXME: Here might be the place to ensure
 496       ; (= (length modes) (length (cons arg1 arg-rest))).
 497       ;(cons 'c-raw-call (cons modes (cons "CONCAT" (cons arg1 arg-rest))))
 498       '(const 0)
 499 )
 500 \f
 501 ; Support for explicit C code.
 502 ; ??? GCC RTL calls this "unspec" which is arguably a more application
 503 ; independent name.
 504
 505 (drn (c-code &options &mode text)
 506      #f
 507      (OPTIONS ANYEXPRMODE STRING) (NA NA NA)
 508      UNSPEC
 509      #f
 510 )
 511
 512 ; Invoke C functions passing them arguments from the semantic code.
 513 ; The arguments are passed as is, no conversion is done here.
 514 ; Usage is:
 515 ;           (c-call mode name arg1 arg2 ...)
 516 ; which is converted into a C function call:
 517 ;           name (current_cpu, arg1, arg2, ...)
 518 ; Mode is the mode of the result.
 519 ; If it is VOID this call is a statement and ';' is appended.
 520 ; Otherwise it is part of an expression.
 521
 522 (drn (c-call &options &mode name . args)
 523      #f
 524      (OPTIONS ANYEXPRMODE STRING . RTX) (NA NA NA . ANY)
 525      UNSPEC
 526      #f
 527 )
 528
 529 ; Same as c-call but without implicit first arg of `current_cpu'.
 530
 531 (drn (c-raw-call &options &mode name . args)
 532      #f
 533      (OPTIONS ANYEXPRMODE STRING . RTX) (NA NA NA . ANY)
 534      UNSPEC
 535      #f
 536 )
 537 \f
 538 ; Set/get/miscellaneous
 539
 540 (drn (nop &options &mode)
 541      VOID
 542      (OPTIONS VOIDMODE) (NA NA)
 543      MISC
 544      #f
 545 )
 546
 547 ; Clobber - mark an object as modified without explaining why or how.
 548
 549 (drn (clobber &options &mode object)
 550      VOID
 551      (OPTIONS VOIDORNUMMODE RTX) (NA NA MATCHEXPR)
 552      MISC
 553      #f
 554 )
 555
 556 ; The `set' rtx.
 557 ; MODE is the mode of DST.  If DFLT, use DST's default mode.
 558 ; The mode of the result is always VOID.
 559 ;
 560 ; ??? It might be more consistent to rename set -> set-trace, but that's
 561 ; too wordy.  The `set' rtx is the normal one and we want the normal one to
 562 ; be the verbose one (prints result tracing messages).  `set-quiet' is the
 563 ; atypical one, it doesn't print tracing messages.  It may also turn out that
 564 ; a different mechanism (rather than the name "set-quiet") is used some day.
 565 ; One way would be to record the "quietness" state with the traversal state and
 566 ; use something like (with-quiet (set foo bar)) akin to with-output-to-string
 567 ; in Guile.
 568 ;
 569 ; i.e. set -> gen-set-trace
 570 ;      set-quiet -> gen-set-quiet
 571 ;
 572 ; ??? One might want a `!' suffix as in `set!', but methinks that's following
 573 ; Scheme too closely.
 574
 575 (drn (set &options &mode dst src)
 576      VOID
 577      (OPTIONS ANYNUMMODE SETRTX RTX) (NA NA MATCHEXPR MATCH2)
 578      SET
 579      #f
 580 )
 581
 582 (drn (set-quiet &options &mode dst src)
 583      VOID
 584      (OPTIONS ANYNUMMODE SETRTX RTX) (NA NA MATCHEXPR MATCH2)
 585      SET
 586      #f
 587 )
 588 \f
 589 ; Standard arithmetic operations.
 590
 591 ; It's nice emitting macro calls to the actual C operation in that the RTX
 592 ; expression is preserved, albeit in C.  On the one hand it's one extra thing
 593 ; the programmer has to know when looking at the code.  But on the other it's
 594 ; trivial stuff, and having a layer between RTX and C allows the
 595 ; macros/functions to be modified to handle unexpected situations.
 596 ;
 597 ; We do emit C directly for cases other than cpu semantics
 598 ; (e.g. the assembler).
 599 ;
 600 ; The language is defined such that we assume ANSI C semantics while avoiding
 601 ; implementation defined areas, with as few exceptions as possible.
 602 ;
 603 ; Current exceptions:
 604 ; - signed shift right assumes the sign bit is replicated.
 605 ;
 606 ; Additional notes [perhaps repeating what's in ANSI C for emphasis]:
 607 ; - callers of division and modulus fns must test for 0 beforehand
 608 ;   if necessary
 609 ; - division and modulus fns have unspecified behavior for negative args
 610 ;   [yes I know the C standard says implementation defined, here its
 611 ;   unspecified]
 612 ; - later add versions of div/mod that have an explicit behaviour for -ve args
 613 ; - signedness is part of the rtx operation name, and is not determined
 614 ;   from the arguments [elsewhere is a description of the tradeoffs]
 615 ; - ???
 616
 617 (drn (neg &options &mode s1)
 618      #f
 619      (OPTIONS ANYNUMMODE RTX) (NA NA MATCHEXPR)
 620      UNARY
 621      #f
 622 )
 623
 624 (drn (abs &options &mode s1)
 625      #f
 626      (OPTIONS ANYNUMMODE RTX) (NA NA MATCHEXPR)
 627      UNARY
 628      #f
 629 )
 630
 631 ; For integer values this is a bitwise operation (each bit inverted).
 632 ; For floating point values this produces 1/x.
 633 ; ??? Might want different names.
 634 (drn (inv &options &mode s1)
 635      #f
 636      (OPTIONS ANYINTMODE RTX) (NA NA MATCHEXPR)
 637      UNARY
 638      #f
 639 )
 640
 641 ; This is a boolean operation.
 642 ; MODE is the mode of S1.  The result always has mode BI.
 643 ; ??? Perhaps `mode' shouldn't be here.
 644 (drn (not &options &mode s1)
 645      BI
 646      (OPTIONS ANYINTMODE RTX) (NA NA MATCHEXPR)
 647      UNARY
 648      #f
 649 )
 650
 651 (drn (add &options &mode s1 s2)
 652      #f
 653      (OPTIONS ANYNUMMODE RTX RTX) (NA NA MATCHEXPR MATCH2)
 654      BINARY
 655      #f
 656 )
 657 (drn (sub &options &mode s1 s2)
 658      #f
 659      (OPTIONS ANYNUMMODE RTX RTX) (NA NA MATCHEXPR MATCH2)
 660      BINARY
 661      #f
 662 )
 663
 664 ; "OF" for "overflow flag", "CF" for "carry flag",
 665 ; "s3" here must have type BI.
 666 ; For the *flag rtx's, MODE is the mode of S1,S2; the result always has
 667 ; mode BI.
 668 (drn (addc &options &mode s1 s2 s3)
 669      #f
 670      (OPTIONS ANYINTMODE RTX RTX RTX) (NA NA MATCHEXPR MATCH2 BI)
 671      TRINARY
 672      #f
 673 )
 674 (drn (addc-cflag &options &mode s1 s2 s3)
 675      BI
 676      (OPTIONS ANYINTMODE RTX RTX RTX) (NA NA MATCHEXPR MATCH2 BI)
 677      TRINARY
 678      #f
 679 )
 680 (drn (addc-oflag &options &mode s1 s2 s3)
 681      BI
 682      (OPTIONS ANYINTMODE RTX RTX RTX) (NA NA MATCHEXPR MATCH2 BI)
 683      TRINARY
 684      #f
 685 )
 686 (drn (subc &options &mode s1 s2 s3)
 687      #f
 688      (OPTIONS ANYINTMODE RTX RTX RTX) (NA NA MATCHEXPR MATCH2 BI)
 689      TRINARY
 690      #f
 691 )
 692 (drn (subc-cflag &options &mode s1 s2 s3)
 693      BI
 694      (OPTIONS ANYINTMODE RTX RTX RTX) (NA NA MATCHEXPR MATCH2 BI)
 695      TRINARY
 696      #f
 697 )
 698 (drn (subc-oflag &options &mode s1 s2 s3)
 699      BI
 700      (OPTIONS ANYINTMODE RTX RTX RTX) (NA NA MATCHEXPR MATCH2 BI)
 701      TRINARY
 702      #f
 703 )
 704
 705 ;; ??? These are deprecated.  Delete in time.
 706 (drn (add-cflag &options &mode s1 s2 s3)
 707      BI
 708      (OPTIONS ANYINTMODE RTX RTX RTX) (NA NA MATCHEXPR MATCH2 BI)
 709      TRINARY
 710      #f
 711 )
 712 (drn (add-oflag &options &mode s1 s2 s3)
 713      BI
 714      (OPTIONS ANYINTMODE RTX RTX RTX) (NA NA MATCHEXPR MATCH2 BI)
 715      TRINARY
 716      #f
 717 )
 718 (drn (sub-cflag &options &mode s1 s2 s3)
 719      BI
 720      (OPTIONS ANYINTMODE RTX RTX RTX) (NA NA MATCHEXPR MATCH2 BI)
 721      TRINARY
 722      #f
 723 )
 724 (drn (sub-oflag &options &mode s1 s2 s3)
 725      BI
 726      (OPTIONS ANYINTMODE RTX RTX RTX) (NA NA MATCHEXPR MATCH2 BI)
 727      TRINARY
 728      #f
 729 )
 730
 731 ; Usurp these names so that we have consistent rtl should a program generator
 732 ; ever want to infer more about what the semantics are doing.
 733 ; For now these are just macros that expand to real rtl to perform the
 734 ; operation.
 735
 736 ; Return bit indicating if VALUE is zero/non-zero.
 737 (drmn (zflag arg1 . rest) ; mode value)
 738       (if (null? rest) ; mode missing?
 739           (list 'eq 'DFLT arg1 0)
 740           (list 'eq arg1 (car rest) 0))
 741 )
 742
 743 ; Return bit indicating if VALUE is negative/non-negative.
 744 (drmn (nflag arg1 . rest) ; mode value)
 745       (if (null? rest) ; mode missing?
 746           (list 'lt 'DFLT arg1 0)
 747           (list 'lt arg1 (car rest) 0))
 748 )
 749
 750 ; Multiply/divide.
 751
 752 (drn (mul &options &mode s1 s2)
 753      #f
 754      (OPTIONS ANYNUMMODE RTX RTX) (NA NA MATCHEXPR MATCH2)
 755      BINARY
 756      #f
 757 )
 758 ; ??? In non-sim case, ensure s1,s2 is in right C type for right result.
 759 ; ??? Need two variants, one that avoids implementation defined situations
 760 ; [both host and target], and one that specifies implementation defined
 761 ; situations [target].
 762 (drn (div &options &mode s1 s2)
 763      #f
 764      (OPTIONS ANYNUMMODE RTX RTX) (NA NA MATCHEXPR MATCH2)
 765      BINARY
 766      #f
 767 )
 768 (drn (udiv &options &mode s1 s2)
 769      #f
 770      (OPTIONS ANYINTMODE RTX RTX) (NA NA MATCHEXPR MATCH2)
 771      BINARY
 772      #f
 773 )
 774 (drn (mod &options &mode s1 s2)
 775      #f
 776      (OPTIONS ANYNUMMODE RTX RTX) (NA NA MATCHEXPR MATCH2)
 777      BINARY
 778      #f
 779 )
 780 (drn (umod &options &mode s1 s2)
 781      #f
 782      (OPTIONS ANYINTMODE RTX RTX) (NA NA MATCHEXPR MATCH2)
 783      BINARY
 784      #f
 785 )
 786
 787 ; wip: mixed mode mul/div
 788
 789 ; various floating point routines
 790
 791 (drn (sqrt &options &mode s1)
 792      #f
 793      (OPTIONS ANYFLOATMODE RTX) (NA NA MATCHEXPR)
 794      UNARY
 795      #f
 796 )
 797
 798 (drn (cos &options &mode s1)
 799      #f
 800      (OPTIONS ANYFLOATMODE RTX) (NA NA MATCHEXPR)
 801      UNARY
 802      #f
 803 )
 804
 805 (drn (sin &options &mode s1)
 806      #f
 807      (OPTIONS ANYFLOATMODE RTX) (NA NA MATCHEXPR)
 808      UNARY
 809      #f
 810 )
 811
 812 ; min/max
 813
 814 (drn (min &options &mode s1 s2)
 815      #f
 816      (OPTIONS ANYNUMMODE RTX RTX) (NA NA MATCHEXPR MATCH2)
 817      BINARY
 818      #f
 819 )
 820
 821 (drn (max &options &mode s1 s2)
 822      #f
 823      (OPTIONS ANYNUMMODE RTX RTX) (NA NA MATCHEXPR MATCH2)
 824      BINARY
 825      #f
 826 )
 827
 828 (drn (umin &options &mode s1 s2)
 829      #f
 830      (OPTIONS ANYINTMODE RTX RTX) (NA NA MATCHEXPR MATCH2)
 831      BINARY
 832      #f
 833 )
 834
 835 (drn (umax &options &mode s1 s2)
 836      #f
 837      (OPTIONS ANYINTMODE RTX RTX) (NA NA MATCHEXPR MATCH2)
 838      BINARY
 839      #f
 840 )
 841
 842 ; These are bitwise operations.
 843 (drn (and &options &mode s1 s2)
 844      #f
 845      (OPTIONS ANYINTMODE RTX RTX) (NA NA MATCHEXPR MATCH2)
 846      BINARY
 847      #f
 848 )
 849 (drn (or &options &mode s1 s2)
 850      #f
 851      (OPTIONS ANYINTMODE RTX RTX) (NA NA MATCHEXPR MATCH2)
 852      BINARY
 853      #f
 854 )
 855 (drn (xor &options &mode s1 s2)
 856      #f
 857      (OPTIONS ANYINTMODE RTX RTX) (NA NA MATCHEXPR MATCH2)
 858      BINARY
 859      #f
 860 )
 861
 862 ; Shift operations.
 863
 864 (drn (sll &options &mode s1 s2)
 865      #f
 866      (OPTIONS ANYINTMODE RTX RTX) (NA NA MATCHEXPR INT)
 867      BINARY
 868      #f
 869 )
 870 (drn (srl &options &mode s1 s2)
 871      #f
 872      (OPTIONS ANYINTMODE RTX RTX) (NA NA MATCHEXPR INT)
 873      BINARY
 874      #f
 875 )
 876 ; ??? In non-sim case, ensure s1 is in right C type for right result.
 877 (drn (sra &options &mode s1 s2)
 878      #f
 879      (OPTIONS ANYINTMODE RTX RTX) (NA NA MATCHEXPR INT)
 880      BINARY
 881      #f
 882 )
 883 ; Rotates don't really have a sign, so doesn't matter what we say.
 884 (drn (ror &options &mode s1 s2)
 885      #f
 886      (OPTIONS ANYINTMODE RTX RTX) (NA NA MATCHEXPR INT)
 887      BINARY
 888      #f
 889 )
 890 (drn (rol &options &mode s1 s2)
 891      #f
 892      (OPTIONS ANYINTMODE RTX RTX) (NA NA MATCHEXPR INT)
 893      BINARY
 894      #f
 895 )
 896 ; ??? Will also need rotate-with-carry [duh...].
 897
 898 ; These are boolean operations (e.g. C &&, ||).
 899 ; The result always has mode BI.
 900 ; ??? 'twould be more Schemey to take a variable number of args.
 901 ; ??? 'twould also simplify several .cpu description entries.
 902 ; On the other hand, handling an arbitrary number of args isn't supported by
 903 ; ISA's, which the main goal of what we're trying to represent.
 904 (drn (andif &options &mode s1 s2)
 905      BI
 906      (OPTIONS BIMODE RTX RTX) (NA NA ANYINT ANYINT)
 907      BINARY ; IF?
 908      #f
 909 )
 910 (drn (orif &options &mode s1 s2)
 911      BI
 912      (OPTIONS BIMODE RTX RTX) (NA NA ANYINT ANYINT)
 913      BINARY ; IF?
 914      #f
 915 )
 916 \f
 917 ; `bitfield' is an experimental operation.
 918 ; It's not really needed but it might help simplify some things.
 919 ;
 920 ;(drn (bitfield mode src start length)
 921 ;     ...
 922 ;     ...
 923 ;)
 924 \f
 925 ; Conversions.
 926
 927 (drn (ext &options &mode s1)
 928      #f
 929      (OPTIONS ANYINTMODE RTX) (NA NA ANY)
 930      UNARY
 931      #f
 932 )
 933 (drn (zext &options &mode s1)
 934      #f
 935      (OPTIONS ANYINTMODE RTX) (NA NA ANY)
 936      UNARY
 937      #f
 938 )
 939 (drn (trunc &options &mode s1)
 940      #f
 941      (OPTIONS ANYINTMODE RTX) (NA NA ANY)
 942      UNARY
 943      #f
 944 )
 945 (drn (fext &options &mode s1)
 946      #f
 947      (OPTIONS ANYFLOATMODE RTX) (NA NA ANY)
 948      UNARY
 949      #f
 950 )
 951 (drn (ftrunc &options &mode s1)
 952      #f
 953      (OPTIONS ANYFLOATMODE RTX) (NA NA ANY)
 954      UNARY
 955      #f
 956 )
 957 (drn (float &options &mode s1)
 958      #f
 959      (OPTIONS ANYFLOATMODE RTX) (NA NA ANY)
 960      UNARY
 961      #f
 962 )
 963 (drn (ufloat &options &mode s1)
 964      #f
 965      (OPTIONS ANYFLOATMODE RTX) (NA NA ANY)
 966      UNARY
 967      #f
 968 )
 969 (drn (fix &options &mode s1)
 970      #f
 971      (OPTIONS ANYINTMODE RTX) (NA NA ANY)
 972      UNARY
 973      #f
 974 )
 975 (drn (ufix &options &mode s1)
 976      #f
 977      (OPTIONS ANYINTMODE RTX) (NA NA ANY)
 978      UNARY
 979      #f
 980 )
 981 \f
 982 ; Comparisons.
 983 ; MODE is the mode of S1,S2.  The result always has mode BI.
 984
 985 (drn (eq &options &mode s1 s2)
 986      BI
 987      (OPTIONS ANYNUMMODE RTX RTX) (NA NA MATCHEXPR MATCH2)
 988      COMPARE
 989      #f
 990 )
 991 (drn (ne &options &mode s1 s2)
 992      BI
 993      (OPTIONS ANYNUMMODE RTX RTX) (NA NA MATCHEXPR MATCH2)
 994      COMPARE
 995      #f
 996 )
 997 ; ??? In non-sim case, ensure s1,s2 is in right C type for right result.
 998 (drn (lt &options &mode s1 s2)
 999      BI
1000      (OPTIONS ANYNUMMODE RTX RTX) (NA NA MATCHEXPR MATCH2)
1001      COMPARE
1002      #f
1003 )
1004 (drn (le &options &mode s1 s2)
1005      BI
1006      (OPTIONS ANYNUMMODE RTX RTX) (NA NA MATCHEXPR MATCH2)
1007      COMPARE
1008      #f
1009 )
1010 (drn (gt &options &mode s1 s2)
1011      BI
1012      (OPTIONS ANYNUMMODE RTX RTX) (NA NA MATCHEXPR MATCH2)
1013      COMPARE
1014      #f
1015 )
1016 (drn (ge &options &mode s1 s2)
1017      BI
1018      (OPTIONS ANYNUMMODE RTX RTX) (NA NA MATCHEXPR MATCH2)
1019      COMPARE
1020      #f
1021 )
1022 ; ??? In non-sim case, ensure s1,s2 is in right C type for right result.
1023 (drn (ltu &options &mode s1 s2)
1024      BI
1025      (OPTIONS ANYNUMMODE RTX RTX) (NA NA MATCHEXPR MATCH2)
1026      COMPARE
1027      #f
1028 )
1029 (drn (leu &options &mode s1 s2)
1030      BI
1031      (OPTIONS ANYNUMMODE RTX RTX) (NA NA MATCHEXPR MATCH2)
1032      COMPARE
1033      #f
1034 )
1035 (drn (gtu &options &mode s1 s2)
1036      BI
1037      (OPTIONS ANYNUMMODE RTX RTX) (NA NA MATCHEXPR MATCH2)
1038      COMPARE
1039      #f
1040 )
1041 (drn (geu &options &mode s1 s2)
1042      BI
1043      (OPTIONS ANYNUMMODE RTX RTX) (NA NA MATCHEXPR MATCH2)
1044      COMPARE
1045      #f
1046 )
1047 \f
1048 ; Set membership.
1049 ; Useful in ifield assertions.
1050
1051 ; Return a boolean (BI mode) indicating if VALUE is in SET.
1052 ; VALUE is any constant rtx.  SET is a `number-list' rtx.
1053
1054 (drn (member &options &mode value set)
1055      #f
1056      (OPTIONS BIMODE RTX RTX) (NA NA INT INT)
1057      MISC
1058      (begin
1059        (if (not (rtx-constant? value))
1060            (estate-error *estate* "`member rtx'"
1061                          "value is not a constant" value))
1062        (if (not (rtx-kind? 'number-list set))
1063            (estate-error *estate* "`member' rtx"
1064                          "set is not a `number-list' rtx" set))
1065        (if (memq (rtx-constant-value value) (rtx-number-list-values set))
1066            (rtx-true)
1067            (rtx-false)))
1068 )
1069
1070 ;; FIXME: "number" in "number-list" implies floats are ok.
1071 ;; Rename to integer-list, int-list, or some such.
1072
1073 (drn (number-list &options &mode value-list)
1074      #f
1075      (OPTIONS INTMODE NUMBER . NUMBER) (NA NA NA . NA)
1076      MISC
1077      #f
1078 )
1079 \f
1080 ; Conditional execution.
1081
1082 ; FIXME: make syntax node?
1083 (drn (if &options &mode cond then . else)
1084      #f
1085      ;; ??? It would be cleaner if TESTRTX had to have BI mode.
1086      (OPTIONS VOIDORNUMMODE TESTRTX RTX . RTX) (NA NA ANYINT MATCHEXPR . MATCH3)
1087      IF
1088      (apply e-if (append! (list *estate* mode cond then) else))
1089 )
1090
1091 ; ??? The syntax here isn't quite that of Scheme.  A condition must be
1092 ; followed by a result expression.
1093 ; ??? The syntax here isn't quite right, there must be at least one cond rtx.
1094 ; ??? Intermediate expressions (the ones before the last one) needn't have
1095 ; the same mode as the result.
1096 (drsn (cond &options &mode . cond-code-list)
1097      #f
1098       (OPTIONS VOIDORNUMMODE . CONDRTX) (NA NA . MATCHEXPR)
1099       COND
1100       #f
1101 )
1102
1103 ; ??? The syntax here isn't quite right, there must be at least one case.
1104 ; ??? Intermediate expressions (the ones before the last one) needn't have
1105 ; the same mode as the result.
1106 (drn (case &options &mode test . case-list)
1107      #f
1108      (OPTIONS VOIDORNUMMODE RTX . CASERTX) (NA NA ANY . MATCHEXPR)
1109      COND
1110      #f
1111 )
1112 \f
1113 ; parallel, sequence, do-count, closure
1114
1115 ; This has to be a syntax node as we don't want EXPRS to be pre-evaluated.
1116 ; All semantic ops must have a mode, though here it must be VOID.
1117 ; IGNORE is for consistency with sequence.  ??? Delete some day.
1118 ; ??? There's no real need for mode either, but convention requires it.
1119
1120 (drsn (parallel &options &mode ignore expr . exprs)
1121      #f
1122       (OPTIONS VOIDMODE LOCALS RTX . RTX) (NA NA NA VOID . VOID)
1123       SEQUENCE
1124       #f
1125 )
1126
1127 ; This has to be a syntax node to handle locals properly: they're not defined
1128 ; yet and thus pre-evaluating the expressions doesn't work.
1129 ; ??? This should create a closure.
1130
1131 (drsn (sequence &options &mode locals expr . exprs)
1132      #f
1133       (OPTIONS VOIDORNUMMODE LOCALS RTX . RTX) (NA NA NA MATCHSEQ . MATCHSEQ)
1134       SEQUENCE
1135       #f
1136 )
1137
1138 ; This has to be a syntax node to handle iter-var properly: it's not defined
1139 ; yet and thus pre-evaluating the expressions doesn't work.
1140
1141 (drsn (do-count &options &mode iter-var nr-times expr . exprs)
1142      #f
1143       (OPTIONS VOIDMODE ITERATION RTX RTX . RTX) (NA NA NA INT VOID . VOID)
1144       SEQUENCE
1145       #f
1146 )
1147
1148 ; Internal rtx to create a closure.
1149 ; Internal, so it does not appear in rtl.texi.
1150
1151 (drsn (closure &options &mode expr env)
1152      #f
1153       (OPTIONS VOIDORNUMMODE RTX ENV) (NA NA MATCHEXPR NA)
1154       MISC
1155       #f
1156 )
1157 \f
1158 )) ; End of def-rtx-funcs