mirror of
https://github.com/gcc-mirror/gcc.git
synced 2024-11-21 13:40:47 +00:00
5213047b1d
Use INCLUDE_VECTOR before including system.h, instead of directly including <vector>, to avoid running into poisoned identifiers. Signed-off-by: Dimitry Andric <dimitry@andric.com> libcc1/ChangeLog: PR middle-end/111632 * libcc1plugin.cc: Fix include. * libcp1plugin.cc: Fix include.
832 lines
22 KiB
C++
832 lines
22 KiB
C++
/* Library interface to C front end
|
||
Copyright (C) 2014-2024 Free Software Foundation, 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 <cc1plugin-config.h>
|
||
|
||
#undef PACKAGE_NAME
|
||
#undef PACKAGE_STRING
|
||
#undef PACKAGE_TARNAME
|
||
#undef PACKAGE_VERSION
|
||
|
||
#include "../gcc/config.h"
|
||
|
||
#undef PACKAGE_NAME
|
||
#undef PACKAGE_STRING
|
||
#undef PACKAGE_TARNAME
|
||
#undef PACKAGE_VERSION
|
||
|
||
#define INCLUDE_MEMORY
|
||
#define INCLUDE_VECTOR
|
||
#include "gcc-plugin.h"
|
||
#include "system.h"
|
||
#include "coretypes.h"
|
||
#include "stringpool.h"
|
||
|
||
#include "gcc-interface.h"
|
||
#include "hash-set.h"
|
||
#include "machmode.h"
|
||
#include "vec.h"
|
||
#include "double-int.h"
|
||
#include "input.h"
|
||
#include "alias.h"
|
||
#include "symtab.h"
|
||
#include "options.h"
|
||
#include "wide-int.h"
|
||
#include "inchash.h"
|
||
#include "tree.h"
|
||
#include "fold-const.h"
|
||
#include "stor-layout.h"
|
||
#include "c-tree.h"
|
||
#include "toplev.h"
|
||
#include "timevar.h"
|
||
#include "hash-table.h"
|
||
#include "tm.h"
|
||
#include "c-family/c-pragma.h"
|
||
#include "c-lang.h"
|
||
#include "diagnostic.h"
|
||
#include "langhooks.h"
|
||
#include "langhooks-def.h"
|
||
|
||
#include "callbacks.hh"
|
||
#include "connection.hh"
|
||
#include "marshall.hh"
|
||
#include "rpc.hh"
|
||
#include "gcc-c-interface.h"
|
||
#include "context.hh"
|
||
|
||
using namespace cc1_plugin;
|
||
|
||
|
||
|
||
// A wrapper for pushdecl that doesn't let gdb have a chance to
|
||
// instantiate a symbol.
|
||
|
||
static void
|
||
pushdecl_safe (tree decl)
|
||
{
|
||
void (*save) (enum c_oracle_request, tree identifier);
|
||
|
||
save = c_binding_oracle;
|
||
c_binding_oracle = NULL;
|
||
pushdecl (decl);
|
||
c_binding_oracle = save;
|
||
}
|
||
|
||
|
||
|
||
static void
|
||
plugin_binding_oracle (enum c_oracle_request kind, tree identifier)
|
||
{
|
||
enum gcc_c_oracle_request request;
|
||
|
||
gcc_assert (current_context != NULL);
|
||
|
||
switch (kind)
|
||
{
|
||
case C_ORACLE_SYMBOL:
|
||
request = GCC_C_ORACLE_SYMBOL;
|
||
break;
|
||
case C_ORACLE_TAG:
|
||
request = GCC_C_ORACLE_TAG;
|
||
break;
|
||
case C_ORACLE_LABEL:
|
||
request = GCC_C_ORACLE_LABEL;
|
||
break;
|
||
default:
|
||
abort ();
|
||
}
|
||
|
||
int ignore;
|
||
cc1_plugin::call (current_context, "binding_oracle", &ignore,
|
||
request, IDENTIFIER_POINTER (identifier));
|
||
}
|
||
|
||
static void
|
||
plugin_pragma_user_expression (cpp_reader *)
|
||
{
|
||
c_binding_oracle = plugin_binding_oracle;
|
||
}
|
||
|
||
static void
|
||
plugin_init_extra_pragmas (void *, void *)
|
||
{
|
||
c_register_pragma ("GCC", "user_expression", plugin_pragma_user_expression);
|
||
}
|
||
|
||
|
||
|
||
// Maybe rewrite a decl to its address.
|
||
static tree
|
||
address_rewriter (tree *in, int *walk_subtrees, void *arg)
|
||
{
|
||
plugin_context *ctx = (plugin_context *) arg;
|
||
|
||
if (!DECL_P (*in) || DECL_NAME (*in) == NULL_TREE)
|
||
return NULL_TREE;
|
||
|
||
decl_addr_value value;
|
||
value.decl = *in;
|
||
decl_addr_value *found_value = ctx->address_map.find (&value);
|
||
if (found_value != NULL)
|
||
;
|
||
else if (DECL_IS_UNDECLARED_BUILTIN (*in))
|
||
{
|
||
gcc_address address;
|
||
|
||
if (!cc1_plugin::call (ctx, "address_oracle", &address,
|
||
IDENTIFIER_POINTER (DECL_NAME (*in))))
|
||
return NULL_TREE;
|
||
if (address == 0)
|
||
return NULL_TREE;
|
||
|
||
// Insert the decl into the address map in case it is referenced
|
||
// again.
|
||
value.address = build_int_cst_type (ptr_type_node, address);
|
||
decl_addr_value **slot = ctx->address_map.find_slot (&value, INSERT);
|
||
gcc_assert (*slot == NULL);
|
||
*slot
|
||
= static_cast<decl_addr_value *> (xmalloc (sizeof (decl_addr_value)));
|
||
**slot = value;
|
||
found_value = *slot;
|
||
}
|
||
else
|
||
return NULL_TREE;
|
||
|
||
if (found_value->address != error_mark_node)
|
||
{
|
||
// We have an address for the decl, so rewrite the tree.
|
||
tree ptr_type = build_pointer_type (TREE_TYPE (*in));
|
||
*in = fold_build1 (INDIRECT_REF, TREE_TYPE (*in),
|
||
fold_build1 (CONVERT_EXPR, ptr_type,
|
||
found_value->address));
|
||
}
|
||
|
||
*walk_subtrees = 0;
|
||
|
||
return NULL_TREE;
|
||
}
|
||
|
||
// When generating code for gdb, we want to be able to use absolute
|
||
// addresses to refer to otherwise external objects that gdb knows
|
||
// about. gdb passes in these addresses when building decls, and then
|
||
// before gimplification we go through the trees, rewriting uses to
|
||
// the equivalent of "*(TYPE *) ADDR".
|
||
static void
|
||
rewrite_decls_to_addresses (void *function_in, void *)
|
||
{
|
||
tree function = (tree) function_in;
|
||
|
||
// Do nothing if we're not in gdb.
|
||
if (current_context == NULL)
|
||
return;
|
||
|
||
walk_tree (&DECL_SAVED_TREE (function), address_rewriter, current_context,
|
||
NULL);
|
||
}
|
||
|
||
|
||
|
||
gcc_decl
|
||
plugin_build_decl (cc1_plugin::connection *self,
|
||
const char *name,
|
||
enum gcc_c_symbol_kind sym_kind,
|
||
gcc_type sym_type_in,
|
||
const char *substitution_name,
|
||
gcc_address address,
|
||
const char *filename,
|
||
unsigned int line_number)
|
||
{
|
||
plugin_context *ctx = static_cast<plugin_context *> (self);
|
||
tree identifier = get_identifier (name);
|
||
enum tree_code code;
|
||
tree decl;
|
||
tree sym_type = convert_in (sym_type_in);
|
||
|
||
switch (sym_kind)
|
||
{
|
||
case GCC_C_SYMBOL_FUNCTION:
|
||
code = FUNCTION_DECL;
|
||
break;
|
||
|
||
case GCC_C_SYMBOL_VARIABLE:
|
||
code = VAR_DECL;
|
||
break;
|
||
|
||
case GCC_C_SYMBOL_TYPEDEF:
|
||
code = TYPE_DECL;
|
||
break;
|
||
|
||
case GCC_C_SYMBOL_LABEL:
|
||
// FIXME: we aren't ready to handle labels yet.
|
||
// It isn't clear how to translate them properly
|
||
// and in any case a "goto" isn't likely to work.
|
||
return convert_out (error_mark_node);
|
||
|
||
default:
|
||
abort ();
|
||
}
|
||
|
||
location_t loc = ctx->get_location_t (filename, line_number);
|
||
|
||
decl = build_decl (loc, code, identifier, sym_type);
|
||
TREE_USED (decl) = 1;
|
||
TREE_ADDRESSABLE (decl) = 1;
|
||
|
||
if (sym_kind != GCC_C_SYMBOL_TYPEDEF)
|
||
{
|
||
decl_addr_value value;
|
||
|
||
DECL_EXTERNAL (decl) = 1;
|
||
value.decl = decl;
|
||
if (substitution_name != NULL)
|
||
{
|
||
// If the translator gave us a name without a binding,
|
||
// we can just substitute error_mark_node, since we know the
|
||
// translator will be reporting an error anyhow.
|
||
value.address
|
||
= lookup_name (get_identifier (substitution_name));
|
||
if (value.address == NULL_TREE)
|
||
value.address = error_mark_node;
|
||
}
|
||
else
|
||
value.address = build_int_cst_type (ptr_type_node, address);
|
||
decl_addr_value **slot = ctx->address_map.find_slot (&value, INSERT);
|
||
gcc_assert (*slot == NULL);
|
||
*slot
|
||
= static_cast<decl_addr_value *> (xmalloc (sizeof (decl_addr_value)));
|
||
**slot = value;
|
||
}
|
||
|
||
return convert_out (ctx->preserve (decl));
|
||
}
|
||
|
||
int
|
||
plugin_bind (cc1_plugin::connection *,
|
||
gcc_decl decl_in, int is_global)
|
||
{
|
||
tree decl = convert_in (decl_in);
|
||
c_bind (DECL_SOURCE_LOCATION (decl), decl, is_global);
|
||
rest_of_decl_compilation (decl, is_global, 0);
|
||
return 1;
|
||
}
|
||
|
||
int
|
||
plugin_tagbind (cc1_plugin::connection *self,
|
||
const char *name, gcc_type tagged_type,
|
||
const char *filename, unsigned int line_number)
|
||
{
|
||
plugin_context *ctx = static_cast<plugin_context *> (self);
|
||
tree t = convert_in (tagged_type), x;
|
||
c_pushtag (ctx->get_location_t (filename, line_number),
|
||
get_identifier (name), t);
|
||
|
||
/* Propagate the newly-added type name so that previously-created
|
||
variant types are not disconnected from their main variants. */
|
||
for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
|
||
TYPE_NAME (x) = TYPE_NAME (t);
|
||
|
||
return 1;
|
||
}
|
||
|
||
gcc_type
|
||
plugin_build_pointer_type (cc1_plugin::connection *,
|
||
gcc_type base_type)
|
||
{
|
||
// No need to preserve a pointer type as the base type is preserved.
|
||
return convert_out (build_pointer_type (convert_in (base_type)));
|
||
}
|
||
|
||
// TYPE_NAME needs to be a valid pointer, even if there is no name available.
|
||
|
||
static tree
|
||
build_anonymous_node (enum tree_code code)
|
||
{
|
||
tree node = make_node (code);
|
||
tree type_decl = build_decl (input_location, TYPE_DECL, NULL_TREE, node);
|
||
TYPE_NAME (node) = type_decl;
|
||
TYPE_STUB_DECL (node) = type_decl;
|
||
return node;
|
||
}
|
||
|
||
gcc_type
|
||
plugin_build_record_type (cc1_plugin::connection *self)
|
||
{
|
||
plugin_context *ctx = static_cast<plugin_context *> (self);
|
||
return convert_out (ctx->preserve (build_anonymous_node (RECORD_TYPE)));
|
||
}
|
||
|
||
gcc_type
|
||
plugin_build_union_type (cc1_plugin::connection *self)
|
||
{
|
||
plugin_context *ctx = static_cast<plugin_context *> (self);
|
||
return convert_out (ctx->preserve (build_anonymous_node (UNION_TYPE)));
|
||
}
|
||
|
||
int
|
||
plugin_build_add_field (cc1_plugin::connection *,
|
||
gcc_type record_or_union_type_in,
|
||
const char *field_name,
|
||
gcc_type field_type_in,
|
||
unsigned long bitsize,
|
||
unsigned long bitpos)
|
||
{
|
||
tree record_or_union_type = convert_in (record_or_union_type_in);
|
||
tree field_type = convert_in (field_type_in);
|
||
|
||
gcc_assert (TREE_CODE (record_or_union_type) == RECORD_TYPE
|
||
|| TREE_CODE (record_or_union_type) == UNION_TYPE);
|
||
|
||
/* Note that gdb does not preserve the location of field decls, so
|
||
we can't provide a decent location here. */
|
||
tree decl = build_decl (BUILTINS_LOCATION, FIELD_DECL,
|
||
get_identifier (field_name), field_type);
|
||
DECL_FIELD_CONTEXT (decl) = record_or_union_type;
|
||
|
||
if (TREE_CODE (field_type) == INTEGER_TYPE
|
||
&& TYPE_PRECISION (field_type) != bitsize)
|
||
{
|
||
DECL_BIT_FIELD_TYPE (decl) = field_type;
|
||
TREE_TYPE (decl)
|
||
= c_build_bitfield_integer_type (bitsize, TYPE_UNSIGNED (field_type));
|
||
}
|
||
|
||
SET_DECL_MODE (decl, TYPE_MODE (TREE_TYPE (decl)));
|
||
|
||
// There's no way to recover this from DWARF.
|
||
SET_DECL_OFFSET_ALIGN (decl, TYPE_PRECISION (pointer_sized_int_node));
|
||
|
||
tree pos = bitsize_int (bitpos);
|
||
pos_from_bit (&DECL_FIELD_OFFSET (decl), &DECL_FIELD_BIT_OFFSET (decl),
|
||
DECL_OFFSET_ALIGN (decl), pos);
|
||
|
||
DECL_SIZE (decl) = bitsize_int (bitsize);
|
||
DECL_SIZE_UNIT (decl) = size_int ((bitsize + BITS_PER_UNIT - 1)
|
||
/ BITS_PER_UNIT);
|
||
|
||
DECL_CHAIN (decl) = TYPE_FIELDS (record_or_union_type);
|
||
TYPE_FIELDS (record_or_union_type) = decl;
|
||
|
||
return 1;
|
||
}
|
||
|
||
int
|
||
plugin_finish_record_with_alignment (cc1_plugin::connection *,
|
||
gcc_type record_or_union_type_in,
|
||
unsigned long size_in_bytes,
|
||
unsigned long align)
|
||
{
|
||
tree record_or_union_type = convert_in (record_or_union_type_in);
|
||
|
||
gcc_assert (TREE_CODE (record_or_union_type) == RECORD_TYPE
|
||
|| TREE_CODE (record_or_union_type) == UNION_TYPE);
|
||
|
||
/* We built the field list in reverse order, so fix it now. */
|
||
TYPE_FIELDS (record_or_union_type)
|
||
= nreverse (TYPE_FIELDS (record_or_union_type));
|
||
|
||
if (TREE_CODE (record_or_union_type) == UNION_TYPE)
|
||
{
|
||
/* Unions can just be handled by the generic code. */
|
||
layout_type (record_or_union_type);
|
||
}
|
||
else
|
||
{
|
||
if (align == 0)
|
||
align = TYPE_PRECISION (pointer_sized_int_node);
|
||
|
||
SET_TYPE_ALIGN (record_or_union_type, align);
|
||
|
||
TYPE_SIZE (record_or_union_type) = bitsize_int (size_in_bytes
|
||
* BITS_PER_UNIT);
|
||
TYPE_SIZE_UNIT (record_or_union_type) = size_int (size_in_bytes);
|
||
|
||
compute_record_mode (record_or_union_type);
|
||
finish_bitfield_layout (record_or_union_type);
|
||
// FIXME we have no idea about TYPE_PACKED
|
||
}
|
||
|
||
tree t = record_or_union_type, x;
|
||
for (x = TYPE_MAIN_VARIANT (t); x; x = TYPE_NEXT_VARIANT (x))
|
||
{
|
||
/* Like finish_struct, update the qualified variant types. */
|
||
TYPE_FIELDS (x) = TYPE_FIELDS (t);
|
||
TYPE_LANG_SPECIFIC (x) = TYPE_LANG_SPECIFIC (t);
|
||
C_TYPE_FIELDS_READONLY (x) = C_TYPE_FIELDS_READONLY (t);
|
||
C_TYPE_FIELDS_VOLATILE (x) = C_TYPE_FIELDS_VOLATILE (t);
|
||
C_TYPE_VARIABLE_SIZE (x) = C_TYPE_VARIABLE_SIZE (t);
|
||
/* We copy these fields too. */
|
||
SET_TYPE_ALIGN (x, TYPE_ALIGN (t));
|
||
TYPE_SIZE (x) = TYPE_SIZE (t);
|
||
TYPE_SIZE_UNIT (x) = TYPE_SIZE_UNIT (t);
|
||
if (x != record_or_union_type)
|
||
compute_record_mode (x);
|
||
}
|
||
|
||
return 1;
|
||
}
|
||
|
||
int
|
||
plugin_finish_record_or_union (cc1_plugin::connection *conn,
|
||
gcc_type record_or_union_type_in,
|
||
unsigned long size_in_bytes)
|
||
{
|
||
return plugin_finish_record_with_alignment (conn, record_or_union_type_in,
|
||
size_in_bytes, 0);
|
||
}
|
||
|
||
gcc_type
|
||
plugin_build_enum_type (cc1_plugin::connection *self,
|
||
gcc_type underlying_int_type_in)
|
||
{
|
||
tree underlying_int_type = convert_in (underlying_int_type_in);
|
||
|
||
if (underlying_int_type == error_mark_node)
|
||
return convert_out (error_mark_node);
|
||
|
||
tree result = build_anonymous_node (ENUMERAL_TYPE);
|
||
|
||
TYPE_PRECISION (result) = TYPE_PRECISION (underlying_int_type);
|
||
TYPE_UNSIGNED (result) = TYPE_UNSIGNED (underlying_int_type);
|
||
ENUM_UNDERLYING_TYPE (result) = underlying_int_type;
|
||
|
||
plugin_context *ctx = static_cast<plugin_context *> (self);
|
||
return convert_out (ctx->preserve (result));
|
||
}
|
||
|
||
int
|
||
plugin_build_add_enum_constant (cc1_plugin::connection *,
|
||
gcc_type enum_type_in,
|
||
const char *name,
|
||
unsigned long value)
|
||
{
|
||
tree cst, decl, cons;
|
||
tree enum_type = convert_in (enum_type_in);
|
||
|
||
gcc_assert (TREE_CODE (enum_type) == ENUMERAL_TYPE);
|
||
|
||
cst = build_int_cst (enum_type, value);
|
||
/* Note that gdb does not preserve the location of enum constants,
|
||
so we can't provide a decent location here. */
|
||
decl = build_decl (BUILTINS_LOCATION, CONST_DECL,
|
||
get_identifier (name), enum_type);
|
||
DECL_INITIAL (decl) = cst;
|
||
pushdecl_safe (decl);
|
||
|
||
cons = tree_cons (DECL_NAME (decl), cst, TYPE_VALUES (enum_type));
|
||
TYPE_VALUES (enum_type) = cons;
|
||
|
||
return 1;
|
||
}
|
||
|
||
int
|
||
plugin_finish_enum_type (cc1_plugin::connection *,
|
||
gcc_type enum_type_in)
|
||
{
|
||
tree enum_type = convert_in (enum_type_in);
|
||
tree minnode, maxnode, iter;
|
||
|
||
iter = TYPE_VALUES (enum_type);
|
||
minnode = maxnode = TREE_VALUE (iter);
|
||
for (iter = TREE_CHAIN (iter);
|
||
iter != NULL_TREE;
|
||
iter = TREE_CHAIN (iter))
|
||
{
|
||
tree value = TREE_VALUE (iter);
|
||
if (tree_int_cst_lt (maxnode, value))
|
||
maxnode = value;
|
||
if (tree_int_cst_lt (value, minnode))
|
||
minnode = value;
|
||
}
|
||
TYPE_MIN_VALUE (enum_type) = minnode;
|
||
TYPE_MAX_VALUE (enum_type) = maxnode;
|
||
|
||
layout_type (enum_type);
|
||
|
||
return 1;
|
||
}
|
||
|
||
gcc_type
|
||
plugin_build_function_type (cc1_plugin::connection *self,
|
||
gcc_type return_type_in,
|
||
const struct gcc_type_array *argument_types_in,
|
||
int is_varargs)
|
||
{
|
||
tree return_type = convert_in (return_type_in);
|
||
tree result;
|
||
|
||
std::vector<tree> argument_types (argument_types_in->n_elements);
|
||
for (int i = 0; i < argument_types_in->n_elements; ++i)
|
||
argument_types[i] = convert_in (argument_types_in->elements[i]);
|
||
|
||
if (is_varargs)
|
||
result = build_varargs_function_type_array (return_type,
|
||
argument_types_in->n_elements,
|
||
argument_types.data ());
|
||
else
|
||
result = build_function_type_array (return_type,
|
||
argument_types_in->n_elements,
|
||
argument_types.data ());
|
||
|
||
plugin_context *ctx = static_cast<plugin_context *> (self);
|
||
return convert_out (ctx->preserve (result));
|
||
}
|
||
|
||
/* Return a builtin type associated with BUILTIN_NAME. */
|
||
|
||
static tree
|
||
safe_lookup_builtin_type (const char *builtin_name)
|
||
{
|
||
tree result = NULL_TREE;
|
||
|
||
if (!builtin_name)
|
||
return result;
|
||
|
||
result = identifier_global_value (get_identifier (builtin_name));
|
||
|
||
if (!result)
|
||
return result;
|
||
|
||
gcc_assert (TREE_CODE (result) == TYPE_DECL);
|
||
result = TREE_TYPE (result);
|
||
return TREE_CODE (result) == ERROR_MARK ? nullptr : result;
|
||
}
|
||
|
||
static gcc_type
|
||
plugin_int_check (cc1_plugin::connection *self,
|
||
int is_unsigned, unsigned long size_in_bytes,
|
||
tree result)
|
||
{
|
||
if (result == NULL_TREE)
|
||
result = error_mark_node;
|
||
else
|
||
{
|
||
gcc_assert (!TYPE_UNSIGNED (result) == !is_unsigned);
|
||
gcc_assert (TREE_CODE (TYPE_SIZE (result)) == INTEGER_CST);
|
||
gcc_assert (TYPE_PRECISION (result) == BITS_PER_UNIT * size_in_bytes);
|
||
|
||
plugin_context *ctx = static_cast<plugin_context *> (self);
|
||
ctx->preserve (result);
|
||
}
|
||
return convert_out (result);
|
||
}
|
||
|
||
gcc_type
|
||
plugin_int_type_v0 (cc1_plugin::connection *self,
|
||
int is_unsigned, unsigned long size_in_bytes)
|
||
{
|
||
tree result = c_common_type_for_size (BITS_PER_UNIT * size_in_bytes,
|
||
is_unsigned);
|
||
|
||
return plugin_int_check (self, is_unsigned, size_in_bytes, result);
|
||
}
|
||
|
||
gcc_type
|
||
plugin_int_type (cc1_plugin::connection *self,
|
||
int is_unsigned, unsigned long size_in_bytes,
|
||
const char *builtin_name)
|
||
{
|
||
if (builtin_name != nullptr)
|
||
{
|
||
tree result = safe_lookup_builtin_type (builtin_name);
|
||
gcc_assert (!result || TREE_CODE (result) == INTEGER_TYPE);
|
||
if (result != nullptr)
|
||
return plugin_int_check (self, is_unsigned, size_in_bytes, result);
|
||
}
|
||
return plugin_int_type_v0 (self, is_unsigned, size_in_bytes);
|
||
}
|
||
|
||
gcc_type
|
||
plugin_char_type (cc1_plugin::connection *)
|
||
{
|
||
return convert_out (char_type_node);
|
||
}
|
||
|
||
gcc_type
|
||
plugin_float_type_v0 (cc1_plugin::connection *,
|
||
unsigned long size_in_bytes)
|
||
{
|
||
if (BITS_PER_UNIT * size_in_bytes == TYPE_PRECISION (float_type_node))
|
||
return convert_out (float_type_node);
|
||
if (BITS_PER_UNIT * size_in_bytes == TYPE_PRECISION (double_type_node))
|
||
return convert_out (double_type_node);
|
||
if (BITS_PER_UNIT * size_in_bytes == TYPE_PRECISION (long_double_type_node))
|
||
return convert_out (long_double_type_node);
|
||
return convert_out (error_mark_node);
|
||
}
|
||
|
||
gcc_type
|
||
plugin_float_type (cc1_plugin::connection *self,
|
||
unsigned long size_in_bytes,
|
||
const char *builtin_name)
|
||
{
|
||
if (!builtin_name)
|
||
return plugin_float_type_v0 (self, size_in_bytes);
|
||
|
||
tree result = safe_lookup_builtin_type (builtin_name);
|
||
|
||
if (!result)
|
||
return plugin_float_type_v0 (self, size_in_bytes);
|
||
|
||
gcc_assert (SCALAR_FLOAT_TYPE_P (result));
|
||
gcc_assert (BITS_PER_UNIT * size_in_bytes == TYPE_PRECISION (result));
|
||
|
||
return convert_out (result);
|
||
}
|
||
|
||
gcc_type
|
||
plugin_void_type (cc1_plugin::connection *)
|
||
{
|
||
return convert_out (void_type_node);
|
||
}
|
||
|
||
gcc_type
|
||
plugin_bool_type (cc1_plugin::connection *)
|
||
{
|
||
return convert_out (boolean_type_node);
|
||
}
|
||
|
||
gcc_type
|
||
plugin_build_array_type (cc1_plugin::connection *self,
|
||
gcc_type element_type_in, int num_elements)
|
||
{
|
||
tree element_type = convert_in (element_type_in);
|
||
tree result;
|
||
|
||
if (num_elements == -1)
|
||
result = build_array_type (element_type, NULL_TREE);
|
||
else
|
||
result = build_array_type_nelts (element_type, num_elements);
|
||
|
||
plugin_context *ctx = static_cast<plugin_context *> (self);
|
||
return convert_out (ctx->preserve (result));
|
||
}
|
||
|
||
gcc_type
|
||
plugin_build_vla_array_type (cc1_plugin::connection *self,
|
||
gcc_type element_type_in,
|
||
const char *upper_bound_name)
|
||
{
|
||
tree element_type = convert_in (element_type_in);
|
||
tree upper_bound = lookup_name (get_identifier (upper_bound_name));
|
||
tree range = build_index_type (upper_bound);
|
||
|
||
tree result = build_array_type (element_type, range);
|
||
C_TYPE_VARIABLE_SIZE (result) = 1;
|
||
|
||
plugin_context *ctx = static_cast<plugin_context *> (self);
|
||
return convert_out (ctx->preserve (result));
|
||
}
|
||
|
||
gcc_type
|
||
plugin_build_qualified_type (cc1_plugin::connection *,
|
||
gcc_type unqualified_type_in,
|
||
enum gcc_qualifiers qualifiers)
|
||
{
|
||
tree unqualified_type = convert_in (unqualified_type_in);
|
||
int quals = 0;
|
||
|
||
if ((qualifiers & GCC_QUALIFIER_CONST) != 0)
|
||
quals |= TYPE_QUAL_CONST;
|
||
if ((qualifiers & GCC_QUALIFIER_VOLATILE) != 0)
|
||
quals |= TYPE_QUAL_VOLATILE;
|
||
if ((qualifiers & GCC_QUALIFIER_RESTRICT) != 0)
|
||
quals |= TYPE_QUAL_RESTRICT;
|
||
|
||
return convert_out (build_qualified_type (unqualified_type, quals));
|
||
}
|
||
|
||
gcc_type
|
||
plugin_build_complex_type (cc1_plugin::connection *self,
|
||
gcc_type base_type)
|
||
{
|
||
plugin_context *ctx = static_cast<plugin_context *> (self);
|
||
return convert_out (ctx->preserve (build_complex_type (convert_in (base_type))));
|
||
}
|
||
|
||
gcc_type
|
||
plugin_build_vector_type (cc1_plugin::connection *self,
|
||
gcc_type base_type, int nunits)
|
||
{
|
||
plugin_context *ctx = static_cast<plugin_context *> (self);
|
||
return convert_out (ctx->preserve (build_vector_type (convert_in (base_type),
|
||
nunits)));
|
||
}
|
||
|
||
int
|
||
plugin_build_constant (cc1_plugin::connection *self, gcc_type type_in,
|
||
const char *name, unsigned long value,
|
||
const char *filename, unsigned int line_number)
|
||
{
|
||
plugin_context *ctx = static_cast<plugin_context *> (self);
|
||
tree cst, decl;
|
||
tree type = convert_in (type_in);
|
||
|
||
cst = build_int_cst (type, value);
|
||
decl = build_decl (ctx->get_location_t (filename, line_number),
|
||
CONST_DECL, get_identifier (name), type);
|
||
DECL_INITIAL (decl) = cst;
|
||
pushdecl_safe (decl);
|
||
|
||
return 1;
|
||
}
|
||
|
||
gcc_type
|
||
plugin_error (cc1_plugin::connection *,
|
||
const char *message)
|
||
{
|
||
error ("%s", message);
|
||
return convert_out (error_mark_node);
|
||
}
|
||
|
||
|
||
|
||
#ifdef __GNUC__
|
||
#pragma GCC visibility push(default)
|
||
#endif
|
||
|
||
int
|
||
plugin_init (struct plugin_name_args *plugin_info,
|
||
struct plugin_gcc_version *)
|
||
{
|
||
generic_plugin_init (plugin_info, GCC_C_FE_VERSION_2);
|
||
|
||
register_callback (plugin_info->base_name, PLUGIN_PRAGMAS,
|
||
plugin_init_extra_pragmas, NULL);
|
||
register_callback (plugin_info->base_name, PLUGIN_PRE_GENERICIZE,
|
||
rewrite_decls_to_addresses, NULL);
|
||
|
||
#define GCC_METHOD0(R, N) \
|
||
{ \
|
||
cc1_plugin::callback_ftype *fun \
|
||
= cc1_plugin::invoker<R>::invoke<plugin_ ## N>; \
|
||
current_context->add_callback (# N, fun); \
|
||
}
|
||
#define GCC_METHOD1(R, N, A) \
|
||
{ \
|
||
cc1_plugin::callback_ftype *fun \
|
||
= cc1_plugin::invoker<R, A>::invoke<plugin_ ## N>; \
|
||
current_context->add_callback (# N, fun); \
|
||
}
|
||
#define GCC_METHOD2(R, N, A, B) \
|
||
{ \
|
||
cc1_plugin::callback_ftype *fun \
|
||
= cc1_plugin::invoker<R, A, B>::invoke<plugin_ ## N>; \
|
||
current_context->add_callback (# N, fun); \
|
||
}
|
||
#define GCC_METHOD3(R, N, A, B, C) \
|
||
{ \
|
||
cc1_plugin::callback_ftype *fun \
|
||
= cc1_plugin::invoker<R, A, B, C>::invoke<plugin_ ## N>; \
|
||
current_context->add_callback (# N, fun); \
|
||
}
|
||
#define GCC_METHOD4(R, N, A, B, C, D) \
|
||
{ \
|
||
cc1_plugin::callback_ftype *fun \
|
||
= cc1_plugin::invoker<R, A, B, C, \
|
||
D>::invoke<plugin_ ## N>; \
|
||
current_context->add_callback (# N, fun); \
|
||
}
|
||
#define GCC_METHOD5(R, N, A, B, C, D, E) \
|
||
{ \
|
||
cc1_plugin::callback_ftype *fun \
|
||
= cc1_plugin::invoker<R, A, B, C, D, \
|
||
E>::invoke<plugin_ ## N>; \
|
||
current_context->add_callback (# N, fun); \
|
||
}
|
||
#define GCC_METHOD7(R, N, A, B, C, D, E, F, G) \
|
||
{ \
|
||
cc1_plugin::callback_ftype *fun \
|
||
= cc1_plugin::invoker<R, A, B, C, D, \
|
||
E, F, G>::invoke<plugin_ ## N>; \
|
||
current_context->add_callback (# N, fun); \
|
||
}
|
||
|
||
#include "gcc-c-fe.def"
|
||
|
||
#undef GCC_METHOD0
|
||
#undef GCC_METHOD1
|
||
#undef GCC_METHOD2
|
||
#undef GCC_METHOD3
|
||
#undef GCC_METHOD4
|
||
#undef GCC_METHOD5
|
||
#undef GCC_METHOD7
|
||
|
||
return 0;
|
||
}
|