Mercurial > hg > CbC > CbC_gcc
view gcc/config/m32c/m32c-pragma.c @ 67:f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
author | nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp> |
---|---|
date | Tue, 22 Mar 2011 17:18:12 +0900 |
parents | a06113de4d67 |
children | 04ced10e8804 |
line wrap: on
line source
/* M32C Pragma support Copyright (C) 2004, 2007, 2010 Free Software Foundation, Inc. Contributed by Red Hat, Inc. 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/>. */ #include "config.h" #include "system.h" #include "coretypes.h" #include "tm.h" #include "tree.h" #include "c-family/c-pragma.h" #include "c-family/c-common.h" #include "diagnostic-core.h" #include "cpplib.h" #include "hard-reg-set.h" #include "output.h" #include "m32c-protos.h" #include "function.h" #define MAX_RECOG_OPERANDS 10 #include "reload.h" #include "target.h" /* Implements the "GCC memregs" pragma. This pragma takes only an integer, and is semantically identical to the -memregs= command line option. The only catch is, the programmer should only use this pragma at the beginning of the file (preferably, in some project-wide header) to avoid ABI changes related to changing the list of available "registers". */ static void m32c_pragma_memregs (cpp_reader * reader ATTRIBUTE_UNUSED) { /* on off */ tree val; enum cpp_ttype type; HOST_WIDE_INT i; type = pragma_lex (&val); if (type == CPP_NUMBER) { if (host_integerp (val, 1)) { i = tree_low_cst (val, 1); type = pragma_lex (&val); if (type != CPP_EOF) warning (0, "junk at end of #pragma GCC memregs [0..16]"); if (0 <= i && i <= 16) { if (!ok_to_change_target_memregs) { warning (0, "#pragma GCC memregs must precede any function decls"); return; } target_memregs = i; m32c_conditional_register_usage (); } else { warning (0, "#pragma GCC memregs takes a number [0..16]"); } return; } } error ("#pragma GCC memregs takes a number [0..16]"); } /* Implements the "pragma ADDRESS" pragma. This pragma takes a variable name and an address, and arranges for that variable to be "at" that address. The variable is also made volatile. */ static void m32c_pragma_address (cpp_reader * reader ATTRIBUTE_UNUSED) { /* on off */ tree var, addr; enum cpp_ttype type; type = pragma_lex (&var); if (type == CPP_NAME) { type = pragma_lex (&addr); if (type == CPP_NUMBER) { if (var != error_mark_node) { unsigned uaddr = tree_low_cst (addr, 1); m32c_note_pragma_address (IDENTIFIER_POINTER (var), uaddr); } type = pragma_lex (&var); if (type != CPP_EOF) { error ("junk at end of #pragma ADDRESS"); } return; } } error ("malformed #pragma ADDRESS variable address"); } /* Implements REGISTER_TARGET_PRAGMAS. */ void m32c_register_pragmas (void) { c_register_pragma ("GCC", "memregs", m32c_pragma_memregs); c_register_pragma (NULL, "ADDRESS", m32c_pragma_address); c_register_pragma (NULL, "address", m32c_pragma_address); /* R8C and M16C have 16-bit pointers in a 20-bit address zpace. M32C has 24-bit pointers in a 24-bit address space, so does not need far pointers, but we accept the qualifier anyway, as a no-op. */ if (TARGET_A16) c_register_addr_space ("__far", ADDR_SPACE_FAR); else c_register_addr_space ("__far", ADDR_SPACE_GENERIC); }