IAR

GNU

--cpu CPU

M16C/R8C Compiler supported targets are Renesas
M16C/1X, 2X, 3X, 6X, and R8C Series of CPU
Use --cpu and specify M16C or R8C.

-mcpu=m16c
Generates the object code for the M16C (up to /60) series.

-mcpu=r8c
Generates the code for R8C/Tiny Series.

To compile code for the M16C/80 core and M32C, you need the M32C IAR C/C++ Compiler.

-mcpu=m32c
Generates the object code for the M32C/80 series.

-mcpu=m32cm
Generates the object code for the M16C/80 series

In-line assembler

asm("MOV.W R1,R0");
Note: The asm keyword reduces the compiler’s ability to optimize the code. Use  modules written in assembler language instead of inline assembler.

e.g.

asm("MOV.W R1,R0");

With the IAR compiler function and variable names are the same on C and assembler level.

The GNU compiler adds a “_” to C function or variables names if they are referred from assembler level.

--align_func={1|2}

By default, the compiler uses byte alignment for function entries. Use --align_func=2 to specify word alignment and force the compiler to align all function entries to an even address

-falign-functions
-falign-functions=n

 

--char_is_signed

By default the compiler interprets the char type as unsigned.

-fsigned-char

-fno-unsigned-char
Let the type char be signed, like signed char.

--enable_multibytes

Enables support for multibyte characters

Unicode characters are default supported.

To add the character set "wchar.h" files need to be included passing "-std=c99" command line option.

-y

--low_consts
Copies constants to near RAM

For M16C GNUC always copies constants from ROM to RAM.

For M32C this is not supported.

--strict_ansi
Enables strict ISO/ANSI

-pedantic

Let the type char be signed, like signed char.

-Dsymbol[=value]
The option -D has the same effect as a #define statement at the top of the source file

-D symbol=value
Functionality similar to #define.

--dependencies=[i][m] {filename|directory}
When you use this option, each source file opened by the compiler is listed in a file.
The following modifiers are available:
i -> Include only the names of files (default)
m -> Makefile style
If --dependencies=m is used, the output uses makefile style.

-M
The preprocessor outputs one make rule containing the object file name For that source file.
-MF file
When used with `-M' or `-MM', specifies a file to write the dependencies to.

--diag_error=tag,tag,...
Use this option to classify diagnostic messages as errors. An error indicates a violation of the C or C++ language rules.

-Werror=
Make all warnings into errors.

-f filename
Reads command line options from the named file, with the default extension xcl.

@file
Read command-line options from file. The options read are inserted in place of the original @file option. If file does not exist, or cannot be read, then the option will be treated literally, and not removed.

--header_context
It is necessary to know which header file that was included from what
source line, to find the cause of a problem. Use this option to list, for each diagnostic message, not only the source position of the problem, but also the entire include stack at that point

-Wsystem-headers
Print warning messages for constructs found in system header files.

-Ipath
Includes file path.

-I dir
Add the directory dir to the list of directories to be searched For header files.

-la

Assembler file

-S

The input C source file is compiled only, assembling and linking is not done. The output is in the form of an assembly file.

-lA  (N is implied)

Assembler file with C or C++ source as comments

-Wa,-ah={filename|directory}
include high-level source

-laN

Assembler file without diagnostics in file.

-Wa,-ad={filename|directory}
omit debugging directives

--no_cse
Use --no_cse to disable common sub-expression elimination.

-fno-gcse
Disable the global common sub-expression elimination.

--no_inline
Use –no_inline to disable function inlining.

-fno-inline
Don't pay attention to the inline keyword.

--no_tbaa

Use --no_tbaa to disable type-based alias analysis.

When this option is not used, the

compiler is free to assume that objects are only accessed through the declared type or

through unsigned char.

may_alias

Accesses to objects with types are not subjected to type-based alias analysis, but are instead assumed to be able to alias any other type of objects, just like the char type.

--no_unroll
Use this option to disable loop unrolling.

-fno-unroll-loops 

-fno-unroll-all-loops  

--no_warnings
By default the compiler issues standard warning messages. use this option to disable all warning messages.

By default all the warnings are disabled.

 

-Wall enables the warning for normal code.

-o {filename|directory}
Use the -o option to specify an output file.

-o file
Place output in file file.

--preprocess=c

Preserve comments

-C
Do not discard comments. All comments are passed through to the output file, except for comments in processed directives, which are deleted along with the directive.

--preprocess=n

Preprocess only

-E
Option, nothing is done except preprocessing.

--preprocess=l

Generate #line directives

-P
Inhibit generation of linemarkers in the output from the preprocessor. This might be useful when running the preprocessor on something that is not C code, and will be sent to a program which might be confused by the linemarkers.

--code_segment=name
-Rname
Place executable code in name.

void foobar (void) __attribute__ ((section ("bar")));
puts the function foobar in the bar section.

-r

--debug
Use the --debug or the -r option to make the compiler include information for supported debuggers.

-g
Produce debugging information for supported debuggers.

--require_prototypes
This option forces the compiler to verify that all functions have proper prototypes.
The following will generate an error:

 

§         A function definition of a public function with no previous prototype declaration

• A function call with no declaration or a K&R C declaration.
• An indirect function call through a function pointer with a type that does not include a prototype.

Not supported

But some of the related optioned are:

-Wstrict-prototypes (C only)

Warn if a function is declared or defined without specifying the argument types.

-Wmissing-prototypes (C only)

Warn if a global function is defined without a previous prototype declaration.

-Wdeclaration-after-statement (C only)
Warn when a declaration is found after a statement in a block.

-s[2|3|6|9|debug|low|medium|high]
Use this option to make the compiler optimize the code for maximum execution speed.
2, debug Debug*

3, low Low*

6, medium Medium

-z[2|3|6|9|debug|low|medium|high]
Use this option to make the compiler optimize the code for minimum size.

-O[1-3]
Optimise for execution speed.

1 – Optimise  for size and speed.

2 – Better optimisation, nearly all optimisations not involving space-speed trade off are used.

3 – Maximum optimisation for speed.

-z9
Highly opimized on minimum code size.

-Os
Code size optimization.

--strict_ansi
Use --strict_ansi to ensure that the program conforms to the
ISO/ANSI C standard.

-ansi

--align_data={1|2}

-u(1|2)
By default, the compiler uses word alignment for data objects. Use -u1 to specify byte alignment (or -u2 to restore word alignment).

aligned (alignment)
This attribute specifies a minimum alignment (in bytes) for variables of the specified type. For example, the declarations:
  struct S { short f[3]; } __attribute__ ((aligned (8)));
typedef int more_aligned_int __attribute__ ((aligned (8)));
force the compiler to insure (as far as it can) that each variable whose type is struct S or more_aligned_int will be allocated and aligned at least on a 8-byte boundary.

--warnings_are_errors
Use this option to make the compiler treat all warnings as errors.

-Werror
Make all warnings into errors.

-2

--64bit_doubles
Use this option to force the compiler to use 64-bit doubles instead of 32-bit doubles which is the default.

By default 64-bit double. No possibility to use 32-bit double.

--calling_convention={simple| normal}
Specifies the calling convention for functions.

Not supported

--constant_data={near|far|huge}
Specifies an explicit location for constants.

Not supported

But using the "attribute" constant variable can be placed in the named segment, as shown below.

char foo __attribute__ ((section (sectionname)));

--data_model={near|far|huge}
Specifies the data model.

Not supported