compiler.h

Go to the documentation of this file.

/* This header file is part of the ATMEL AT32UC3A-SoftwareFramework-1.1.1 Release */

/*This file is prepared for Doxygen automatic documentation generation.*/
/* Copyright (c) 2007, Atmel Corporation All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 * this list of conditions and the following disclaimer in the documentation
 * and/or other materials provided with the distribution.
 *
 * 3. The name of ATMEL may not be used to endorse or promote products derived
 * from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY ATMEL ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE EXPRESSLY AND
 * SPECIFICALLY DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT,
 * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */


#ifndef _COMPILER_H_
#define _COMPILER_H_

#include <avr32/io.h>
#if __ICCAVR32__
#  include <intrinsics.h>
#endif
#include "preprocessor.h"


//_____ D E C L A R A T I O N S ____________________________________________

#ifdef __AVR32_ABI_COMPILER__ // Automatically defined when compiling for AVR32, not when assembling.

#include <stddef.h>
#include <stdlib.h>


#if __ICCAVR32__


#define __asm__             asm
#define __inline__          inline
#define __volatile__

#endif



typedef unsigned char           Bool; 
typedef unsigned char           U8 ;  
typedef unsigned short int      U16;  
typedef unsigned long int       U32;  
typedef unsigned long long int  U64;  
typedef signed char             S8 ;  
typedef signed short int        S16;  
typedef signed long int         S32;  
typedef signed long long int    S64;  
typedef float                   F32;  
typedef double                  F64;  




typedef Bool                Status_bool_t;  
typedef U8                  Status_t;       





typedef union
{
  U16 u16   ;
  U8  u8 [2];
} Union16;

typedef union
{
  U32 u32   ;
  U16 u16[2];
  U8  u8 [4];
} Union32;

typedef union
{
  U64 u64   ;
  U32 u32[2];
  U16 u16[4];
  U8  u8 [8];
} Union64;

typedef union
{
  U64 *u64ptr;
  U32 *u32ptr;
  U16 *u16ptr;
  U8  *u8ptr ;
} UnionPtr;

typedef union
{
  volatile U64 *u64ptr;
  volatile U32 *u32ptr;
  volatile U16 *u16ptr;
  volatile U8  *u8ptr ;
} UnionVPtr;

typedef union
{
  const U64 *u64ptr;
  const U32 *u32ptr;
  const U16 *u16ptr;
  const U8  *u8ptr ;
} UnionCPtr;

typedef union
{
  const volatile U64 *u64ptr;
  const volatile U32 *u32ptr;
  const volatile U16 *u16ptr;
  const volatile U8  *u8ptr ;
} UnionCVPtr;

typedef struct
{
  U64 *u64ptr;
  U32 *u32ptr;
  U16 *u16ptr;
  U8  *u8ptr ;
} StructPtr;

typedef struct
{
  volatile U64 *u64ptr;
  volatile U32 *u32ptr;
  volatile U16 *u16ptr;
  volatile U8  *u8ptr ;
} StructVPtr;

typedef struct
{
  const U64 *u64ptr;
  const U32 *u32ptr;
  const U16 *u16ptr;
  const U8  *u8ptr ;
} StructCPtr;

typedef struct
{
  const volatile U64 *u64ptr;
  const volatile U32 *u32ptr;
  const volatile U16 *u16ptr;
  const volatile U8  *u8ptr ;
} StructCVPtr;


#endif  // __AVR32_ABI_COMPILER__


//_____ M A C R O S ________________________________________________________


#define DISABLE   0
#define ENABLE    1
#define DISABLED  0
#define ENABLED   1
#define OFF       0
#define ON        1
#define FALSE     0
#define TRUE      1
#define KO        0
#define OK        1
#define PASS      0
#define FAIL      1
#define LOW       0
#define HIGH      1
#define CLR       0
#define SET       1


#ifdef __AVR32_ABI_COMPILER__ // Automatically defined when compiling for AVR32, not when assembling.



#define Rd_bits( value, mask)        ((value) & (mask))

#define Wr_bits(lvalue, mask, bits)  ((lvalue) = ((lvalue) & ~(mask)) |\
                                                 ((bits  ) &  (mask)))

#define Tst_bits( value, mask)  (Rd_bits(value, mask) != 0)

#define Clr_bits(lvalue, mask)  ((lvalue) &= ~(mask))

#define Set_bits(lvalue, mask)  ((lvalue) |=  (mask))

#define Tgl_bits(lvalue, mask)  ((lvalue) ^=  (mask))

#define Rd_bitfield( value, mask)           (Rd_bits( value, mask) >> ctz(mask))

#define Wr_bitfield(lvalue, mask, bitfield) (Wr_bits(lvalue, mask, (U32)(bitfield) << ctz(mask)))



#ifdef _ASSERT_ENABLE_
  #define Assert(expr) \
  {\
    if (!(expr)) while (TRUE);\
  }
#else
  #define Assert(expr)
#endif




#if __GNUC__
  #define clz(u)              __builtin_clz(u)
#elif __ICCAVR32__
  #define clz(u)              __count_leading_zeros(u)
#endif

#if __GNUC__
  #define ctz(u)              __builtin_ctz(u)
#elif __ICCAVR32__
  #define ctz(u)              __count_trailing_zeros(u)
#endif





#define Test_align(val, n     ) (!Tst_bits( val, (n) - 1     )   )

#define Get_align( val, n     ) (  Rd_bits( val, (n) - 1     )   )

#define Set_align(lval, n, alg) (  Wr_bits(lval, (n) - 1, alg)   )

#define Align_up(  val, n     ) (((val) + ((n) - 1)) & ~((n) - 1))

#define Align_down(val, n     ) ( (val)              & ~((n) - 1))





#define Abs(a)              (((a) <  0 ) ? -(a) : (a))

#define Min(a, b)           (((a) < (b)) ?  (a) : (b))

#define Max(a, b)           (((a) > (b)) ?  (a) : (b))

#if __GNUC__
  #define abs(a) \
  (\
    {\
      int __value = (a);\
      __asm__ ("abs\t%0" : "+r" (__value) :  : "cc");\
      __value;\
    }\
  )
#elif __ICCAVR32__
  #define abs(a)      Abs(a)
#endif

#if __GNUC__
  #define min(a, b) \
  (\
    {\
      int __value, __arg_a = (a), __arg_b = (b);\
      __asm__ ("min\t%0, %1, %2" : "=r" (__value) : "r" (__arg_a), "r" (__arg_b));\
      __value;\
    }\
  )
#elif __ICCAVR32__
  #define min(a, b)   Min(a, b)
#endif

#if __GNUC__
  #define max(a, b) \
  (\
    {\
      int __value, __arg_a = (a), __arg_b = (b);\
      __asm__ ("max\t%0, %1, %2" : "=r" (__value) : "r" (__arg_a), "r" (__arg_b));\
      __value;\
    }\
  )
#elif __ICCAVR32__
  #define max(a, b)   Max(a, b)
#endif



#define Long_call(addr)                   ((*(void (*)(void))(addr))())

#if __GNUC__
  #define Reset_CPU() \
  (\
    {\
      __asm__ __volatile__ (\
        "lddpc   r9, 3f\n\t"\
        "mfsr    r8, %[SR]\n\t"\
        "bfextu  r8, r8, %[SR_MX_OFFSET], %[SR_MX_SIZE]\n\t"\
        "cp.w    r8, 0b001\n\t"\
        "breq    0f\n\t"\
        "sub     r8, pc, $ - 1f\n\t"\
        "pushm   r8-r9\n\t"\
        "rete\n"\
        "0:\n\t"\
        "mtsr    %[SR], r9\n"\
        "1:\n\t"\
        "mov     r0, 0\n\t"\
        "mov     r1, 0\n\t"\
        "mov     r2, 0\n\t"\
        "mov     r3, 0\n\t"\
        "mov     r4, 0\n\t"\
        "mov     r5, 0\n\t"\
        "mov     r6, 0\n\t"\
        "mov     r7, 0\n\t"\
        "mov     r8, 0\n\t"\
        "mov     r9, 0\n\t"\
        "mov     r10, 0\n\t"\
        "mov     r11, 0\n\t"\
        "mov     r12, 0\n\t"\
        "mov     sp, 0\n\t"\
        "stdsp   sp[0], sp\n\t"\
        "ldmts   sp, sp\n\t"\
        "mov     lr, 0\n\t"\
        "lddpc   pc, 2f\n\t"\
        ".balign 4\n"\
        "2:\n\t"\
        ".word   _start\n"\
        "3:\n\t"\
        ".word   %[RESET_SR]"\
        :\
        : [SR] "i" (AVR32_SR),\
          [SR_MX_OFFSET] "i" (AVR32_SR_M0_OFFSET),\
          [SR_MX_SIZE] "i" (AVR32_SR_M0_SIZE + AVR32_SR_M1_SIZE + AVR32_SR_M2_SIZE),\
          [RESET_SR] "i" (AVR32_SR_GM_MASK | AVR32_SR_EM_MASK | AVR32_SR_M0_MASK)\
      );\
    }\
  )
#elif __ICCAVR32__
  #define Reset_CPU() \
  {\
    extern void *volatile __program_start;\
    __asm__ __volatile__ (\
      "mov     r7, LWRD(__program_start)\n\t"\
      "orh     r7, HWRD(__program_start)\n\t"\
      "mov     r9, LWRD("ASTRINGZ(AVR32_SR_GM_MASK | AVR32_SR_EM_MASK | AVR32_SR_M0_MASK)")\n\t"\
      "orh     r9, HWRD("ASTRINGZ(AVR32_SR_GM_MASK | AVR32_SR_EM_MASK | AVR32_SR_M0_MASK)")\n\t"\
      "mfsr    r8, "ASTRINGZ(AVR32_SR)"\n\t"\
      "bfextu  r8, r8, "ASTRINGZ(AVR32_SR_M0_OFFSET)", "ASTRINGZ(AVR32_SR_M0_SIZE + AVR32_SR_M1_SIZE + AVR32_SR_M2_SIZE)"\n\t"\
      "cp.w    r8, 001b\n\t"\
      "breq    $ + 10\n\t"\
      "sub     r8, pc, -12\n\t"\
      "pushm   r8-r9\n\t"\
      "rete\n\t"\
      "mtsr    "ASTRINGZ(AVR32_SR)", r9\n\t"\
      "mov     r0, 0\n\t"\
      "mov     r1, 0\n\t"\
      "mov     r2, 0\n\t"\
      "mov     r3, 0\n\t"\
      "mov     r4, 0\n\t"\
      "mov     r5, 0\n\t"\
      "mov     r6, 0\n\t"\
      "st.w    r0[4], r7\n\t"\
      "mov     r7, 0\n\t"\
      "mov     r8, 0\n\t"\
      "mov     r9, 0\n\t"\
      "mov     r10, 0\n\t"\
      "mov     r11, 0\n\t"\
      "mov     r12, 0\n\t"\
      "mov     sp, 0\n\t"\
      "stdsp   sp[0], sp\n\t"\
      "ldmts   sp, sp\n\t"\
      "mov     lr, 0\n\t"\
      "ld.w    pc, lr[4]"\
    );\
    __program_start;\
  }
#endif




#if __GNUC__
  #define Get_system_register(sysreg)         __builtin_mfsr(sysreg)
#elif __ICCAVR32__
  #define Get_system_register(sysreg)         __get_system_register(sysreg)
#endif

#if __GNUC__
  #define Set_system_register(sysreg, value)  __builtin_mtsr(sysreg, value)
#elif __ICCAVR32__
  #define Set_system_register(sysreg, value)  __set_system_register(sysreg, value)
#endif





#define Is_global_exception_enabled()       (!Tst_bits(Get_system_register(AVR32_SR), AVR32_SR_EM_MASK))

#if __GNUC__
  #define Disable_global_exception()        ({__asm__ __volatile__ ("ssrf\t%0" :  : "i" (AVR32_SR_EM_OFFSET));})
#elif __ICCAVR32__
  #define Disable_global_exception()        (__set_status_flag(AVR32_SR_EM_OFFSET))
#endif

#if __GNUC__
  #define Enable_global_exception()         ({__asm__ __volatile__ ("csrf\t%0" :  : "i" (AVR32_SR_EM_OFFSET));})
#elif __ICCAVR32__
  #define Enable_global_exception()         (__clear_status_flag(AVR32_SR_EM_OFFSET))
#endif

#define Is_global_interrupt_enabled()       (!Tst_bits(Get_system_register(AVR32_SR), AVR32_SR_GM_MASK))

#if __GNUC__
  #define Disable_global_interrupt()        ({__asm__ __volatile__ ("ssrf\t%0\n\tnop\n\tnop" :  : "i" (AVR32_SR_GM_OFFSET));})
#elif __ICCAVR32__
  #define Disable_global_interrupt()        {__asm__ __volatile__ ("ssrf\t"ASTRINGZ(AVR32_SR_GM_OFFSET)"\n\tnop\n\tnop");}
#endif

#if __GNUC__
  #define Enable_global_interrupt()         ({__asm__ __volatile__ ("csrf\t%0" :  : "i" (AVR32_SR_GM_OFFSET));})
#elif __ICCAVR32__
  #define Enable_global_interrupt()         (__enable_interrupt())
#endif

#define Is_interrupt_level_enabled(int_lev) (!Tst_bits(Get_system_register(AVR32_SR), TPASTE3(AVR32_SR_I, int_lev, M_MASK)))

#if __GNUC__
  #define Disable_interrupt_level(int_lev)  ({__asm__ __volatile__ ("ssrf\t%0\n\tnop\n\tnop" :  : "i" (TPASTE3(AVR32_SR_I, int_lev, M_OFFSET)));})
#elif __ICCAVR32__
  #define Disable_interrupt_level(int_lev)  {__asm__ __volatile__ ("ssrf\t"ASTRINGZ(TPASTE3(AVR32_SR_I, int_lev, M_OFFSET))"\n\tnop\n\tnop");}
#endif

#if __GNUC__
  #define Enable_interrupt_level(int_lev)   ({__asm__ __volatile__ ("csrf\t%0" :  : "i" (TPASTE3(AVR32_SR_I, int_lev, M_OFFSET)));})
#elif __ICCAVR32__
  #define Enable_interrupt_level(int_lev)   (__clear_status_flag(TPASTE3(AVR32_SR_I, int_lev, M_OFFSET)))
#endif


#endif  // __AVR32_ABI_COMPILER__


#if (__GNUC__ && __AVR32__) || (__ICCAVR32__ || __AAVR32__)
  #define LITTLE_ENDIAN_MCU     FALSE
#endif

// Check that MCU endianism is correctly defined.
#ifndef LITTLE_ENDIAN_MCU
  #error YOU MUST define the MCU endianism with LITTLE_ENDIAN_MCU: either FALSE or TRUE
#endif

#define BIG_ENDIAN_MCU        (!LITTLE_ENDIAN_MCU)


#ifdef __AVR32_ABI_COMPILER__ // Automatically defined when compiling for AVR32, not when assembling.



#if LITTLE_ENDIAN_MCU

  #define LSB(u16)        (((U8  *)&(u16))[0])  
  #define MSB(u16)        (((U8  *)&(u16))[1])  

  #define LSH(u32)        (((U16 *)&(u32))[0])  
  #define MSH(u32)        (((U16 *)&(u32))[1])  
  #define LSB0W(u32)      (((U8  *)&(u32))[0])  
  #define LSB1W(u32)      (((U8  *)&(u32))[1])  
  #define LSB2W(u32)      (((U8  *)&(u32))[2])  
  #define LSB3W(u32)      (((U8  *)&(u32))[3])  
  #define MSB3W(u32)      LSB0W(u32)            
  #define MSB2W(u32)      LSB1W(u32)            
  #define MSB1W(u32)      LSB2W(u32)            
  #define MSB0W(u32)      LSB3W(u32)            

  #define LSW(u64)        (((U32 *)&(u64))[0])  
  #define MSW(u64)        (((U32 *)&(u64))[1])  
  #define LSH0(u64)       (((U16 *)&(u64))[0])  
  #define LSH1(u64)       (((U16 *)&(u64))[1])  
  #define LSH2(u64)       (((U16 *)&(u64))[2])  
  #define LSH3(u64)       (((U16 *)&(u64))[3])  
  #define MSH3(u64)       LSH0(u64)             
  #define MSH2(u64)       LSH1(u64)             
  #define MSH1(u64)       LSH2(u64)             
  #define MSH0(u64)       LSH3(u64)             
  #define LSB0D(u64)      (((U8  *)&(u64))[0])  
  #define LSB1D(u64)      (((U8  *)&(u64))[1])  
  #define LSB2D(u64)      (((U8  *)&(u64))[2])  
  #define LSB3D(u64)      (((U8  *)&(u64))[3])  
  #define LSB4D(u64)      (((U8  *)&(u64))[4])  
  #define LSB5D(u64)      (((U8  *)&(u64))[5])  
  #define LSB6D(u64)      (((U8  *)&(u64))[6])  
  #define LSB7D(u64)      (((U8  *)&(u64))[7])  
  #define MSB7D(u64)      LSB0D(u64)            
  #define MSB6D(u64)      LSB1D(u64)            
  #define MSB5D(u64)      LSB2D(u64)            
  #define MSB4D(u64)      LSB3D(u64)            
  #define MSB3D(u64)      LSB4D(u64)            
  #define MSB2D(u64)      LSB5D(u64)            
  #define MSB1D(u64)      LSB6D(u64)            
  #define MSB0D(u64)      LSB7D(u64)            

#else // BIG_ENDIAN_MCU

  #define MSB(u16)        (((U8  *)&(u16))[0])  
  #define LSB(u16)        (((U8  *)&(u16))[1])  

  #define MSH(u32)        (((U16 *)&(u32))[0])  
  #define LSH(u32)        (((U16 *)&(u32))[1])  
  #define MSB0W(u32)      (((U8  *)&(u32))[0])  
  #define MSB1W(u32)      (((U8  *)&(u32))[1])  
  #define MSB2W(u32)      (((U8  *)&(u32))[2])  
  #define MSB3W(u32)      (((U8  *)&(u32))[3])  
  #define LSB3W(u32)      MSB0W(u32)            
  #define LSB2W(u32)      MSB1W(u32)            
  #define LSB1W(u32)      MSB2W(u32)            
  #define LSB0W(u32)      MSB3W(u32)            

  #define MSW(u64)        (((U32 *)&(u64))[0])  
  #define LSW(u64)        (((U32 *)&(u64))[1])  
  #define MSH0(u64)       (((U16 *)&(u64))[0])  
  #define MSH1(u64)       (((U16 *)&(u64))[1])  
  #define MSH2(u64)       (((U16 *)&(u64))[2])  
  #define MSH3(u64)       (((U16 *)&(u64))[3])  
  #define LSH3(u64)       MSH0(u64)             
  #define LSH2(u64)       MSH1(u64)             
  #define LSH1(u64)       MSH2(u64)             
  #define LSH0(u64)       MSH3(u64)             
  #define MSB0D(u64)      (((U8  *)&(u64))[0])  
  #define MSB1D(u64)      (((U8  *)&(u64))[1])  
  #define MSB2D(u64)      (((U8  *)&(u64))[2])  
  #define MSB3D(u64)      (((U8  *)&(u64))[3])  
  #define MSB4D(u64)      (((U8  *)&(u64))[4])  
  #define MSB5D(u64)      (((U8  *)&(u64))[5])  
  #define MSB6D(u64)      (((U8  *)&(u64))[6])  
  #define MSB7D(u64)      (((U8  *)&(u64))[7])  
  #define LSB7D(u64)      MSB0D(u64)            
  #define LSB6D(u64)      MSB1D(u64)            
  #define LSB5D(u64)      MSB2D(u64)            
  #define LSB4D(u64)      MSB3D(u64)            
  #define LSB3D(u64)      MSB4D(u64)            
  #define LSB2D(u64)      MSB5D(u64)            
  #define LSB1D(u64)      MSB6D(u64)            
  #define LSB0D(u64)      MSB7D(u64)            

#endif





#define Swap16(u16) ((U16)(((U16)(u16) >> 8) |\
                           ((U16)(u16) << 8)))

#define Swap32(u32) ((U32)(((U32)Swap16((U32)(u32) >> 16)) |\
                           ((U32)Swap16((U32)(u32)) << 16)))

#define Swap64(u64) ((U64)(((U64)Swap32((U64)(u64) >> 32)) |\
                           ((U64)Swap32((U64)(u64)) << 32)))

#if __GNUC__
  #define swap16(u16) __builtin_bswap_16(u16)
#elif __ICCAVR32__
  #define swap16(u16) Swap16(u16)
#endif

#if __GNUC__
  #define swap32(u32) __builtin_bswap_32(u32)
#elif __ICCAVR32__
  #define swap32(u32) Swap32(u32)
#endif

#define swap64(u64) ((U64)(((U64)swap32((U64)(u64) >> 32)) |\
                           ((U64)swap32((U64)(u64)) << 32)))





#define _GLOBEXT_           extern      
#define _CONST_TYPE_        const       
#define _MEM_TYPE_SLOW_                 
#define _MEM_TYPE_MEDFAST_              
#define _MEM_TYPE_FAST_                 

typedef U8                  Byte;       

#define memcmp_ram2ram      memcmp      
#define memcmp_code2ram     memcmp      
#define memcpy_ram2ram      memcpy      
#define memcpy_code2ram     memcpy      

#define LSB0(u32)           LSB0W(u32)  
#define LSB1(u32)           LSB1W(u32)  
#define LSB2(u32)           LSB2W(u32)  
#define LSB3(u32)           LSB3W(u32)  
#define MSB3(u32)           MSB3W(u32)  
#define MSB2(u32)           MSB2W(u32)  
#define MSB1(u32)           MSB1W(u32)  
#define MSB0(u32)           MSB0W(u32)  


#endif  // __AVR32_ABI_COMPILER__


#endif  // _COMPILER_H_

---