Optimization Pragmas. NXP CodeWarrior Development Studio
Reklam
Reklam
Optimization Pragmas
NOTE
Other forms of the se_rfi
such as se_rfci
and se_rfdi
are also supported.
36.5 Optimization Pragmas
This section describes the optimization pragmas.
•
•
•
•
•
•
•
•
peephole_enable_16bit_load_store_inst
•
•
•
•
•
•
•
•
•
•
•
36.5.1 aggressive_hoisting
Improves the number of variables that get hoisted out of a loop.
Syntax
#pragma aggressive_hoisting on | off | reset
Remarks
CodeWarrior Development Studio for Power Architecture Processors Build Tools Reference Manual, Rev.
10.6, 02/2014
550 Freescale Semiconductor, Inc.
Chapter 36 Pragmas for Power Architecture Compiler
This pragma produces faster code and causes a slight increase in code size, especially when optimizing for size. In some cases, hoisting variables out of a loop when the loop does not have a lot of iterations can make your code slower.
The default value for this pragma is off
.
36.5.2 c9x_alias_by_type
Allows back-end optimizations to use alias type information.
Syntax
#pragma c9x_alias_by_type on | off | reset
Remarks
When this pragma is on, the compiler's back-end optimizations take advantage of type information gathered during alias analysis. Turn this pragma on if your source code follows the type rules specified by the ISO/IEC 9899-1999 C standard ("C99"), section
6.5.
Turn this pragma off if your source code violates type rules. The information collected from source code that violates these rules might lead the compiler to apply its optimizations incorrectly.
This pragma does not have a corresponding IDE panel setting.
36.5.3 epilogue_helper_functions
Controls size optimization for function termination instructions.
Syntax
#pragma epilogue_helper_functions on | off | reset
Remarks
When this pragma is on, the compiler reduces the size of object code in function terminations. It performs this optimization by replacing several instructions for function termination with fewer calls to special functions that perform the same tasks. This optimization reduces executable code size but also slows the program's performance.
CodeWarrior Development Studio for Power Architecture Processors Build Tools Reference Manual, Rev.
10.6, 02/2014
Freescale Semiconductor, Inc.
551
Optimization Pragmas
When this pragma is on, the compiler generates instructions that may appear as inconsistent information in a symbolic debugger when stepping through the end of a function.
This pragma does not correspond to any panel setting. By default, this pragma is off. The compiler turns this optimization on implicitly when size optimization is on and optimization level is equal to or greater than 2. For example, these pragma settings will also turn on epilogue helper function generation:
#pragma optimization_level 2 #pragma optimize_for_size on
36.5.4 fp_contract
Controls the SPE additional fused multiply-add instructions codegen, when
-spe2_vector
is selected.
Syntax
#pragma fp_contract on|off
Remarks
Floating point accuracy is maintained by turning off this optimization.
36.5.5 fp_contract_aggressive
Enables the peephole pattern to detect and convert the seperate instructions.
Syntax
#pragma fp_contract_aggressive on|off|reset
Remarks
#pragma fp_contract_aggressive on can be used to further optimize multiply-add opportunities.
NOTE
Precision could be lost due to rounding issues.
CodeWarrior Development Studio for Power Architecture Processors Build Tools Reference Manual, Rev.
10.6, 02/2014
552 Freescale Semiconductor, Inc.
Chapter 36 Pragmas for Power Architecture Compiler
36.5.6 ipa_rescopes_globals
Rescopes the application global variables, that are only used in one function, to local static. The change to static enables other optimizations that improve alias analysis and load/store optimizations.
Syntax
#pragma ipa_rescopes_globals on | off
Remarks
Ensure that the following requirements are met to rescope the application global variables to local static:
• Program IPA is enabled in all application source files
• use of
#pragma ipa_rescopes_globals on
in all application source files (prefix file or with
-flag ipa_rescopes_globals
on the commandline)
• main()
is defined in one of the application files.
• It is not necessary, or even desirable, to have standard library, runtime or startup code compiled with program IPA and ipa_rescopes_globals on
. However, it is important to have as many of your application sources as possible compiled with those options enabled.
NOTE
As the third party libraries generally do not access the application variables, these libraries can be kept in archive form.
For a simple example, compile/assemble your startup code without program IPA.
Compile all of the application code with program IPA,
#pragma ipa_rescopes_globals on
and link the startup objects, your application objects and the library archives (For more details on Program IPA linking procedures, refer "Interprocedural Analysis").
For a complex example where the application sources are put into groups, compiled and then pre-built into several archives or partially linked objects and the build procedure cannot be matched with the simple example, following changes to the build procedure are suggested:
• Try to make the build setup as similar to the simple example as possible. This will help you identify if the code will benefit from ipa_rescopes_globals
or you will need to
CodeWarrior Development Studio for Power Architecture Processors Build Tools Reference Manual, Rev.
10.6, 02/2014
Freescale Semiconductor, Inc.
553
Optimization Pragmas
modify your source files to get a successful link. For more details, refer "Generating a successful link" .
• All of your functions are not visible to the compiler at once during program IPA. It is possible that a defined global variable in your core files may be used by only one core file but might also be used in one of your application archives that you were unable to build the simple way. If this is true, ipa_rescopes_globals
will rescope the variable and at link time, your application archive will not be able to find the variable and you will get an undefined symbol link error.
NOTE
If you get a successful link you do not have to make any further changes to the build or source.
Generating a successful link
Optimization prevents an improper build. If you do not get a successful link or you only get a few such link errors, identify the source file that defines the "undefined" symbol and try one of the following (in decreasing order of general preference):
• Move the definition of the symbol into the application archive. Symbols that are undefined do not get rescoped.
• Force the export of the symbol with
__declspec
(force_export). Symbols that are exported do not get rescoped.
• Change the symbols to weak with
__declspec
(weak) by inserting before definition.
Weak symbols do not get rescoped.
• Change the symbols to volatile. Volatile symbols do not get rescoped.
with smaller, more efficient groups of instructions.
36.5.7 peephole
Controls the use peephole optimization.
Syntax
#pragma peephole on | off | reset
Remarks
If you enable this pragma, the compiler performs peephole optimizations . These optimizations replace redundant or commonly occurring groups of instructions with smaller, more efficient groups of instructions.
CodeWarrior Development Studio for Power Architecture Processors Build Tools Reference Manual, Rev.
10.6, 02/2014
554 Freescale Semiconductor, Inc.
Chapter 36 Pragmas for Power Architecture Compiler
36.5.8 peephole_enable_16bit_load_store_inst
Enables use of 16-bit load/store instructions instead of 32-bit load/store instructions
Syntax
#pragma peephole_enable_16bit_load_store_inst on | off |
reset
Remarks
This peephole optimization will replace the 32 bit load/store instructions with 16 bit load/ store instructions.
This pragma is on by default under size optimization and off under speed optimization.
Please note that this optimization is applicable only when VLE instruction set is enabled.
Example
Converts the below pattern
e_stb r0,28(r3)
e_stb r0,32(r3)
e_stb r4,36(r3)
e_stb r4,40(r3)
e_stb r4,41(r3)
e_stb r4,42(r3)
e_stb r4,43(r3) to
e_add16i r3,r6,28
se_stb r0,0(r3)
se_stb r0,4(r3)
CodeWarrior Development Studio for Power Architecture Processors Build Tools Reference Manual, Rev.
10.6, 02/2014
Freescale Semiconductor, Inc.
555
Optimization Pragmas
se_stb r4,8(r3)
se_stb r4,12(r3)
se_stb r4,13(r3)
se_stb r4,14(r3)
se_stb r4,15(r3)
36.5.9 ppc_opt_defuse_mem_limit
Controls memory consumed by compiler optimizations on the host computer.
Syntax
#pragma ppc_opt_defuse_mem_limit on | off | reset |
limit
Parameter
limit
Number of megabytes to use on the host computer when optimizing object code. The default value is
150
, which specifies 150 megabytes.
Remarks
Some optimizations need a lot of memory on the host computer, especially when optimizing large functions that make many function calls or refer to many variables. This pragma controls how much memory these optimizations consume.
If limit is set too low, the compiler will not be able to complete some optimizations and will issue an error message.
NOTE
This pragma is to be used when users see the compiler error or warning that the compiler needs more memory to be allocated for usedef/defuse chain computation.
36.5.10 ppc_unroll_instructions_limit
CodeWarrior Development Studio for Power Architecture Processors Build Tools Reference Manual, Rev.
10.6, 02/2014
556 Freescale Semiconductor, Inc.
Chapter 36 Pragmas for Power Architecture Compiler
Limits number of instructions in an unrolled loop to value.
Syntax
#pragma ppc_unroll_instructions_limit value | on | off
Parameter
value
Count limit of instructions. The default is 70.
Remarks
Use this pragma to specify the maximum number of instructions to place in an unrolled loop. The opt_unroll_loops
pragma controls loop unrolling optimization.
When this pragma is on
, the compiler uses the default value.
36.5.11 ppc_unroll_speculative
Controls speculative unrolling of counting loops which do not have fixed counts.
Syntax
#pragma ppc_unroll_speculative on | off
Remarks
The compiler uses the value specified with the ppc_unroll_factor_limit
pragma to compute how many times to unroll eligible loops. The compiler adjusts the value specified with ppc_unroll_factor_limit
so that it is equal to or less than the closest power of 2.
This optimization is only applied when:
• loop unrolling is turned on with the opt_unroll_loops
pragma
• the loop iterator is a 32-bit value ( int
, long
, unsigned int
, unsigned long
)
• the loop's body has no conditional statements
If you enable this pragma, the loop unrolling factor is a power of 2, less than or equal to the value specified by the ppc_unroll_factor_limit
pragma.
The opt_unroll_loops
pragma controls all loop unrolling optimization. To check this setting, use
__option (ppc_unroll_speculative)
. By default, this pragma is on
when loop unrolling is enabled.
CodeWarrior Development Studio for Power Architecture Processors Build Tools Reference Manual, Rev.
10.6, 02/2014
Freescale Semiconductor, Inc.
557
Optimization Pragmas
36.5.12 processor
Specifies the scheduling model used for instruction scheduling optimization.
Syntax
#pragma processor
model
model
This argument is one of these choices:
401 | 403 | 405 | 505 | 509 | 5100 | 5200 | 555 | 56x | 601 | 602 | 603 | 603e | 604 | 604e
| 74x | 75x | 801 | 821 | 823 | 85x | 86x | 87x | 88x | 7400 | 744x | 745x | 82xx| 85xx | e300v1 | e500v1 | e500v2 | e600 | Zen | generic
36.5.13 prologue_helper_functions
Controls size optimization for function initialization instructions.
Syntax
#pragma prologue_helper_functions on | off | reset
Remarks
When this pragma is on, the compiler reduces the size of object code in function initialization. It performs this optimization by replacing several instructions for function initialization with fewer calls to special functions that perform the same tasks. This optimization reduces executable code size but also reduces the program's performance.
This pragma does not correspond to any panel setting. By default, this pragma is off. The compiler turns this optimization on implicitly when size optimization is on and optimization level is equal to or greater than 2. For example, these pragma settings will also turn on prologue helper function generation:
#pragma optimization_level 2 #pragma optimize_for_size on
36.5.14 remove_frsp_aggressive
CodeWarrior Development Studio for Power Architecture Processors Build Tools Reference Manual, Rev.
10.6, 02/2014
558 Freescale Semiconductor, Inc.
Chapter 36 Pragmas for Power Architecture Compiler
Improves code optimization by transforming Power Architecture LFS and FRSP instructions into the equivalent FMR instructions.
Syntax
#pragma remove_frsp_aggressive on | off | reset
Remarks
This pragma allows the compiler more opportunity to use copy propogation optimizations to improve the generated code.
The default value for this pragma is off
.
36.5.15 schedule
Specifies the use of instruction scheduling optimization.
Syntax
#pragma schedule once | twice | altivec | off
Remarks
This pragma lets you choose how many times the compiler passes object code through its instruction scheduler.
On highly optimized C code where loops were manually unrolled, running the scheduler once seems to give better results than running it twice, especially in functions that use the register
specifier.
When the scheduler is run twice, it is run both before and after register colorizing. If it is only run once, it is only run after register colorizing.
This pragma does not correspond to any panel setting. The default value for this pragma is twice
.
36.5.16 schedule z760
Controls the rearrangement of instructions to reduce the effects of instruction latency.
This scheduler is for e200 processors.
CodeWarrior Development Studio for Power Architecture Processors Build Tools Reference Manual, Rev.
10.6, 02/2014
Freescale Semiconductor, Inc.
559
Optimization Pragmas
Syntax
#pragma schedule z760
Remarks
This pragma can be activated by:
1. selecting the Zen processor (from the Processor preference panel or by using the
proc Zen
command line compiler option)
2. specifying
#pragma schedule z760
in the prefix file or on the Preprocessor preference panel. You can also pass
-pragma "schedule z760"
command line to the compiler, to activate the pragma.
This pragma can be used for all e200 dual issue cores.
The pragma does not correspond to any panel setting. By default, this pragma is off
.
36.5.17 scheduling
Specifies the scheduling model used for instruction scheduling optimization.
Syntax
#pragma scheduling
model
| off model
This argument is one of these choices:
401 | 403 | 405 | 505 | 509 | 5100 | 5200 | 555 | 56x | 601 | 602 | 603 | 603e | 604 | 604e
| 74x | 75x | 801 | 821 | 823 | 85x | 86x | 87x | 88x | 7400 | 744x | 745x | 82xx| 85xx | e300v1 | e500v1 | e500v2 | e600 | Zen | generic
36.5.18 volatileasm
Controls the optimization of inline assembly statements.
Syntax
#pragma volatileasm on | off | reset
CodeWarrior Development Studio for Power Architecture Processors Build Tools Reference Manual, Rev.
10.6, 02/2014
560 Freescale Semiconductor, Inc.
Chapter 36 Pragmas for Power Architecture Compiler
Remarks
When this pragma is off
, the compiler applies peephole and scheduling optimizations to inline assembly statements. If the pragma is on
, the compiler does not optimize these statements.
36.5.19 switch_op
Minimizes comparisions for "if" and "switch" statements.
Syntax
#pragma switch_op on | off
Remarks
When this pragma is on, the comparisions for "if" and "switch" statements are minimized.
The compiler performs this optimization by using the constants specified within the switch case (or if) statements and based on internal heuristics that determine the cost.
By default, this pragma is off. The compiler turns this optimization on implicitly when the optimization level is equal to or greater than 2 and the user specifies #pragma switch_op on. For example, these pragma settings will also turn on switch optimization:
#pragma optimization_level 2
#pragma switch_op on
CodeWarrior Development Studio for Power Architecture Processors Build Tools Reference Manual, Rev.
10.6, 02/2014
Freescale Semiconductor, Inc.
561
Optimization Pragmas
CodeWarrior Development Studio for Power Architecture Processors Build Tools Reference Manual, Rev.
10.6, 02/2014
562 Freescale Semiconductor, Inc.
Index
Index
__ASSEMBLER__
__attribute__((deprecated))
__attribute__((noalias))
__attribute__((returns_twice))
__attribute__((unused))
__COMPILER__
__cplusplus
__declspec(interrupt)
__declspec(never_inline)
__declspec(weak)
__FILE__
__FUNCTION__
__ide_target()
__MWERKS__
__PPCBROADWAY__
__PPCGECKO__
__PRETTY_FUNCTION__ Identifier
__STDC__
__VERSION__
. (location counter)
.ifge if greater than or equal
.ifgt if greater than
.ifle if less than or equal
.ifne if not equal
#define
-align
-ansi
-ARM
-bool
-c
-codegen
-ConvertArchiveToPartialLink
-convertpaths
-defaults
-define
-dialect
-enum
-EP
-fatext
-flag
-fmt
-format
-func_align
-g
-gap_fill
-gccincludes
-genbinary
-I-
-I+
-include
-inline
CodeWarrior Development Studio for Power Architecture Processors Build Tools Reference Manual
Freescale Semiconductor, Inc.
563
Index
-keepobjects
-L+
-library
-linkmode
-listdwarf
-little
-M
-maf
-main
-mapcr
-maxerrors
-maxwarnings
-MD
-MM
-MMD
-model
-msgstyle
-nosyspath
-o
-O
-pool
-ppopt
-precompile
-preprocess
-processor
-profile
-progress
-rambuffer
-relocate
-requireprotos
-resolved_partial
-romaddr
-rostr
-RTTI
-sdata2threshold
-sdataaddr
-sdatathreshold
-som_env_check
-sortsrec
-srec
-stackaddr
-stacksize
-stderr
-stdlib
-strict
-strings
-trigraphs
-use_lmw_stmw
-vector
-verbose
-version
-vle_bl_opt
564
CodeWarrior Development Studio for Power Architecture Processors Build Tools Reference Manual
Freescale Semiconductor, Inc.
Index
A
ABI Conformance
Additional Small Data Sections
ADDR
aggressive_hoisting
aggressive_inline
AGGRESSIVE_MERGE_SECTIONS
ALIGNALL
Aligning a Variable Declaration
alignment_metrowerks
Alignment in a Structure Definition
Allocating Additional Heap Space
altivec_model
AltiVec™ Data Types
always_import
ANSI_strict
ARM_conform
ARM_scoping
Assembler Control Directives
Assembling VLE Instructions
Assembly Language Statements
Associating Input Sections With Output Sections
B
Bitfields
Board Initialization Code
Boolean Type
bss
Buffer Manipulation
Building an SDA PIC/PID Application
byte
BYTE
Byte-Reversing Functions
C
C++ Compiler
C++-Style Comments
C++-Style Digraphs
c99
C99 Complex Data Types
C99 Extensions
c9x
c9x_alias_by_type
C Compiler
check_header_flags
Checking Pragma Settings
Choosing Which Functions to Inline
Code Generation Command-Line Options
Code Merging
CodeWarrior Linker Command File
Command-Line for Power Architecture Processors
Command-Line Options for Diagnostic Messages
Command-Line Options for Language Translation
Command-Line Options for Library and Linking
Command-Line Options for Optimization
Command-Line Options for Preprocessing
Command-Line Options for Standard C++
Conformance
Command-Line Options for Standard C
Conformance
Commands, Directives, and Keywords
Comments
Common Subexpression Elimination
Common Terms
Compatibility Conditional Directives
Compiling VLE Instructions
Compound Literal Values
Conditional Preprocessor Directives
CodeWarrior Development Studio for Power Architecture Processors Build Tools Reference Manual
Freescale Semiconductor, Inc.
565
Index
Configuring Command-Line Tools
Configuring Linker File to Several ROM Blocks
const_strings
Constants
Controlling Alignment
Controlling Standard C Conformance
cpp_extensions
Create New RAM Section
Create New ROM Section
Creating an LCF from Scratch
Creating a Stack Frame
Creating Memory Gaps
Creating Statement Labels
Creating Symbols
Creating Unique Labels and Equates
D
data
Data Addressing
Dead Code Elimination
Dead Store Elimination
Deadstripping
Dead-Stripping
Declaration Specifications for Power Architecture
Code
Declaring Variables by Address
defer_codegen
defer_defarg_parsing
Defining Sections in the Output File
Defining the Target's Memory Map
Dependencies Among Source Files
Determining Which Settings Are Saved and
Diagnostic Command-Line Options
Diagnostic Pragmas
Differences Between ISO C++ and EC++
direct_destruction
direct_to_som
Directives
DO_NOT_MERGE_SECTIONS
dont_inline
dwarf2typedefchains
E
e500v2_floatingpoint
EC++ Specifications
elseif
Embedded C++
enums_signed
equ
,
errno_name
error
EWL Naming Convention
Exception Handling
export
EXPORTSTRTAB
Expressions
extended_errorcheck
Extensions to the Preprocessor
EXTERNAL_SYMBOL
566
CodeWarrior Development Studio for Power Architecture Processors Build Tools Reference Manual
Freescale Semiconductor, Inc.
Index
F
faster_pch_gen
File Name Extensions
flat_include
FORCEFILES
Forward Declarations of Static Arrays
fp_contract
fp_contract_aggressive
fralloc
fullpath_prepdump
Function and Top-level Variable Declarations
Function-Level Inline Assembly
G
gcc_extensions
GCC Extensions
,
Getting Help
global_optimizer
GNU Compatible Syntax option
H
has8bytebitfields
Hexadecimal Floating-Point Constants
How to Rebuild the EWL Libraries
I
if
ifc
ifdef
ifndef
Implementation-Defined Behavior
IMPORTSYMTAB
INCLUDE
incompatible_return_small_structs
incompatible_sfpe_double_params
Initializing Automatic Arrays and Structures
inline_bottom_up_once
inline_depth
inline_max_auto_size
inline_max_size
inline_max_total_size
Inline-Assembly for Power Architecture Build
Inlining Techniques
Integer Types
internal
INTERNAL_SYMBOL
Internal and External Addressing Modes
Internal and External Segments and References
interrupt
Invoking Interprocedural Analysis
Invoking Macros
ipa
ipa_rescopes_globals
iso_templates
K
CodeWarrior Development Studio for Power Architecture Processors Build Tools Reference Manual
Freescale Semiconductor, Inc.
567
Index
L
Language Related Issues
lib_export
Library and Linking Command-Line Options
Library and Linking Pragmas
line
Linker Command File Operator Precedence
Linker Command File Support
Linker for Power Architecture Processors
Linker Generated Symbols
Linker Map File
Linking a ROM Image
Linking Binary Files
Live Range Splitting
LOAD
load_store_elimination
Localization
Local Labels
LONG
Loop Unrolling
Low-Level Processor Synchronization
M
macro_prepdump
Macro Directives
Macros
Manipulating the Contents of a Variable or Register
Math Functions
MAX_BIN_GAP
maxerrorcount
Memory Map
min_enum_size
min_struct_align
misaligned_mem_access
Modifications to the Section Pragma
mpwc_newline
multibyteaware_preserve_literals
N
Naming Conventions
new_mangler
no_register_save_helpers
no_static_dtors
NO_TRAILING_BSS_IN_BIN_FILES
Non-constant Static Data Initialization
Non-Standard Keywords
Normal, Record, and Overflow Forms
O
OBJECT
old_friend_lookup
old_pods
Omitted Operands in Conditional Expressions
once
opt_classresults
opt_dead_assignments
opt_lifetimes
opt_propagation
opt_strength_reduction
opt_unroll_loops
opt_vectorize_loops
optimization_level
568
CodeWarrior Development Studio for Power Architecture Processors Build Tools Reference Manual
Freescale Semiconductor, Inc.
Index
Optimization Command-Line Options
Optimization Pragmas
optimize_for_size
option
Option Formats
opword
P
pack
Parameter Formats
parse_mfunc_templ
peephole_enable_16bit_load_store_inst
PIC/PID Linker Command File Directives
Place Symbols in Specific Memory Location
Place the Library File in the LCF
Placing Code and Data in RAM
Placing Code in ROM
pool_data
pop, push
Power Architecture Code Generation
Power Architecture Optimizations
ppc_opt_defuse_mem_limit
ppc_unroll_instructions_limit
pragma
Pragmas for Optimization
Pragmas for Power Architecture Compiler
precompile_target
Precompiling a File in the CodeWarrior IDE
Precompiling a File on the Command Line
Precompiling C++ Source Code
Predefined Macros
Predefined Macros for Power Architecture
Predefined Symbol __func__
Preprocessor Scope in Precompiled Files
previous
Processor Core Specific Macros
Processors With VLE Capability
Program-Level Optimization
Program-Level Requirements
prologue_helper_functions
R
read_only_switch_tables
read_only_vtable_RTTI
Referring to Assembly, C, and C++ Variables
Referring to Registers
Referring to the Number of Arguments
Referring to Variables in Instruction Operands
Referring to Variables in Memory
REGISTER
Relocating Code and Data in External MRAM
Relocating Code and Data in Internal RAM
Relocating Code in ROM
Required Libraries and Source Code Files
Runtime Libraries
S
Saving and Restoring Pragma Settings
sbss
schedule
scheduling
Scope Control Directives
sdata2
section
SECTIONS
Setting CodeWarrior Environment Variables
Setting the Floating-Point Environment
Setting the PATH Environment Variable
SHORT
showmessagenumber
simple_prepdump
CodeWarrior Development Studio for Power Architecture Processors Build Tools Reference Manual
Freescale Semiconductor, Inc.
569
Index
SIZEOF_ROM
Small Data Area PIC/PID Support
space_prepdump
Specifying A Single ROM Block
Specifying Constant Data Location
Specifying Inline Assembly Statements
Specifying Jump Table Location
Specifying Link Order in the IDE
Specifying Memory Area Locations and Sizes
Specifying Several ROM Blocks
Specifying Source File Locations
Standard and Non-Standard Template Parsing
Statement-Level Inline Assembly
strict_ieee_fp
Supported Extensions
suppress_init_code
switch_op
switch_tables
sym
Symbols
Syntax
Syntax for Attribute Specifications
Syntax for Declaration Specifications
T
template_depth
Templates
text
text_encoding
text_vle
The __builtin_constant_p() Operator
The __builtin_expect() Operator
The typeof() Operator
Third Party Standard Libraries
Trailing Commas in Enumerations
type
Typedef Declaration
U
Unique LCF Examples
Unnamed Structures and Enumerations in C
Unsuffixed Decimal Literal Values
Unsupported Extensions
Unsupported Language Features
unused
Updating a Precompiled File Automatically
Uses for SDA PIC/PID
Using a Precompiled File
Using Build Tools on the Command Line
Using Comments
Using Console I/O
Using Immediate Operands
Using Local Variables and Arguments
Using Macro Arguments
Using the .macro Directive
Using the #define Directive
Using the Embedded Warrior Libraries
Using the Main Standard Libraries
Using the Preprocessor
Using Variable Names as Memory Locations
V
Variable Argument Macros
Variable-Length Arrays
Variable Length Encoding
Void and Function Pointer Arithmetic
volatileasm
W
warn_extracomma
warn_filenamecaps_system
warn_hidevirtual
warn_illpragma
warn_illunionmembers
warn_impl_f2i_conv
warn_impl_i2f_conv
570
CodeWarrior Development Studio for Power Architecture Processors Build Tools Reference Manual
Freescale Semiconductor, Inc.
warn_largeargs
warn_no_explicit_virtual
warn_no_side_effect
warn_no_typename
warn_notinlined
warn_padding
warn_pch_portability
warn_possunwant
warn_undefmacro
warn_uninitializedvar
warn_unusedarg
warn_unusedvar
warning
warning_errors
What Can be Precompiled
Z
z4_16bit_cond_branch_errata_5116
z4_mtlr_se_rfi_errata_26553
z760
Index
CodeWarrior Development Studio for Power Architecture Processors Build Tools Reference Manual
Freescale Semiconductor, Inc.
571
Index
572
CodeWarrior Development Studio for Power Architecture Processors Build Tools Reference Manual
Freescale Semiconductor, Inc.
How to Reach Us:
Home Page:
freescale.com
Web Support:
freescale.com/support
Information in this document is provided solely to enable system and software implementers to use Freescale products. There are no express or implied copyright licenses granted hereunder to design or fabricate any integrated circuits based on the information in this document.
Freescale reserves the right to make changes without further notice to any products herein.
Freescale makes no warranty, representation, or guarantee regarding the suitability of its products for any particular purpose, nor does
Freescale assume any liability arising out of the application or use of any product or circuit, and specifically disclaims any and all liability, including without limitation consequential or incidental damages.
“Typical” parameters that may be provided in Freescale data sheets and/or specifications can and do vary in different applications, and actual performance may vary over time. All operating parameters, including “typicals,” must be validated for each customer application by customer's technical experts. Freescale does not convey any license under its patent rights nor the rights of others. Freescale sells products pursuant to standard terms and conditions of sale, which can be found at the following address: freescale.com/SalesTermsandConditions .
Freescale, the Freescale logo and StarCore are trademarks of
Freescale Semiconductor, Inc., Reg. U.S. Pat. & Tm. Off. All other product or service names are the property of their respective owners.
The Power Architecture and Power.org word marks and the Power and
Power.org logos and related marks are trademarks and service marks licensed by Power.org.
© 2005–2014 Freescale Semiconductor, Inc. All rights reserved.
Document Number CWMCUPABTR
Revision 10.6, 02/2014
İndir
Herkese açık bağlantı güncellendi
Sohbetinize giden herkese açık bağlantı güncellendi. You may view and manage your chat links after registration here.
Belge herkese açık bağlantısı
Reklam
