/* Copyright (C) 2009-2020 Free Software Foundation, Inc.
Contributed by Anatoly Sokolov (aesok@post.ru)
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
GCC is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
/* Not included in avr.c since this requires C front end. */
#define IN_TARGET_CODE 1
#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "target.h"
#include "c-family/c-common.h"
#include "stor-layout.h"
#include "langhooks.h"
#include "memmodel.h"
#include "tm_p.h"
/* IDs for all the AVR builtins. */
enum avr_builtin_id
{
#define DEF_BUILTIN(NAME, N_ARGS, TYPE, CODE, LIBNAME) \
AVR_BUILTIN_ ## NAME,
#include "builtins.def"
#undef DEF_BUILTIN
AVR_BUILTIN_COUNT
};
/* Implement `TARGET_RESOLVE_OVERLOADED_PLUGIN'. */
static tree
avr_resolve_overloaded_builtin (unsigned int iloc, tree fndecl, void *vargs)
{
tree type0, type1, fold = NULL_TREE;
enum avr_builtin_id id = AVR_BUILTIN_COUNT;
location_t loc = (location_t) iloc;
vec<tree, va_gc> &args = * (vec<tree, va_gc>*) vargs;
switch (DECL_MD_FUNCTION_CODE (fndecl))
{
default:
break;
case AVR_BUILTIN_ABSFX:
if (args.length() != 1)
{
error_at (loc, "%qs expects 1 argument but %d given",
"absfx", (int) args.length());
fold = error_mark_node;
break;
}
type0 = TREE_TYPE (args[0]);
if (!FIXED_POINT_TYPE_P (type0))
{
error_at (loc, "%qs expects a fixed-point value as argument",
"absfx");
fold = error_mark_node;
}
switch (TYPE_MODE (type0))
{
case E_QQmode: id = AVR_BUILTIN_ABSHR; break;
case E_HQmode: id = AVR_BUILTIN_ABSR; break;
case E_SQmode: id = AVR_BUILTIN_ABSLR; break;
case E_DQmode: id = AVR_BUILTIN_ABSLLR; break;
case E_HAmode: id = AVR_BUILTIN_ABSHK; break;
case E_SAmode: id = AVR_BUILTIN_ABSK; break;
case E_DAmode: id = AVR_BUILTIN_ABSLK; break;
case E_TAmode: id = AVR_BUILTIN_ABSLLK; break;
case E_UQQmode:
case E_UHQmode:
case E_USQmode:
case E_UDQmode:
case E_UHAmode:
case E_USAmode:
case E_UDAmode:
case E_UTAmode:
warning_at (loc, 0, "using %qs with unsigned type has no effect",
"absfx");
return args[0];
default:
error_at (loc, "no matching fixed-point overload found for %qs",
"absfx");
fold = error_mark_node;
break;
}
fold = targetm.builtin_decl (id, true);
if (fold != error_mark_node)
fold = build_function_call_vec (loc, vNULL, fold, &args, NULL);
break; // absfx
case AVR_BUILTIN_ROUNDFX:
if (args.length() != 2)
{
error_at (loc, "%qs expects 2 arguments but %d given",
"roundfx", (int) args.length());
fold = error_mark_node;
break;
}
type0 = TREE_TYPE (args[0]);
type1 = TREE_TYPE (args[1]);
if (!FIXED_POINT_TYPE_P (type0))
{
error_at (loc, "%qs expects a fixed-point value as first argument",
"roundfx");
fold = error_mark_node;
}
if (!INTEGRAL_TYPE_P (type1))
{
error_at (loc, "%qs expects an integer value as second argument",
"roundfx");
fold = error_mark_node;
}
switch (TYPE_MODE (type0))
{
case E_QQmode: id = AVR_BUILTIN_ROUNDHR; break;
case E_HQmode: id = AVR_BUILTIN_ROUNDR; break;
case E_SQmode: id = AVR_BUILTIN_ROUNDLR; break;
case E_DQmode: id = AVR_BUILTIN_ROUNDLLR; break;
case E_UQQmode: id = AVR_BUILTIN_ROUNDUHR; break;
case E_UHQmode: id = AVR_BUILTIN_ROUNDUR; break;
case E_USQmode: id = AVR_BUILTIN_ROUNDULR; break;
case E_UDQmode: id = AVR_BUILTIN_ROUNDULLR; break;
case E_HAmode: id = AVR_BUILTIN_ROUNDHK; break;
case E_SAmode: id = AVR_BUILTIN_ROUNDK; break;
case E_DAmode: id = AVR_BUILTIN_ROUNDLK; break;
case E_TAmode: id = AVR_BUILTIN_ROUNDLLK; break;
case E_UHAmode: id = AVR_BUILTIN_ROUNDUHK; break;
case E_USAmode: id = AVR_BUILTIN_ROUNDUK; break;
case E_UDAmode: id = AVR_BUILTIN_ROUNDULK; break;
case E_UTAmode: id = AVR_BUILTIN_ROUNDULLK; break;
default:
error_at (loc, "no matching fixed-point overload found for %qs",
"roundfx");
fold = error_mark_node;
break;
}
fold = targetm.builtin_decl (id, true);
if (fold != error_mark_node)
fold = build_function_call_vec (loc, vNULL, fold, &args, NULL);
break; // roundfx
case AVR_BUILTIN_COUNTLSFX:
if (args.length() != 1)
{
error_at (loc, "%qs expects 1 argument but %d given",
"countlsfx", (int) args.length());
fold = error_mark_node;
break;
}
type0 = TREE_TYPE (args[0]);
if (!FIXED_POINT_TYPE_P (type0))
{
error_at (loc, "%qs expects a fixed-point value as first argument",
"countlsfx");
fold = error_mark_node;
}
switch (TYPE_MODE (type0))
{
case E_QQmode: id = AVR_BUILTIN_COUNTLSHR; break;
case E_HQmode: id = AVR_BUILTIN_COUNTLSR; break;
case E_SQmode: id = AVR_BUILTIN_COUNTLSLR; break;
case E_DQmode: id = AVR_BUILTIN_COUNTLSLLR; break;
case E_UQQmode: id = AVR_BUILTIN_COUNTLSUHR; break;
case E_UHQmode: id = AVR_BUILTIN_COUNTLSUR; break;
case E_USQmode: id = AVR_BUILTIN_COUNTLSULR; break;
case E_UDQmode: id = AVR_BUILTIN_COUNTLSULLR; break;
case E_HAmode: id = AVR_BUILTIN_COUNTLSHK; break;
case E_SAmode: id = AVR_BUILTIN_COUNTLSK; break;
case E_DAmode: id = AVR_BUILTIN_COUNTLSLK; break;
case E_TAmode: id = AVR_BUILTIN_COUNTLSLLK; break;
case E_UHAmode: id = AVR_BUILTIN_COUNTLSUHK; break;
case E_USAmode: id = AVR_BUILTIN_COUNTLSUK; break;
case E_UDAmode: id = AVR_BUILTIN_COUNTLSULK; break;
case E_UTAmode: id = AVR_BUILTIN_COUNTLSULLK; break;
default:
error_at (loc, "no matching fixed-point overload found for %qs",
"countlsfx");
fold = error_mark_node;
break;
}
fold = targetm.builtin_decl (id, true);
if (fold != error_mark_node)
fold = build_function_call_vec (loc, vNULL, fold, &args, NULL);
break; // countlsfx
}
return fold;
}
/* Implement `REGISTER_TARGET_PRAGMAS'. */
void
avr_register_target_pragmas (void)
{
gcc_assert (ADDR_SPACE_GENERIC == ADDR_SPACE_RAM);
/* Register address spaces. The order must be the same as in the respective
enum from avr.h (or designated initializers must be used in avr.c).
We always register all address spaces even if some of them make no
sense for some targets. Diagnose for non-supported spaces will be
emit by TARGET_ADDR_SPACE_DIAGNOSE_USAGE. */
for (int i = 0; i < ADDR_SPACE_COUNT; i++)
{
gcc_assert (i == avr_addrspace[i].id);
if (!ADDR_SPACE_GENERIC_P (i))
c_register_addr_space (avr_addrspace[i].name, avr_addrspace[i].id);
}
targetm.resolve_overloaded_builtin = avr_resolve_overloaded_builtin;
}
/* Transform LO into uppercase and write the result to UP.
You must provide enough space for UP. Return UP. */
static char*
avr_toupper (char *up, const char *lo)
{
char *up0 = up;
for (; *lo; lo++, up++)
*up = TOUPPER (*lo);
*up = '\0';
return up0;
}
/* Worker function for TARGET_CPU_CPP_BUILTINS. */
void
avr_cpu_cpp_builtins (struct cpp_reader *pfile)
{
builtin_define_std ("AVR");
/* __AVR_DEVICE_NAME__ and avr_mcu_types[].macro like __AVR_ATmega8__
are defined by -D command option, see device-specs file. */
if (avr_arch->macro)
cpp_define_formatted (pfile, "__AVR_ARCH__=%s", avr_arch->macro);
if (AVR_HAVE_RAMPD) cpp_define (pfile, "__AVR_HAVE_RAMPD__");
if (AVR_HAVE_RAMPX) cpp_define (pfile, "__AVR_HAVE_RAMPX__");
if (AVR_HAVE_RAMPY) cpp_define (pfile, "__AVR_HAVE_RAMPY__");
if (AVR_HAVE_RAMPZ) cpp_define (pfile, "__AVR_HAVE_RAMPZ__");
if (AVR_HAVE_ELPM) cpp_define (pfile, "__AVR_HAVE_ELPM__");
if (AVR_HAVE_ELPMX) cpp_define (pfile, "__AVR_HAVE_ELPMX__");
if (AVR_HAVE_MOVW) cpp_define (pfile, "__AVR_HAVE_MOVW__");
if (AVR_HAVE_LPMX) cpp_define (pfile, "__AVR_HAVE_LPMX__");
if (avr_arch->asm_only)
cpp_define (pfile, "__AVR_ASM_ONLY__");
if (AVR_HAVE_MUL)
{
cpp_define (pfile, "__AVR_ENHANCED__");
cpp_define (pfile, "__AVR_HAVE_MUL__");
}
if (AVR_HAVE_JMP_CALL)
cpp_define (pfile, "__AVR_HAVE_JMP_CALL__");
if (avr_arch->have_jmp_call)
cpp_define (pfile, "__AVR_MEGA__");
if (AVR_SHORT_CALLS)
cpp_define (pfile, "__AVR_SHORT_CALLS__");
if (AVR_XMEGA)
cpp_define (pfile, "__AVR_XMEGA__");
if (AVR_TINY)
{
cpp_define (pfile, "__AVR_TINY__");
/* Define macro "__AVR_TINY_PM_BASE_ADDRESS__" with mapped program memory
start address. This macro shall be used where mapped program
memory is accessed, eg. copying data section (__do_copy_data)
contents to data memory region.
NOTE:
Program memory of AVR_TINY devices cannot be accessed directly,
it has been mapped to the data memory. For AVR_TINY devices
(ATtiny4/5/9/10/20 and 40) mapped program memory starts at 0x4000. */
cpp_define_formatted (pfile, "__AVR_TINY_PM_BASE_ADDRESS__=0x%x",
avr_arch->flash_pm_offset);
}
if (avr_arch->flash_pm_offset)
cpp_define_formatted (pfile, "__AVR_PM_BASE_ADDRESS__=0x%x",
avr_arch->flash_pm_offset);
if (AVR_HAVE_EIJMP_EICALL)
{
cpp_define (pfile, "__AVR_HAVE_EIJMP_EICALL__");
cpp_define (pfile, "__AVR_3_BYTE_PC__");
}
else
{
cpp_define (pfile, "__AVR_2_BYTE_PC__");
}
if (AVR_HAVE_8BIT_SP)
cpp_define (pfile, "__AVR_HAVE_8BIT_SP__");
else
cpp_define (pfile, "__AVR_HAVE_16BIT_SP__");
if (AVR_HAVE_SPH)
cpp_define (pfile, "__AVR_HAVE_SPH__");
else
cpp_define (pfile, "__AVR_SP8__");
if (TARGET_NO_INTERRUPTS)
cpp_define (pfile, "__NO_INTERRUPTS__");
if (TARGET_SKIP_BUG)
{
cpp_define (pfile, "__AVR_ERRATA_SKIP__");
if (AVR_HAVE_JMP_CALL)
cpp_define (pfile, "__AVR_ERRATA_SKIP_JMP_CALL__");
}
if (TARGET_RMW)
cpp_define (pfile, "__AVR_ISA_RMW__");
cpp_define_formatted (pfile, "__AVR_SFR_OFFSET__=0x%x",
avr_arch->sfr_offset);
#ifdef WITH_AVRLIBC
cpp_define (pfile, "__WITH_AVRLIBC__");
#endif /* WITH_AVRLIBC */
// From configure --with-libf7={|libgcc|math|math-symbols|yes|no}
#ifdef WITH_LIBF7_LIBGCC
cpp_define (pfile, "__WITH_LIBF7_LIBGCC__");
#endif /* WITH_LIBF7_LIBGCC */
#ifdef WITH_LIBF7_MATH
cpp_define (pfile, "__WITH_LIBF7_MATH__");
#endif /* WITH_LIBF7_MATH */
#ifdef WITH_LIBF7_MATH_SYMBOLS
cpp_define (pfile, "__WITH_LIBF7_MATH_SYMBOLS__");
#endif /* WITH_LIBF7_MATH_SYMBOLS */
// From configure --with-double={|32|32,64|64,32|64}
#ifdef HAVE_DOUBLE_MULTILIB
cpp_define (pfile, "__HAVE_DOUBLE_MULTILIB__");
#endif
#ifdef HAVE_DOUBLE64
cpp_define (pfile, "__HAVE_DOUBLE64__");
#endif
#ifdef HAVE_DOUBLE32
cpp_define (pfile, "__HAVE_DOUBLE32__");
#endif
#if defined (WITH_DOUBLE64)
cpp_define (pfile, "__DEFAULT_DOUBLE__=64");
#elif defined (WITH_DOUBLE32)
cpp_define (pfile, "__DEFAULT_DOUBLE__=32");
#else
#error "align this with config.gcc"
#endif
// From configure --with-long-double={|32|32,64|64,32|64|double}
#ifdef HAVE_LONG_DOUBLE_MULTILIB
cpp_define (pfile, "__HAVE_LONG_DOUBLE_MULTILIB__");
#endif
#ifdef HAVE_LONG_DOUBLE64
cpp_define (pfile, "__HAVE_LONG_DOUBLE64__");
#endif
#ifdef HAVE_LONG_DOUBLE32
cpp_define (pfile, "__HAVE_LONG_DOUBLE32__");
#endif
#ifdef HAVE_LONG_DOUBLE_IS_DOUBLE
cpp_define (pfile, "__HAVE_LONG_DOUBLE_IS_DOUBLE__");
#endif
#if defined (WITH_LONG_DOUBLE64)
cpp_define (pfile, "__DEFAULT_LONG_DOUBLE__=64");
#elif defined (WITH_LONG_DOUBLE32)
cpp_define (pfile, "__DEFAULT_LONG_DOUBLE__=32");
#else
#error "align this with config.gcc"
#endif
// From configure --with-double-comparison={2|3} --with-libf7.
#if defined (WITH_DOUBLE_COMPARISON)
#if WITH_DOUBLE_COMPARISON == 2 || WITH_DOUBLE_COMPARISON == 3
/* The number of states a DFmode comparison libcall might take and
reflects what avr.c:FLOAT_LIB_COMPARE_RETURNS_BOOL returns for
DFmode. GCC's default is 3-state, but some libraries like LibF7
implement true / false (2-state). */
cpp_define_formatted (pfile, "__WITH_DOUBLE_COMPARISON__=%d",
WITH_DOUBLE_COMPARISON);
#else
#error "align this with config.gcc"
#endif
#else
#error "align this with config.gcc"
#endif
/* Define builtin macros so that the user can easily query whether
non-generic address spaces (and which) are supported or not.
This is only supported for C. For C++, a language extension is needed
(as mentioned in ISO/IEC DTR 18037; Annex F.2) which is not
implemented in GCC up to now. */
if (lang_GNU_C ())
{
for (int i = 0; i < ADDR_SPACE_COUNT; i++)
if (!ADDR_SPACE_GENERIC_P (i)
/* Only supply __FLASH<n> macro if the address space is reasonable
for this target. The address space qualifier itself is still
supported, but using it will throw an error. */
&& avr_addr_space_supported_p ((addr_space_t) i))
{
const char *name = avr_addrspace[i].name;
char *Name = (char*) alloca (1 + strlen (name));
cpp_define (pfile, avr_toupper (Name, name));
}
}
/* Define builtin macros so that the user can easily query whether or
not a specific builtin is available. */
#define DEF_BUILTIN(NAME, N_ARGS, TYPE, CODE, LIBNAME) \
cpp_define (pfile, "__BUILTIN_AVR_" #NAME);
#include "builtins.def"
#undef DEF_BUILTIN
/* Builtin macros for the __int24 and __uint24 type. */
cpp_define_formatted (pfile, "__INT24_MAX__=8388607%s",
INT_TYPE_SIZE == 8 ? "LL" : "L");
cpp_define (pfile, "__INT24_MIN__=(-__INT24_MAX__-1)");
cpp_define_formatted (pfile, "__UINT24_MAX__=16777215%s",
INT_TYPE_SIZE == 8 ? "ULL" : "UL");
}