Subversion Repositories scarts

; Routines for instruction semantic analysis.

; Copyright (C) 2000, 2009 Red Hat, Inc.

; This file is part of CGEN.

; See file COPYING.CGEN for details.

;

; Semantic expression compilation.

; This is more involved than normal rtx compilation as we need to keep

; track of the inputs and outputs.  Various attributes that can be derived

; from the code are also computed.

; Two modes are equivalent if they're equal, or if their sem-mode fields

; are equal.

; Subroutine of semantic-compile to find OP in OP-LIST.

; The result is the list element or #f if not found.

; TYPE is one of -op- reg mem.

; EXPR is the constructed `xop' rtx expression for the operand,

;   ignored in the search.

; MODE must match, as defined by -rtx-mode-equiv?.

; NAME is the hardware element name, ifield name, or '-op-'.

; INDX-SEL must match if present in either.

;

; The first cdr is to drop the dummy first arg.

; Subroutine of semantic-compile to determine how the operand in

; position OP-POS of EXPR is used.

; The result is one of 'use, 'set, 'set-quiet.

; "use" means "input operand".

; operand 0 is the option list, operand 1 is the mode

; (if you want to complain, fine, it's not like it would be unexpected)

; Subroutine of semantic-compile:process-expr!, to simplify it.

; Looks up the operand in the current set, returns it if found,

; otherwise adds it.

; REF-TYPE is one of 'use, 'set, 'set-quiet.

;(display (list op-name mode ref-type)) (newline) (force-output)

; The first #f is a placeholder for the object.

; If already present, return the object, otherwise add it.

; We can't set the operand number yet 'cus we don't know it.

; However, when it's computed we'll need to set all associated

; operands.  This is done by creating shared rtx (a la gcc) - the

; operand number then need only be updated in one place.

; Set the object rtx in `try', now that we have it.

; Add the operand to in/out-ops.

; Subroutine of semantic-compile:process-expr!, to simplify it.

; If the mode is DFLT, use the object's natural mode.

; #f is a place-holder for the object (filled in later)

; If already present, return the object, otherwise add it.

; Set the object rtx in `try', now that we have it.

; Add the operand to in/out-ops.

"unknown reg"; Subroutine of semantic-compile:process-expr!, to simplify it.

"memory must have explicit mode"; If already present, return the object, otherwise add it.

; Add the operand to in/out-ops.

; Subroutine of semantic-compile:process-expr!, to simplify it.

"unknown ifield"; If already present, return the object, otherwise add it.

; Subroutine of semantic-compile:process-expr!, to simplify it.

; ??? There are various optimizations (both space usage in ARGBUF and time

; spent in semantic code) that can be done on code that uses index-of

; (see i960's movq insn).  Later.

"only `(index-of operand)' is currently supported""only ifield indices are currently supported"; The rest of this is identical to -build-ifield-operand!.

; If already present, return the object, otherwise add it.

; (send (op:type op) 'get-index-mode)

; Build the tstate known value list for INSN.

; This is built from the ifield-assertion list.

; Structure to record the result of semantic-compile.

; Accessors.

; and computing the input and output operands.

; The result is an object of four elements (built with csem-make).

; The first is a list of the canonical form of each element in SEM-CODE:

; operand and ifield elements specified without `operand' or `ifield' have it

; prepended, and operand numbers are computed for each operand.

; Having the operand numbers available is also useful for efficient

; modeling: recording operand references can be done with a bitmask (one host

; insn), and the code to do the modeling can be kept out of the code that

; performs the insn.

; The second is the list of input <operand> objects.

; The third is the list of output <operand> objects.

; The fourth is an <attr-list> object of attributes that can be computed from

; the semantics.

; ??? Combine *-CTI into an enum attribute.

;

; CONTEXT is a <context> object or #f if there is none.

; INSN is the <insn> object.

; ??? Specifying operand ordinals in the source would simplify this and speed

; it up.  On the other hand that makes the source form more complex.  Maybe the

; complication", we don't do this yet.

; input/output operands to the instruction description.

;

; ??? This calls rtx-simplify which calls rtx-traverse as it's simpler to

; simplify EXPR first, and then compile it.  On the other hand it's slower

; These record the result of traversing SEM-CODE.

; They're lists of (type object mode name [args ...]).

; TYPE is one of: -op- reg mem.

; `-op-' is just something unique and is only used internally.

; OBJECT is the constructed <operand> object.

; The first element is just a dummy so that append! always works.

; List of attributes computed from SEM-CODE.

; The first element is just a dummy so that append! always works.

; Don't waste cpu here, this is part of the slowest piece in CGEN.

; ??? could verify reg is a scalar

; The register number is either a number or an

; expression.

; significant ramifications.  On the other hand in cases

; where it matters the expression could always be

; required to reduce to a constant (or some such).

"invalid register number"; Memory.

; Operands.

; Give operand new name.

"name: invalid argument:"; (op:set-num! result (caddr expr))

; Specify a reference to a local variable

; nothing to do

"can't set an `ifield'"; Hardware indices.

; For registers this is the register number.

; For constants, this is the constant.

; Machine generate the DELAY-SLOT attribute.

; If this is a syntax expression, the operands won't have been

; processed, so tell our caller we want it to by returning #f.

; We do the same for non-syntax expressions to keep things

; simple.  This requires collaboration with the traversal

; handlers which are defined to do what we want if we return #f.

; Whew.  We're now ready to traverse the expression.

; Traverse the expression recording the operands and building objects

; for most elements in the source representation.

; In particular machine dependent code for non-selected machines

; is discarded.

;(display "out: ") (display out-ops) (newline)

; Now that we have the nub of all input and output operands,

; we can assign operand numbers.  Inputs and outputs are not defined

; separately, output operand numbers follow inputs.  This simplifies the

; The assignment is defined to be arbitrary.  If there comes a day

; when we need to prespecify operand numbers, revisit.

; The operand lists are sorted to avoid spurious differences in generated

; ARGBUF struct).

; Drop dummy first arg and sort operand lists.

; The result is an <attr-list> object of attributes that can be computed from

; the semantics.

; This computes the same values as semantic-compile, but for speed is

; ??? Combine *-CTI into an enum attribute.

;

; CONTEXT is a <context> object or #f if there is none.

; INSN is the <insn> object.

; List of attributes computed from SEM-CODE.

; The first element is just a dummy so that append! always works.

; Called for expressions encountered in SEM-CODE.

; Don't change these to '(FOO), since

; we use append!.

; processed, so tell our caller we want it to by returning #f.

; simple.  This requires collaboration with the traversal

; handlers which are defined to do what we want if we return #f.

; Traverse the expression recording the attributes.

""