s566_prj.stp

realview22.rar

                           \C (,-fforce-addr)
    inline=B0           \\ Attempt to insert all simple functions in-line  \
                           \C (,-finline-functions)
    keep_inline=B0      \\ Create a separate run time callable version of in-lined function \
                           \C (,-fkeep-inline-functions)
    {.registers
      extra_use=B0      \\ Utilize registers normally reserved for function calls       \
                           \C (,-fcaller-saves)
      fixed_use=LD      \\ Mark register (r0-r5) as fixed (compiler does not use) \
                           \C ?* -ffixed-$VALUE
    }
    tertiary=B0         \\ Allow mismatched types (2nd, 3rd arguments) in expression    \
                           \C (,-fcond-mismatch)
    peephole=B0         \\ Disable peephole portion of optimization     \
                           \C (,-fno-peephole)
    strength_reduce=B0  \\ Disable optimizations of loop strength       \
                           \C (,-fno-strength-reduce)
    stack_pop=K(speed,size)0    \\ Disable stack pop optimization       \
                           \C (,-fno-defer-pop)
    volatile=B0         \\ Consider memory references through pointers to be volatile \
                           \C (,-fvolatile)

    write_strings=B0    \\ Store string constants in writable data spaced \
                           \C (,-fwritable-strings)
    enhancements=B0     \\ Disable all Motorola optimizer enhancements  \
                           \C (,-mno-dsp-optimization)
    optimizer=B0        \\ Disable all optimizations (override setting) \
                           \C (,-fno-opt)
}
# Compilation settings allow control of various compiler actions. Most of
# these will not need to be changed for normal development.
{.Compile_Options       \\ Control of compilation
  strict_ANSI=B0        \\ Compile according to strict ANSI standard C  \
                           \C (,-pedantic)
  data_usage=K(X_Memory,Y_Memory,L_Memory)1     \
                        \\ Direct the compiler to use specific data memory (stack, etc.) \
                           \C (-mx-memory,-my-memory,-ml-memory)
  speed_vs_space=K(speed,space)0 \\ Generate call to prolog\epilog library code \
                           \C (,-mconserve-p-mem)
  stack_check=B0        \\ Generate code to detect stack/heap collisions \
                           \C (,-mstack-check)
  switch_tables=B0      \\ Force the compiler to locate switch tables in Program space \
                           \C (,-mp-mem-switchtable)  
  DO_instruction=B0     \\ Disable DO instruction usage by the optimizer \
                           \C (,mno-do-loop-generation)
  generate_debug=B1     \\ Produce information for debugging \C (,-g)
  verbose_mode=B1       \\ Compiler should be verbose during processing \
                           \C (,-Q)
}
# [e-mail]>settings ; The ASSEMBLE group contains the assembler sources to be assembled in the
# project. The default build (ASSEMBLE=default) contains the normal build
# rules for all sources. If some sources need to be assembled differently,
# a new ASSEMBLE group can be created that contains these alternate
# rules.
[TEMPLATE=ASSEMBLE]     \\ Defines assembler rule order $$FLG $$SRC $$OBJ  \
                           \C $$FLG $$SRC
# [e-mail]>settings ; 
disable=B0              \\ Removes this assemble group from build \
                           \C (,$<DIS=1>)
# [e-mail]>settings ; The file list contains the list of sources to assemble with for this
# assemble group. These should only be assembler sources.
files=LF(Sources [*.asm;*.s;*.src],$CWD) \\ Source files to assemble \
                           \C{*} ? $<SRC=$VALUE>
# [e-mail]>settings ; The obj-location field contains information on where the object files
# should be placed relative to the sources. The default is to put the
# objects in the base directory of the project. An alternate is to put
# them in a subidrectory of the base. Another alternate is to put them
# in the same location as the sources or a sub-directory of the sources.
# If a sub-directory is chosen, the obj_sub name is used; if not given,
# "objects" is used. The source directory choice will use the same
# directory as each source or a sub-directory of that source if obj_sub
# is filled in. The sub-directories will be automatically created.
obj_location=K(local,sub_dir,same_as_source)0 \\ Where to put object files\K\
                        In project base directory,\
                        In object subdirectory from base,\
                        In source directory \
                        \C (,$<OBJ=[$"obj_sub",$"obj_sub",objects]>\
                             ,$<OBJ=$$SPA/$"obj_sub">)
# [e-mail]>settings ; If the obj_location is selected as sub_dir, this specifies the name
# of the sub-directory.
obj_sub=S               \\ Sub-directory name for output (if not local) \C
# [e-mail]>settings ; The tool directory specified in the project or tool location file
# will be used to find the assembler. The name of the assembler is
# given in the tool location file. If you want to use a different
# location or name, you can set tool_path here.
tool_path=F(EXE)        \\ Pathname of assembler if different than tools \
                           \C ? $<EXE=$VALUE>
{.File_control          \\ Control file searching and output
  include=LD            \\ Paths for include directives \
                           \C ?* -I$VALUE
  listing=LF            \\ Produce a listing file (.lst) \C ?* -L$VALUE
  macro=LD              \\ Macro Library Path(s)        \
                           \C ?* -M$VALUE
  output=LF             \\ Assembler output filename    \
                           \C ?* -B$VALUE
}
{.Symbol_Control                \\ Control symbol handling in the assembler
  absolute_mode=B0      \\ Assembler operates in absolute mode. Use File  \
                        \\ control to output filename \
                           \C (,-A)
  generate_debug=B1     \\ Include source file symbol information       \
                           \C (-Z,-G)
  define=LS             \\ Define symbol \C ?* -D$VALUE
}
{.Assembler_Advanced    \\ Advanced Assembler Options
  command_file=LF               \\ File for further command arguments   \
                           \C ?* -F$VALUE
  OPT_Directives=LD     \\ Specify assembler OPT directive(s)           \
                           \C ?* -O$VALUE
  revision_control=LD   \\ Run without the specified processor revision \
                        \\ enhancements \
                           \C ?* -R$VALUE
  verbose_mode=B1       \\ Assembler should be verbose during processing \
                           \C (,-V)
}
# [e-mail]>settings ; Extra-args is used to add special assembler switches not controlled
# below.
extra_args=S            \\ Any extra assembler arguments to use \
                           \C ?* $VALUE
# [e-mail]>settings ; The BUILD group (there can only be one) is used to link the 
# objects created by COMPILE, ASSEMBLE, and CUSTOM groups into
# an application. This will invoke the linker after all other
# files have be checked for rebuild. The BUILD group allows for
# pre-link and post-link commands to be used as well.
[TEMPLATE=BUILD]        \\ Defines linker rules \C$DEF_LINK_ARGS
# Removes this BUILD group from being used
disable=B0              \\ Removes this BUILD group from being used \
                        \C (,$<DIS=1>)
# [e-mail]>settings ; The application name is the executable file to load into the
# debugger. It is normally placed in the base directory unless
# a path is specified.
application=F(Applications [*.cld]) \\ Name of target application to build \
                           \C ?* -B$VALUE
# A Linker command file is an ASCII file containing linker
# options (if needed), memory mapping information, and a
# list of libraries (if needed). The memory map can be created
# by ASPEX from the Mapping Manager. The options normally would
# be created using the GUI switches below. The filename must
# end in .cmd for the linker to recognize it. The default
# will be set based on the project template and whether C files
# have been used.
command_file=F(Commands [*.cmd])$DEF_CMD_FILE   \\ Name of optional command file for build (.cmd) \
                           \C ?* $<SRC=-F$VALUE>
# The Library paths coerce the search order for libraries. If
# a library is specified by name only (above or in the linker
# command file), this will indicate where to look for it.
library_paths=LD$?DEF_LIB_PATH \\ Define search paths for libraries \
                           \C ?* -P$VALUE
# Objects are used when you want to link in object files that
# are not built as part of this project. This is used when these
# files are not part of a library. An example would be files
# that are built as part of a different project that you do
# not want to build again.
objects=LF$DEF_OBJ_FILE \\ Name of pre-built objects to link    \
                           \C ?* $<OBJ=$VALUE>
# Libraries are packages of object files to be searches for
# matching symbols (functions usually) to complete the executable.
# The linker command file may contain the name of some libraries
# as well. The files may use full paths or just filenames.
libraries=LF(Library [*.clb])$DEF_LIB_FILE \\ Define libraries to link in \
                           \C ?* $<OBJ=-L$VALUE>
# Extra-args is used to add special linker switches not controlled
# below.
extra_args=S            \\ Any extra Linker arguments to use \
                           \C ?* $VALUE
# The tool directory specified in the project or tool location file
# will be used to find the linker. The name of the linker is
# given in the tool location file. If you want to use a different
# location or name, you can set tool_path here.
tool_path=F(EXE)        \\ Pathname of linker if different than tools \
                           \C ?* $<EXE=$VALUE>
# Each project builds a makefile. This names the makefile to
# create.
makefile=F(Makefiles [*.mk;Makefile;makefile])  \\ Makefile to write out to \C
# Makefile template allows overriding the default Genmake template provided
# by RVD for the processor. You can create your own from the base version
# and then specify it here.
make_template=F(Makefile Template [gen*.mk]) \\ Optional genmake template to use for makefile \C
# Linker map file
map_file=F(Map Files [*.map]) \\ Specify mapfile \C ?* -M$VALUE

{.Link_Advanced         \\ Advanced linker commands
  outfile_type=K(absolute,relocatable)   \\ Type of output file \C (,-I)
  {.Redefine_Memory     \\ Redefine the start address for any memory space
    {.Program_start
    location_counter=K(High,Low)        \\ Location counter (H)igh (L)ow        \
                           \C ?* (H,L)
    physical_map=K(Internal,External,Bootstrap) \
                        \\ Physical mapping (I)nternal (E)xternal (B)ootstrap   \
                           \C ?* (I,E,B)
    address=S           \\ Define starting address      \
                           \C ?* -OP$"location_counter"$"physical_map":$VALUE
    }
    {.X_Memory_start
    location_counter=K(High,Low)        \\ Location counter (H)igh (L)ow        \
                           \C ?* (H,L)
    physical_map=K(Internal,External,Bootstrap) \
                        \\ Physical mapping (I)nternal (E)xternal (B)ootstrap   \
                           \C ?* (I,E,B)
    address=S           \\ Define starting address      \
                           \C ?* -OX$"location_counter"$"physical_map":$VALUE
    }
    {.Y_Memory_start
    location_counter=K(High,Low)        \\ Location counter (H)igh (L)ow        \
                           \C ?* (H,L)
    physical_map=K(Internal,External,Bootstrap) \
                        \\ Physical mapping (I)nternal (E)xternal (B)ootstrap   \
                           \C ?* (I,E,B)
    address=S           \\ Define starting address      \
                           \C ?* -O$$"location_counter"$"physical_map":$VALUE
    }
    {.Y_Memory_start
    location_counter=K(High,Low)        \\ Location counter (H)igh (L)ow        \
                           \C ?* (H,L)
    physical_map=K(Internal,External,Bootstrap) \
                        \\ Physical mapping (I)nternal (E)xternal (B)ootstrap   \
                           \C ?* (I,E,B)
    address=S           \\ Define starting address      \
                           \C ?* -OY$"location_counter"$"physical_map":$VALUE
    }
  }
  memory_control=LF     \\ Memory control file  \
                           \C ?* -R$VALUE
  ignore_case=B0        \\ Linker should ignore case in symbols \
                           \C (,-N)
  verbose_mode=B1       \\ Linker should be verbose during processing   \
                           \C (,-V)
}
{.Symbol_Control        \\ Symbol Controls
  undefine=LS           \\ Create unresolved external \C ?* -U$VALUE
  generate_debug=B1     \\ Include source file symbol information       \
                           \C (-Z,-G)
}
# Pre and Post Link commands allow insertion of specific commands
# to run just prior to linkage and right after. These can be
# OS commands (DOS/Windows or UNIX shell) and any program on
# the local system. Use of "$(MACRO_NAME)" will allow access to
# any make macro (e.g. $(PROGRAM) is the output program). Note
# that under Windows, you need to put a plus sign (+) in front
# of shell commands (e.g. "+echo this is a message"). You may
# browse the makefile to see what macros are available for these
# commands.
{.Pre_Post_Link         \\ Operating Systems commands for before/after link
  pre_link=LS           \\ OS commands to execute before link \
                           \C ?* $<PRV=pre=$VALUE>
  post_link=LS          \\ OS commands to execute after link \
                           \C ?* $<PRV=pos=$VALUE>
}
{.Aspex_Commands        \\ ASPEX commands to execute after build
# Post_build commands are run after the build is complete and
# there were no errors. A "%s" may be used in the commands to 
# have the target filename expanded.
  post_build=LS         \\ ASPEX Commands to execute after a build \
                           \C
}