TASKING

GNU

In-line assembler

__asm ("MOV.W #0xFF, R0")

Note: The asm keyword reduces the compiler’s ability to optimize the code. Use modules written in assembler language instead of inline assembler.

asm(“assembly-language instruction string”);

Eg : asm("MOV.W  #0xFF,R0");

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

--align-func

By default, the compiler uses byte alignment for function entries. This option will force the compiler to align all function entries to an even address.

-falign-functions

Align functions.

--align-data

By default, the compiler uses word aligns objects to the minimum alignment required by the architecture.

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.

--cpu = CPU

OR -C cpu

This options define the target processor

--r8c option  tells the compiler to compile for R8C/tiny core

-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 Tasking 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

-c90  OR --iso = c90
Enables strict ISO/ANSI

-ansi

--check

Check the source for syntax errors.

-fsyntax-only

Check the code for syntax errors.

--compact-max-size = Value

Limit the maximum number of instructions in functions that the compiler generates during code compaction

Not Supported

-D (--define)

-D name=definition (--define=name=definition)

This option is used to define macro and specify it to the processor.

-D name=definition

The contents of definition are tokenized and processed as if they appeared during translation phase three in a `#define' directive

-E  [flags]

--preproces [=flags]

This option tells the compiler to preprocess the C source.

-E

Tells the compiler to preprocess the source.

-f filename OR –options-file= filename

Reads command line options from the named file, with there may not be any extension.

@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.

-F  OR --no-double

This option  tell the compiler to treat variables of the type double as float

-fshort-double

Use the same size for double as for float.

-H  OR --include-file

This option you include one extra file at the beginning of each C source file, before other includes

-include  file

Process file as if #include "file" appeared as the first line of the primary source file

-I path  OR --include-directory = path

Includes Directory path.

-I dir

Add the directory ‘dir’ to the list of directories to be searched For header files.

--inline 

Instructs the compiler to inline all functions.

-finline-functions

Integrate all simple functions into their callers.

--no_inline
Use –no_inline to disable function inlining.

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

-integer-enumeration

This option the compiler always treats enum-types as integer. By default it is char type.

Not supported. But following option can be used alternatively

-fshort-enums

Allocate to an enum type only as many bytes as it needs for the declared range of possible values

--noframe.

This option tells the compiler not to generate an interrupt frame (saving/restoring registers) for interrupt handlers

Not Supported

--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 all 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 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 line markers 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 line markers.

-g

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

-g

Produce debugging information for supported debuggers.

--help OR -?

Displays the help message

--help

Displays the help message

-O (flags)  OR –optimize = flags

-O0  No optimization

-O1 Debug purpose optimizations

-O2 Release purpose optimization

-O3 Full optimization

-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

-Os

Code size optimization.

-M {l | m | s}     OR

--model = { large | medium | small}

Specifies the data model large, medium or small.

Not supported

-r[flags]

--runtime [=flags] 

This option controls a number of run-time checks to detect errors during program execution.

Not Supported.

--strict_ansi

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

-ansi

-u (--uchar)

Treat 'character' type variables as 'unsigned character' variables. By default char is the same as specifying signed char.

-fsigned-char

 Let the type char be signed, like signed char

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

-V

--version         

Display version information

-- version

Display version information

--novector

Option you tell the compiler not to generate code for interrupt vectors

Not supported.

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

-Werror
Make all warnings into errors.