Subversion Repositories scarts

; Simulator generator support routines.

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

; This file is part of CGEN.

; i.e. this file fills in the missing pieces of the interface between

; the application independent part of CGEN (i.e. the code loaded by read.scm)

; and the application dependent part (i.e. sim-*.scm).

; `send' is not intended to appear in sim-*.scm.

; [It still does but that's to be fixed.]

; Specify which application.

; Currently supported options:

; with-scache

; with-pbb

; with-sem-frags

;       generate semantic fragment engine (requires with-pbb)

; with-profile fn|sw

;       generate code to do profiling in the semantic function

;       code (fn) or in the semantic switch (sw)

; with-multiple-isa

;       enable multiple-isa support (e.g. arm+thumb)

;       ??? wip.

; copyright fsf|redhat

;       emit an FSF or Red Hat copyright (temporary, pending decision)

; package gnusim|cygsim

;       indicate the software package

; #t if the scache is being used

; #t if we're generating profiling code

; Each of the function and switch semantic code can have profiling.

; The options as passed are stored in -with-profile-{fn,sw}?, and

; -with-profile? is set at code generation time.

; #t if semantics are generated as pbb computed-goto engine

; #t if the semantic fragment engine is to be used.

; This involves combining common fragments of each insn into one.

; String containing text defining the package we're generating code for.

; Initialize the options.

; Handle an option passed in from the command line.

"fn""sw""invalid with-profile value""fsf""redhat""invalid copyright value""gnusim""cygsim""invalid package value""unknown option"; #t if we're currently generating a pbb engine.

; #t if the cpu can execute insns parallely.

; This one isn't passed on the command line, but we follow the convention

; of prefixing these things with `with-'.

; While processing operand reading (or writing), parallel execution support

; needs to be turned off, so it is up to the appropriate cgen-foo.c proc to

; Kind of parallel support.

; If 'read, read pre-processing is done.

; If 'write, write post-processing is done.

; version used read pre-processing.  Not sure supporting both is useful

; in the long run.

; #t if parallel support is provided by read pre-processing.

; Cover functions for various methods.

; Return the C type of something.  This isn't always a mode.

; Return the C type of an index's value or #f if not needed (scalar).

; Misc. utilities.

; ISAS is a list of <isa> objects.

; The idea is that in multiple isa architectures (e.g. arm) the elements

; isa are kept in separate classes.

"current_cpu->@cpu@_hardware.""current_cpu->hardware."; Attribute support.

; PC-VAR is the C expression containing the address of the start of the

;

; We don't bother trying to handle bitsizes that don't have a

; corresponding GETIMEM method.  Doing so would require us to take

; endianness into account just to ensure that the requested bits end

; up at the proper place in the result.  It's easier just to make the

; caller ask us for something we can do directly.

;

; ??? Aligned/unaligned support?

"current_cpu->GETIMEM""UQI""UHI""USI""bad bitsize argument to gen-ifetch"" (pc, "" + "")"; Return definition of an object's attributes.

; This is like gen-obj-attr-defn, except split for sid.

; TYPE is one of 'ifld, 'hw, 'operand, 'insn.

; ALL-ATTRS is an ordered alist of all attributes.

; duplicate entries have been removed.

"{ "","" 0"; drop the leading ","

; FIXME: Are we missing attr-prefix here?

", "" }"; Instruction field support code.

; Return a <c-expr> object of the value of an ifield.

; ??? Perhaps a better way would be to defer evaluating the src of a

; set until the method processing the dest.

""; Type system.

; Methods:

; gen-type - return C code representing the type

; gen-sym-decl - generate decl using the provided symbol

; gen-sym-get-macro - generate GET macro for accessing CPU elements

; gen-sym-set-macro - generate SET macro for accessing CPU elements

; Scalar type

"  /* "" */\n""  "" "";\n"; Array type

"  /* "" */\n""  "" "";\n"; Return a reference to the array.

; SYM is the name of the array.

; INDEX is either a single index object or a (possibly empty) list of objects,

; one object per dimension.

"[""]"; Integers

;

;(method-make!

; <integer> 'gen-type

; (lambda (self)

;   (mode:c-type (mode-find (elm-get self 'bits)

;                              'UINT 'INT)))

;   )

;)

;

;(method-make! <integer> 'gen-sym-get-macro (lambda (self sym comment) ""))

;(method-make! <integer> 'gen-sym-set-macro (lambda (self sym comment) ""))

; Hardware descriptions support code.

;

; Various operations are required for each h/w object to support the various

; things the simulator will want to do with it.

;

; Methods:

; gen-decl

; cxmake-get    - Return a <c-expr> object to fetch the value.

; gen-set-quiet - Set the value.

;                 ??? Could just call this gen-set as there is no gen-set-trace

;                 but for consistency with the messages passed to operands

;                 we use this same.

; gen-type      - C type to use to record value.

;                 ??? Delete and just use get-mode?

; save-index?   - return #t if an index needs to be saved for parallel

;                 execution post-write processing

; gen-profile-decl

; gen-record-profile

; get-mode

; gen-profile-locals

; gen-sym-decl  - Return a C declaration using the provided symbol.

; gen-sym-get-macro - Generate default GET access macro.

; gen-ref       - Return a C reference to the object.

""; Return a C reference to a hardware object.

"gen-write method not overridden:"; gen-type handler, must be overridden

""; nothing to do

; Return a <c-expr> object of the value of SELF.

; ESTATE is the current rtl evaluator state.

; INDEX is a <hw-index> object.  It must be an ifield.

; SELECTOR is a hardware selector RTX.

;(if (not (eq? 'ifield (hw-index:type index)))

;    (error "not an ifield hw-index" index))

; 'gen-set-quiet helper for PC values.

; If OPTIONS contains #:direct, set the PC directly, bypassing semantic

; code considerations.

; ??? OPTIONS support wip.  Probably want a new form (or extend existing form)

; of rtx: that takes a variable number of named arguments.

; ??? Another way to get #:direct might be (raw-reg h-pc).

; This is done in a post-processing pass after semantic evaluation.

; SFMT is the <sformat>.

; OP is the operand.

; ACCESS-MACRO is the runtime C macro to use to fetch indices computed

; during semantic evaluation.

;

; At this point I'm reluctant to willy nilly make methods virtual.

; Forward these methods onto TYPE.

; For parallel instructions supported by queueing outputs for later update,

; return a boolean indicating if an index needs to be recorded.

; An example of when the index isn't needed is if the index can be determined

; during extraction.

; For array registers, we need to store away the index. 

; Handle updates of registers during parallel execution.

; This is done in a post-processing pass after semantic evaluation.

; SFMT is the <sformat>.

; OP is the <operand>.

; ACCESS-MACRO is the runtime C macro to use to fetch indices computed

; FIXME: May need mode of OP.

; First get a hw-index object to use during indexing.

; Some indices, e.g. memory addresses, are computed during semantic

; evaluation.  Others are computed during the extraction phase.

"  "" ("")""  /* "" */\n""  unsigned long "";\n"; FIXME: Need to handle scalars.

;(send index 'gen-extracted-field-value)

; Utilities to generate register accesses via cover functions.

"current_cpu->"" ("""")""current_cpu->"" ("""", "");\n"; Utility to build a <c-expr> object to fetch the value of a register.

; If the register is accessed via a cover function/macro, do it.

; Otherwise fetch the value from the cached address or from the CPU struct.

; FIXME: redo test

; ??? raw-reg: support is wip

; Utilities to generate C code to assign a variable to a register.

; FIXME: redo test

"* "" = "";\n"" = "";\n"; raw-reg: support

; ??? wip

" = "";\n"; Return method name of access function.

; Common elements have no prefix.

"_""""_get""_""""_set"; Memory support.

"current_cpu->GETMEM""""ASI"" (""pc, """", "")""current_cpu->SETMEM""""ASI"" (""pc, """", "", "");\n"""""""; For parallel instructions supported by queueing outputs for later update,

; return the type of the index or #f if not needed.

; In the case of the complete memory address being an immediate

; argument, we can return #f (later).

"  "" ("")"; Immediates, addresses.

; Forward these methods onto TYPE.

"gen-write of <hw-immediate> shouldn't happen"; FIXME.

"ADDR"""""""; Return a <c-expr> object of the value of SELF.

; ESTATE is the current rtl evaluator state.

; INDEX is a hw-index object.  It must be an ifield.

; Needed because we record our own copy of the ifield in ARGBUF.

; SELECTOR is a hardware selector RTX.

"not an ifield hw-index""gen-write of <hw-address> shouldn't happen"; FIXME: revisit.

"IADDR"; Return a <c-expr> object of the value of SELF.

; ESTATE is the current rtl evaluator state.

; INDEX is a <hw-index> object.  It must be an ifield.

; Needed because we record our own copy of the ifield in ARGBUF,

; *and* because we want to record in the result the 'CACHED attribute

; since instruction addresses based on ifields are fixed [and thus cacheable].

; SELECTOR is a hardware selector RTX.

; set until the method processing the dest.

; Return the index to use by the gen-write method.

; execution time), the index is computed along with the value to be stored,

; so this is easy.

" ("")"; Return the name of the PAREXEC structure member holding a hardware index

; for operand OP.

"_idx"; Cover fn to hardware indices to generate the actual C code.

; INDEX is the hw-index object (i.e. op:index).

; The result is a string of C code.

; FIXME:wip

; ??? May wish to handle more similarily.

; e.g. doing array index calcs at extraction time.

"""(("") "")""""-gen-hw-index: invalid index:"; Return a <c-expr> object of the value of a hardware index.

; If MODE is VOID, abort.

"hw-index:cxmake-get: result needs a mode"; FIXME: Temporary hack to generate same code as before.

; Hardware selector support code.

; Instruction operand support code.

; gen-type      - Return C type to use to hold operand's value.

; gen-read      - Record an operand's value prior to parallely executing

;                 several instructions.  Not used if gen-write used.

; gen-write     - Write back an operand's value after parallely executing

; cxmake-get    - Return C code to fetch the value of an operand.

; gen-set-quiet - Return C code to set the value of an operand.

; gen-set-trace - Return C code to set the value of an operand, and print

;                 a result trace message.  ??? Ideally this will go away when

;                 trace record support is complete.

; Return the C type of an operand.

; Generally we forward things on to TYPE, but for the actual type we need to

; use the get-mode method.

; First get the mode.

; Extra pc operand methods.

"pc"; Default gen-read method.

; This is used to help support targets with parallel insns.

; Either this or gen-write (but not both) is used.

"  "" ("") = "; Pass #f for the index -> use the operand's builtin index.

";\n"; Forward gen-write onto the <hardware> object.

; If operand is conditionally written, we have to check that first.

; ??? If two (or more) operands are written based on the same condition,

; all the tests can be collapsed together.  Not sure that's a big

; enough win yet.

"  if (written & (1ULL << ""))\n""    {\n""    ""    }\n"; Return <c-expr> object to get the value of an operand.

; ESTATE is the current rtl evaluator state.

; If INDEX is non-#f use it, otherwise use (op:index self).

; This special handling of #f for INDEX is *only* supported for operands

; in cxmake-get, gen-set-quiet, and gen-set-trace.

; Ditto for SELECTOR.

"  {\n""    "" opval = "";\n""    written |= (1ULL << "");\n"""; TRACE_RESULT_<MODE> (cpu, abuf, hwnum, opnum, value);

; For each insn record array of operand numbers [or indices into

; operand instance table].

; Could just scan the operand table for the operand or hardware number,

"""    if (UNLIKELY(current_cpu->trace_result_p))\n""      current_cpu->trace_stream << "" << '['"" << "; print memory addresses in hex

"\"memory\""" \"0x\" << hex << (UDI) """"\"memory\""" << dec"""" << ']'"""" << \":=0x\" << hex << "; Add (SI) or (USI) cast for byte-wide data, to prevent C++ iostreams

; from printing byte as plain raw char.

"(SI) ""(USI) """"opval << dec << \"  \";\n"; Dispatch to setter code if appropriate

"    ""opval""opval";else

"opval""  }\n""    ""_memory"""""""", ""  {\n";; delayed write: push it to the appropriate buffer

" opval = "";\n""buf.""_writes [(tick + "") % @prefix@::pipe_sz].push (@prefix@::write<"">(pc, opval""));\n";; else, uh, we should never have been called!

"-op-gen-delayed-set-maybe-trace called on non-delayed operand"; TRACE_RESULT_<MODE> (cpu, abuf, hwnum, opnum, value);

; For each insn record array of operand numbers [or indices into

; operand instance table].

; Could just scan the operand table for the operand or hardware number,

"    if (UNLIKELY(current_cpu->trace_result_p))\n""      current_cpu->trace_stream << "" << '['"" << "; print memory addresses in hex

"\"memory\""" \"0x\" << hex << (UDI) """"\"memory\""" << dec"""" << ']'"""" << \":=0x\" << hex << ";; Add (SI) or (USI) cast for byte-wide data, to prevent C++ iostreams

;; from printing byte as plain raw char.

"(SI) ""(USI) """"opval << dec << \"  \";\n""  }\n";; else no tracing is emitted

""; Return C code to set the value of an operand.

; NEWVAL is a <c-expr> object of the value to store.

; If INDEX is non-#f use it, otherwise use (op:index self).

; This special handling of #f for INDEX is *only* supported for operands

; in cxmake-get, gen-set-quiet, and gen-set-trace.

; Ditto for SELECTOR.

; Return C code to set the value of an operand and print TRACE_RESULT message.

; NEWVAL is a <c-expr> object of the value to store.

; If INDEX is non-#f use it, otherwise use (op:index self).

; This special handling of #f for INDEX is *only* supported for operands

; Ditto for SELECTOR.

; Operand profiling and parallel execution support.

; Return boolean indicating if operand OP needs its index saved

; (for parallel write post-processing support).

; Return C code to record profile data for modeling use.

; In the case of a register, this is usually the register's number.

; This shouldn't be called in the case of a scalar, the code should be

; smart enough to know there is no need.

"c++"; Return C code to record the data needed for profiling operand SELF.

; This is done during extraction.

"""      ""out_""in_"" = "";\n"; Return C code to track profiling of operand SELF.

; This is usually called by the x-after handler.

"  ""@prefix@_model_mark_""set_""get_""_"" (current_cpu"""", ""out_""in_"");\n"; CPU, mach, model support.

; Return the declaration of the cpu/insn enum.

"@prefix@_insn_type""instructions in cpu family @prefix@""@PREFIX@_INSN_"; Return the enum of INSN in cpu family CPU.

; In addition to CGEN_INSN_TYPE, an enum is created for each insn in each

; cpu family.  This collapses the insn enum space for each cpu to increase

; cache efficiently (since the IDESC table is similarily collapsed).

"@PREFIX@_INSN_"; Return C code to declare the machine data.

"extern const MACH ""_mach;\n""\n"; Return C code to define the machine data.

"const MACH *sim_machs[] =\n{\n""#ifdef ""\n""  & ""_mach,\n""#endif\n""  0\n""};\n\n"; Return C declarations of cpu model support stuff.

; ??? This goes in arch.h but a better place is each cpu.h.

"model types""MODEL_""#define MAX_MODELS ((int) MODEL_MAX)\n\n"; Function units.

""; Lookup operand named OP-NAME in INSN.

; Returns #f if OP-NAME is not an operand of INSN.

; and 'in-out to request either (though if an operand is used for input and

; FIXME: Move elsewhere.

"insn-op-lookup: bad arg:"; Return C code to profile a unit's usage.

; UNIT-NUM is number of the unit in INSN.

; OVERRIDES is a list of (name value) pairs, where

; - NAME is a spec name, one of cycles, pred, in, out.

;   as they appear in the semantic code to operand names as they appear in

; - VALUE is the operand to NAME.  For in,out it is (NAME VALUE) where

;   - VALUE is the name of the operand as it appears in semantic code.

; ??? This is a big sucker, though half of it is just the definitions

"  'gen-profile-code\n"; Return C code to initialize UNIT-REFERENCED-VAR to be a bit mask

; of operands of UNIT that were read/written by INSN.

; INSN-REFERENCED-VAR is a bitmask of operands read/written by INSN.

; All we have to do is map INSN-REFERENCED-VAR to

; UNIT-REFERENCED-VAR.

"    gen-ref-arg\n""insn_referenced""referenced""    ""if ("" & (1 << "")) "" |= 1 << "";\n""    "" |= 1 << "";\n"""; Initialize unit argument ARG.

"    gen-arg-unit\n"; Ignore scalars.

; Ignore remapped arg, handled elsewhere.

; Ignore operands not in INSN.

"""    ""out_""in_"" = ""out_""in_"";\n"; Return C code to declare variable to hold unit argument ARG.

"    gen-arg-decl ""\n"; ignore scalars

; OUT? is #f for input args, #t for output args.

""", ""out_""in_""  {\n""    int referenced = 0;\n""    unsigned long long insn_referenced = abuf->written;\n"""; Declare variables to hold unit arguments.

; Initialize 'em, being careful not to initialize an operand that

; has an override.

; Make a list of names of in/out overrides.

"""""""""    in_"" = ""in_"";\n""""    out_"" = ""out_"";\n""""insn function unit spec""invalid spec"; Create bitmask indicating which args were referenced.

"    "" += "" (current_cpu, idesc"", "", referenced"""");\n""  }\n"; Return C code to profile an insn-specific unit's usage.

; UNIT-NUM is number of the unit in INSN.

; Mode support.

; Generate a table of mode data.

; For now all we need is the names.

; mode here, so ignore them.

"};\n\n"; Insn profiling support.

; Generate declarations for local variables needed for modelling code.

;   (let ((cti? (or (has-attr? self 'UNCOND-CTI)

;                  (has-attr? self 'COND-CTI))))

;     (string-append

;      (if cti? "  int UNUSED taken_p = 0;\n" "")

""; Generate C code to profile INSN.

; Return list of all instructions to use for scache engine.

; This is all real insns plus the `invalid' and `cond' virtual insns.

; It does not include the pbb virtual insns.

; Return list of all instructions to use for pbb engine.

; This is all real insns plus the `invalid' and `cond' virtual insns.

;; Subroutine of -create-virtual-insns!.

;; Add virtual insn INSN to the database.

;; and it helps to see them first in lists.

;; ORDINAL is a used to place the insn ahead of normal insns;

;; it is a pair so we can do the update for the next virtual insn here.

; Create the virtual insns.

"virtual insns";; Record as a pair so -virtual-insn-add! can update it.

"invalid insn handler""--invalid--""\

  {

    current_cpu->invalid_insn (pc);

    assert (0);

    /* NOTREACHED */

  }

""pbb begin handler""--begin--""\

  {

    vpc = current_cpu->@prefix@_pbb_begin (current_cpu->h_pc_get ());

  }

""pbb chain handler""--chain--""\

  {

    vpc = current_cpu->@prefix@_engine.pbb_chain (current_cpu, abuf);

    // If we don't have to give up control, don't.

    // end of the block.  This is defined to be ok.

      BREAK (vpc);

  }

""pbb cti-chain handler""--cti-chain--""\

  {

    vpc = current_cpu->@prefix@_engine.pbb_cti_chain (current_cpu, abuf, pbb_br_status, pbb_br_npc);

    // If we don't have to give up control, don't.

    // Note that we may overrun step_insn_count since we do the test at the

    // end of the block.  This is defined to be ok.

    if (UNLIKELY(current_cpu->stop_after_insns_p (abuf->fields.chain.insn_count)))

  }

""pbb before handler""--before--""\

  {

    current_cpu->@prefix@_engine.pbb_before (current_cpu, abuf);

  }

""pbb after handler""--after--""\

  {

    current_cpu->@prefix@_engine.pbb_after (current_cpu, abuf);

"; If entire instruction set is conditionally executed, create a virtual

; insn to handle that.

"conditional exec test""--cond--""\

  {

    // Assume branch not taken.

    pbb_br_status = BRANCH_UNTAKEN;

    UINT cond_code = abuf->cond;

    BI exec_p = ""cond_code"";

    if (! exec_p)

      ++vpc;

  }

"; Return a boolean indicating if INSN should be split.

; Build the ifield-assertion for ifield F-NAME.

; Subroutine of -decode-split-insn.

; Specialize INSN according to <decode-split> dspec.

; Split INSN.

; The result is a list of the split copies of INSN.

"Splitting "" ...\n"; FIXME: check constraint

; Create copies of insns to be split.

; ??? better phrase needed?  Possible confusion with gcc's define-split.

; The original insns are then marked as aliases so the simulator ignores them.

"Splitting instructions ...\n";; Splice new insns next to original.

;; easier to read for human viewer.

;; This is done by using an ordinal of

;; (major . minor).

"Done splitting.\n"; .cpu file loading support

; Only run sim-analyze-insns! once.

; List of computed sformat argument buffers.

; Called before the .cpu file has been read in.

; Called after the .cpu file has been read in.

; go through methods, thus allowing the programmer to override them.

"read hardware elements via cover functions/methods""write hardware elements via cover functions/methods"; If there is a .sim file, load it.

"/cpu/"".sim""Loading sim file "" ...\n"; If we're building files for an isa, create the virtual insns.

; Called after file is read in and global error checks are done

; to initialize tables.

; Scan insns, copying them to the simulator insn list, splitting the

; requested insns, then analyze the semantics and compute instruction formats.

; needs to be done or not (which is determined by what files are being

; generated).  Since this is an expensive operation, we defer doing this

; to the files that need it.

; This can only be done if one isa and one cpu family is being kept.

; don't include aliases

; do analyze the semantics

; Compute the set of sformat argument buffers.

; Do our own error checking.