118334Speter/* Build expressions with type checking for C compiler. 2169689Skan Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 3169689Skan 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 4169689Skan Free Software Foundation, Inc. 518334Speter 690075SobrienThis file is part of GCC. 718334Speter 890075SobrienGCC is free software; you can redistribute it and/or modify it under 990075Sobrienthe terms of the GNU General Public License as published by the Free 1090075SobrienSoftware Foundation; either version 2, or (at your option) any later 1190075Sobrienversion. 1218334Speter 1390075SobrienGCC is distributed in the hope that it will be useful, but WITHOUT ANY 1490075SobrienWARRANTY; without even the implied warranty of MERCHANTABILITY or 1590075SobrienFITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 1690075Sobrienfor more details. 1718334Speter 1818334SpeterYou should have received a copy of the GNU General Public License 1990075Sobrienalong with GCC; see the file COPYING. If not, write to the Free 20169689SkanSoftware Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 21169689Skan02110-1301, USA. */ 2218334Speter 2318334Speter 2418334Speter/* This file is part of the C front end. 2518334Speter It contains routines to build C expressions given their operands, 2618334Speter including computing the types of the result, C-specific error checks, 27169689Skan and some optimization. */ 2818334Speter 2918334Speter#include "config.h" 3050397Sobrien#include "system.h" 31132718Skan#include "coretypes.h" 32132718Skan#include "tm.h" 3390075Sobrien#include "rtl.h" 3418334Speter#include "tree.h" 35169689Skan#include "langhooks.h" 3618334Speter#include "c-tree.h" 3790075Sobrien#include "tm_p.h" 3818334Speter#include "flags.h" 3918334Speter#include "output.h" 4050397Sobrien#include "expr.h" 4150397Sobrien#include "toplev.h" 4252284Sobrien#include "intl.h" 4390075Sobrien#include "ggc.h" 4490075Sobrien#include "target.h" 45169689Skan#include "tree-iterator.h" 46169689Skan#include "tree-gimple.h" 47169689Skan#include "tree-flow.h" 4818334Speter 49169689Skan/* Possible cases of implicit bad conversions. Used to select 50169689Skan diagnostic messages in convert_for_assignment. */ 51169689Skanenum impl_conv { 52169689Skan ic_argpass, 53169689Skan ic_argpass_nonproto, 54169689Skan ic_assign, 55169689Skan ic_init, 56169689Skan ic_return 57169689Skan}; 58169689Skan 59169689Skan/* The level of nesting inside "__alignof__". */ 60169689Skanint in_alignof; 61169689Skan 62169689Skan/* The level of nesting inside "sizeof". */ 63169689Skanint in_sizeof; 64169689Skan 65169689Skan/* The level of nesting inside "typeof". */ 66169689Skanint in_typeof; 67169689Skan 68169689Skanstruct c_label_context_se *label_context_stack_se; 69169689Skanstruct c_label_context_vm *label_context_stack_vm; 70169689Skan 7118334Speter/* Nonzero if we've already printed a "missing braces around initializer" 7218334Speter message within this initializer. */ 7318334Speterstatic int missing_braces_mentioned; 7418334Speter 75132718Skanstatic int require_constant_value; 76132718Skanstatic int require_constant_elements; 7790075Sobrien 78169689Skanstatic bool null_pointer_constant_p (tree); 79132718Skanstatic tree qualify_type (tree, tree); 80169689Skanstatic int tagged_types_tu_compatible_p (tree, tree); 81169689Skanstatic int comp_target_types (tree, tree); 82169689Skanstatic int function_types_compatible_p (tree, tree); 83169689Skanstatic int type_lists_compatible_p (tree, tree); 84132718Skanstatic tree decl_constant_value_for_broken_optimization (tree); 85132718Skanstatic tree lookup_field (tree, tree); 86132718Skanstatic tree convert_arguments (tree, tree, tree, tree); 87132718Skanstatic tree pointer_diff (tree, tree); 88169689Skanstatic tree convert_for_assignment (tree, tree, enum impl_conv, tree, tree, 89132718Skan int); 90132718Skanstatic tree valid_compound_expr_initializer (tree, tree); 91132718Skanstatic void push_string (const char *); 92132718Skanstatic void push_member_name (tree); 93132718Skanstatic int spelling_length (void); 94132718Skanstatic char *print_spelling (char *); 95132718Skanstatic void warning_init (const char *); 96169689Skanstatic tree digest_init (tree, tree, bool, int); 97169689Skanstatic void output_init_element (tree, bool, tree, tree, int); 98132718Skanstatic void output_pending_init_elements (int); 99132718Skanstatic int set_designator (int); 100132718Skanstatic void push_range_stack (tree); 101132718Skanstatic void add_pending_init (tree, tree); 102132718Skanstatic void set_nonincremental_init (void); 103132718Skanstatic void set_nonincremental_init_from_string (tree); 104132718Skanstatic tree find_init_member (tree); 105169689Skanstatic void readonly_error (tree, enum lvalue_use); 106169689Skanstatic int lvalue_or_else (tree, enum lvalue_use); 107169689Skanstatic int lvalue_p (tree); 108169689Skanstatic void record_maybe_used_decl (tree); 109169689Skanstatic int comptypes_internal (tree, tree); 11018334Speter 111169689Skan/* Return true if EXP is a null pointer constant, false otherwise. */ 112169689Skan 113169689Skanstatic bool 114169689Skannull_pointer_constant_p (tree expr) 115169689Skan{ 116169689Skan /* This should really operate on c_expr structures, but they aren't 117169689Skan yet available everywhere required. */ 118169689Skan tree type = TREE_TYPE (expr); 119169689Skan return (TREE_CODE (expr) == INTEGER_CST 120169689Skan && !TREE_CONSTANT_OVERFLOW (expr) 121169689Skan && integer_zerop (expr) 122169689Skan && (INTEGRAL_TYPE_P (type) 123169689Skan || (TREE_CODE (type) == POINTER_TYPE 124169689Skan && VOID_TYPE_P (TREE_TYPE (type)) 125169689Skan && TYPE_QUALS (TREE_TYPE (type)) == TYPE_UNQUALIFIED))); 126169689Skan} 127169689Skan/* This is a cache to hold if two types are compatible or not. */ 128169689Skan 129169689Skanstruct tagged_tu_seen_cache { 130169689Skan const struct tagged_tu_seen_cache * next; 131169689Skan tree t1; 132169689Skan tree t2; 133169689Skan /* The return value of tagged_types_tu_compatible_p if we had seen 134169689Skan these two types already. */ 135169689Skan int val; 136169689Skan}; 137169689Skan 138169689Skanstatic const struct tagged_tu_seen_cache * tagged_tu_seen_base; 139169689Skanstatic void free_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache *); 140169689Skan 14118334Speter/* Do `exp = require_complete_type (exp);' to make sure exp 14218334Speter does not have an incomplete type. (That includes void types.) */ 14318334Speter 14418334Spetertree 145132718Skanrequire_complete_type (tree value) 14618334Speter{ 14718334Speter tree type = TREE_TYPE (value); 14818334Speter 14990075Sobrien if (value == error_mark_node || type == error_mark_node) 15052284Sobrien return error_mark_node; 15152284Sobrien 15218334Speter /* First, detect a valid value with a complete type. */ 15390075Sobrien if (COMPLETE_TYPE_P (type)) 15418334Speter return value; 15518334Speter 156117395Skan c_incomplete_type_error (value, type); 15718334Speter return error_mark_node; 15818334Speter} 15918334Speter 16018334Speter/* Print an error message for invalid use of an incomplete type. 16118334Speter VALUE is the expression that was used (or 0 if that isn't known) 16218334Speter and TYPE is the type that was invalid. */ 16318334Speter 16418334Spetervoid 165132718Skanc_incomplete_type_error (tree value, tree type) 16618334Speter{ 16752284Sobrien const char *type_code_string; 16818334Speter 16918334Speter /* Avoid duplicate error message. */ 17018334Speter if (TREE_CODE (type) == ERROR_MARK) 17118334Speter return; 17218334Speter 17318334Speter if (value != 0 && (TREE_CODE (value) == VAR_DECL 17418334Speter || TREE_CODE (value) == PARM_DECL)) 175169689Skan error ("%qD has an incomplete type", value); 17618334Speter else 17718334Speter { 17818334Speter retry: 17918334Speter /* We must print an error message. Be clever about what it says. */ 18018334Speter 18118334Speter switch (TREE_CODE (type)) 18218334Speter { 18318334Speter case RECORD_TYPE: 18452284Sobrien type_code_string = "struct"; 18518334Speter break; 18618334Speter 18718334Speter case UNION_TYPE: 18852284Sobrien type_code_string = "union"; 18918334Speter break; 19018334Speter 19118334Speter case ENUMERAL_TYPE: 19252284Sobrien type_code_string = "enum"; 19318334Speter break; 19418334Speter 19518334Speter case VOID_TYPE: 19618334Speter error ("invalid use of void expression"); 19718334Speter return; 19818334Speter 19918334Speter case ARRAY_TYPE: 20018334Speter if (TYPE_DOMAIN (type)) 20118334Speter { 20296263Sobrien if (TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL) 20396263Sobrien { 20496263Sobrien error ("invalid use of flexible array member"); 20596263Sobrien return; 20696263Sobrien } 20718334Speter type = TREE_TYPE (type); 20818334Speter goto retry; 20918334Speter } 21018334Speter error ("invalid use of array with unspecified bounds"); 21118334Speter return; 21218334Speter 21318334Speter default: 214169689Skan gcc_unreachable (); 21518334Speter } 21618334Speter 21718334Speter if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) 218169689Skan error ("invalid use of undefined type %<%s %E%>", 219169689Skan type_code_string, TYPE_NAME (type)); 22018334Speter else 22118334Speter /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */ 222169689Skan error ("invalid use of incomplete typedef %qD", TYPE_NAME (type)); 22318334Speter } 22418334Speter} 22518334Speter 226117395Skan/* Given a type, apply default promotions wrt unnamed function 227117395Skan arguments and return the new type. */ 228117395Skan 229117395Skantree 230132718Skanc_type_promotes_to (tree type) 231117395Skan{ 232117395Skan if (TYPE_MAIN_VARIANT (type) == float_type_node) 233117395Skan return double_type_node; 234117395Skan 235117395Skan if (c_promoting_integer_type_p (type)) 236117395Skan { 237117395Skan /* Preserve unsignedness if not really getting any wider. */ 238169689Skan if (TYPE_UNSIGNED (type) 239169689Skan && (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))) 240169689Skan return unsigned_type_node; 241117395Skan return integer_type_node; 242117395Skan } 243117395Skan 244117395Skan return type; 245117395Skan} 246117395Skan 24718334Speter/* Return a variant of TYPE which has all the type qualifiers of LIKE 24818334Speter as well as those of TYPE. */ 24918334Speter 25018334Speterstatic tree 251132718Skanqualify_type (tree type, tree like) 25218334Speter{ 253132718Skan return c_build_qualified_type (type, 25452750Sobrien TYPE_QUALS (type) | TYPE_QUALS (like)); 25518334Speter} 256169689Skan 257169689Skan/* Return true iff the given tree T is a variable length array. */ 258169689Skan 259169689Skanbool 260169689Skanc_vla_type_p (tree t) 261169689Skan{ 262169689Skan if (TREE_CODE (t) == ARRAY_TYPE 263169689Skan && C_TYPE_VARIABLE_SIZE (t)) 264169689Skan return true; 265169689Skan return false; 266169689Skan} 26718334Speter 268169689Skan/* Return the composite type of two compatible types. 26918334Speter 270169689Skan We assume that comptypes has already been done and returned 271169689Skan nonzero; if that isn't so, this may crash. In particular, we 272169689Skan assume that qualifiers match. */ 27318334Speter 27418334Spetertree 275169689Skancomposite_type (tree t1, tree t2) 27618334Speter{ 27790075Sobrien enum tree_code code1; 27890075Sobrien enum tree_code code2; 27918334Speter tree attributes; 28018334Speter 28118334Speter /* Save time if the two types are the same. */ 28218334Speter 28318334Speter if (t1 == t2) return t1; 28418334Speter 28518334Speter /* If one type is nonsense, use the other. */ 28618334Speter if (t1 == error_mark_node) 28718334Speter return t2; 28818334Speter if (t2 == error_mark_node) 28918334Speter return t1; 29018334Speter 291169689Skan code1 = TREE_CODE (t1); 292169689Skan code2 = TREE_CODE (t2); 293169689Skan 29450397Sobrien /* Merge the attributes. */ 295169689Skan attributes = targetm.merge_type_attributes (t1, t2); 29618334Speter 297169689Skan /* If one is an enumerated type and the other is the compatible 298169689Skan integer type, the composite type might be either of the two 299169689Skan (DR#013 question 3). For consistency, use the enumerated type as 300169689Skan the composite type. */ 30118334Speter 302169689Skan if (code1 == ENUMERAL_TYPE && code2 == INTEGER_TYPE) 303169689Skan return t1; 304169689Skan if (code2 == ENUMERAL_TYPE && code1 == INTEGER_TYPE) 305169689Skan return t2; 30618334Speter 307169689Skan gcc_assert (code1 == code2); 30818334Speter 30918334Speter switch (code1) 31018334Speter { 31118334Speter case POINTER_TYPE: 312169689Skan /* For two pointers, do this recursively on the target type. */ 31318334Speter { 31452284Sobrien tree pointed_to_1 = TREE_TYPE (t1); 31552284Sobrien tree pointed_to_2 = TREE_TYPE (t2); 316169689Skan tree target = composite_type (pointed_to_1, pointed_to_2); 317169689Skan t1 = build_pointer_type (target); 318169689Skan t1 = build_type_attribute_variant (t1, attributes); 319169689Skan return qualify_type (t1, t2); 32018334Speter } 32118334Speter 32218334Speter case ARRAY_TYPE: 32318334Speter { 324169689Skan tree elt = composite_type (TREE_TYPE (t1), TREE_TYPE (t2)); 325169689Skan int quals; 326169689Skan tree unqual_elt; 327169689Skan tree d1 = TYPE_DOMAIN (t1); 328169689Skan tree d2 = TYPE_DOMAIN (t2); 329169689Skan bool d1_variable, d2_variable; 330169689Skan bool d1_zero, d2_zero; 331169689Skan 332169689Skan /* We should not have any type quals on arrays at all. */ 333169689Skan gcc_assert (!TYPE_QUALS (t1) && !TYPE_QUALS (t2)); 334169689Skan 335169689Skan d1_zero = d1 == 0 || !TYPE_MAX_VALUE (d1); 336169689Skan d2_zero = d2 == 0 || !TYPE_MAX_VALUE (d2); 337169689Skan 338169689Skan d1_variable = (!d1_zero 339169689Skan && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST 340169689Skan || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST)); 341169689Skan d2_variable = (!d2_zero 342169689Skan && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST 343169689Skan || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST)); 344169689Skan d1_variable = d1_variable || (d1_zero && c_vla_type_p (t1)); 345169689Skan d2_variable = d2_variable || (d2_zero && c_vla_type_p (t2)); 346169689Skan 34718334Speter /* Save space: see if the result is identical to one of the args. */ 348169689Skan if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1) 349169689Skan && (d2_variable || d2_zero || !d1_variable)) 35018334Speter return build_type_attribute_variant (t1, attributes); 351169689Skan if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2) 352169689Skan && (d1_variable || d1_zero || !d2_variable)) 35318334Speter return build_type_attribute_variant (t2, attributes); 354169689Skan 355169689Skan if (elt == TREE_TYPE (t1) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1)) 356169689Skan return build_type_attribute_variant (t1, attributes); 357169689Skan if (elt == TREE_TYPE (t2) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1)) 358169689Skan return build_type_attribute_variant (t2, attributes); 359169689Skan 360169689Skan /* Merge the element types, and have a size if either arg has 361169689Skan one. We may have qualifiers on the element types. To set 362169689Skan up TYPE_MAIN_VARIANT correctly, we need to form the 363169689Skan composite of the unqualified types and add the qualifiers 364169689Skan back at the end. */ 365169689Skan quals = TYPE_QUALS (strip_array_types (elt)); 366169689Skan unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED); 367169689Skan t1 = build_array_type (unqual_elt, 368169689Skan TYPE_DOMAIN ((TYPE_DOMAIN (t1) 369169689Skan && (d2_variable 370169689Skan || d2_zero 371169689Skan || !d1_variable)) 372169689Skan ? t1 373169689Skan : t2)); 374169689Skan t1 = c_build_qualified_type (t1, quals); 37518334Speter return build_type_attribute_variant (t1, attributes); 37618334Speter } 37718334Speter 378169689Skan case ENUMERAL_TYPE: 379169689Skan case RECORD_TYPE: 380169689Skan case UNION_TYPE: 381169689Skan if (attributes != NULL) 382169689Skan { 383169689Skan /* Try harder not to create a new aggregate type. */ 384169689Skan if (attribute_list_equal (TYPE_ATTRIBUTES (t1), attributes)) 385169689Skan return t1; 386169689Skan if (attribute_list_equal (TYPE_ATTRIBUTES (t2), attributes)) 387169689Skan return t2; 388169689Skan } 389169689Skan return build_type_attribute_variant (t1, attributes); 390169689Skan 39118334Speter case FUNCTION_TYPE: 39218334Speter /* Function types: prefer the one that specified arg types. 39318334Speter If both do, merge the arg types. Also merge the return types. */ 39418334Speter { 395169689Skan tree valtype = composite_type (TREE_TYPE (t1), TREE_TYPE (t2)); 39618334Speter tree p1 = TYPE_ARG_TYPES (t1); 39718334Speter tree p2 = TYPE_ARG_TYPES (t2); 39818334Speter int len; 39918334Speter tree newargs, n; 40018334Speter int i; 40118334Speter 40218334Speter /* Save space: see if the result is identical to one of the args. */ 403169689Skan if (valtype == TREE_TYPE (t1) && !TYPE_ARG_TYPES (t2)) 40418334Speter return build_type_attribute_variant (t1, attributes); 405169689Skan if (valtype == TREE_TYPE (t2) && !TYPE_ARG_TYPES (t1)) 40618334Speter return build_type_attribute_variant (t2, attributes); 40718334Speter 40818334Speter /* Simple way if one arg fails to specify argument types. */ 40918334Speter if (TYPE_ARG_TYPES (t1) == 0) 41018334Speter { 411169689Skan t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2)); 412169689Skan t1 = build_type_attribute_variant (t1, attributes); 413169689Skan return qualify_type (t1, t2); 41418334Speter } 41518334Speter if (TYPE_ARG_TYPES (t2) == 0) 41618334Speter { 41718334Speter t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1)); 418169689Skan t1 = build_type_attribute_variant (t1, attributes); 419169689Skan return qualify_type (t1, t2); 42018334Speter } 42118334Speter 42218334Speter /* If both args specify argument types, we must merge the two 42318334Speter lists, argument by argument. */ 424169689Skan /* Tell global_bindings_p to return false so that variable_size 425169689Skan doesn't die on VLAs in parameter types. */ 426169689Skan c_override_global_bindings_to_false = true; 42718334Speter 42818334Speter len = list_length (p1); 42918334Speter newargs = 0; 43018334Speter 43118334Speter for (i = 0; i < len; i++) 43218334Speter newargs = tree_cons (NULL_TREE, NULL_TREE, newargs); 43318334Speter 43418334Speter n = newargs; 43518334Speter 43618334Speter for (; p1; 43718334Speter p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n)) 43818334Speter { 43918334Speter /* A null type means arg type is not specified. 44018334Speter Take whatever the other function type has. */ 44118334Speter if (TREE_VALUE (p1) == 0) 44218334Speter { 44318334Speter TREE_VALUE (n) = TREE_VALUE (p2); 44418334Speter goto parm_done; 44518334Speter } 44618334Speter if (TREE_VALUE (p2) == 0) 44718334Speter { 44818334Speter TREE_VALUE (n) = TREE_VALUE (p1); 44918334Speter goto parm_done; 45018334Speter } 451132718Skan 45218334Speter /* Given wait (union {union wait *u; int *i} *) 45318334Speter and wait (union wait *), 45418334Speter prefer union wait * as type of parm. */ 45518334Speter if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE 45618334Speter && TREE_VALUE (p1) != TREE_VALUE (p2)) 45718334Speter { 45818334Speter tree memb; 459169689Skan tree mv2 = TREE_VALUE (p2); 460169689Skan if (mv2 && mv2 != error_mark_node 461169689Skan && TREE_CODE (mv2) != ARRAY_TYPE) 462169689Skan mv2 = TYPE_MAIN_VARIANT (mv2); 46318334Speter for (memb = TYPE_FIELDS (TREE_VALUE (p1)); 46418334Speter memb; memb = TREE_CHAIN (memb)) 465169689Skan { 466169689Skan tree mv3 = TREE_TYPE (memb); 467169689Skan if (mv3 && mv3 != error_mark_node 468169689Skan && TREE_CODE (mv3) != ARRAY_TYPE) 469169689Skan mv3 = TYPE_MAIN_VARIANT (mv3); 470169689Skan if (comptypes (mv3, mv2)) 471169689Skan { 472169689Skan TREE_VALUE (n) = composite_type (TREE_TYPE (memb), 473169689Skan TREE_VALUE (p2)); 474169689Skan if (pedantic) 475169689Skan pedwarn ("function types not truly compatible in ISO C"); 476169689Skan goto parm_done; 477169689Skan } 478169689Skan } 47918334Speter } 48018334Speter if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE 48118334Speter && TREE_VALUE (p2) != TREE_VALUE (p1)) 48218334Speter { 48318334Speter tree memb; 484169689Skan tree mv1 = TREE_VALUE (p1); 485169689Skan if (mv1 && mv1 != error_mark_node 486169689Skan && TREE_CODE (mv1) != ARRAY_TYPE) 487169689Skan mv1 = TYPE_MAIN_VARIANT (mv1); 48818334Speter for (memb = TYPE_FIELDS (TREE_VALUE (p2)); 48918334Speter memb; memb = TREE_CHAIN (memb)) 490169689Skan { 491169689Skan tree mv3 = TREE_TYPE (memb); 492169689Skan if (mv3 && mv3 != error_mark_node 493169689Skan && TREE_CODE (mv3) != ARRAY_TYPE) 494169689Skan mv3 = TYPE_MAIN_VARIANT (mv3); 495169689Skan if (comptypes (mv3, mv1)) 496169689Skan { 497169689Skan TREE_VALUE (n) = composite_type (TREE_TYPE (memb), 498169689Skan TREE_VALUE (p1)); 499169689Skan if (pedantic) 500169689Skan pedwarn ("function types not truly compatible in ISO C"); 501169689Skan goto parm_done; 502169689Skan } 503169689Skan } 50418334Speter } 505169689Skan TREE_VALUE (n) = composite_type (TREE_VALUE (p1), TREE_VALUE (p2)); 50618334Speter parm_done: ; 50718334Speter } 50818334Speter 509169689Skan c_override_global_bindings_to_false = false; 51018334Speter t1 = build_function_type (valtype, newargs); 511169689Skan t1 = qualify_type (t1, t2); 51250397Sobrien /* ... falls through ... */ 51318334Speter } 51418334Speter 51518334Speter default: 51618334Speter return build_type_attribute_variant (t1, attributes); 51718334Speter } 51818334Speter 51918334Speter} 520169689Skan 521169689Skan/* Return the type of a conditional expression between pointers to 522169689Skan possibly differently qualified versions of compatible types. 523169689Skan 524169689Skan We assume that comp_target_types has already been done and returned 525169689Skan nonzero; if that isn't so, this may crash. */ 526169689Skan 527169689Skanstatic tree 528169689Skancommon_pointer_type (tree t1, tree t2) 529169689Skan{ 530169689Skan tree attributes; 531169689Skan tree pointed_to_1, mv1; 532169689Skan tree pointed_to_2, mv2; 533169689Skan tree target; 534169689Skan 535169689Skan /* Save time if the two types are the same. */ 536169689Skan 537169689Skan if (t1 == t2) return t1; 538169689Skan 539169689Skan /* If one type is nonsense, use the other. */ 540169689Skan if (t1 == error_mark_node) 541169689Skan return t2; 542169689Skan if (t2 == error_mark_node) 543169689Skan return t1; 544169689Skan 545169689Skan gcc_assert (TREE_CODE (t1) == POINTER_TYPE 546169689Skan && TREE_CODE (t2) == POINTER_TYPE); 547169689Skan 548169689Skan /* Merge the attributes. */ 549169689Skan attributes = targetm.merge_type_attributes (t1, t2); 550169689Skan 551169689Skan /* Find the composite type of the target types, and combine the 552169689Skan qualifiers of the two types' targets. Do not lose qualifiers on 553169689Skan array element types by taking the TYPE_MAIN_VARIANT. */ 554169689Skan mv1 = pointed_to_1 = TREE_TYPE (t1); 555169689Skan mv2 = pointed_to_2 = TREE_TYPE (t2); 556169689Skan if (TREE_CODE (mv1) != ARRAY_TYPE) 557169689Skan mv1 = TYPE_MAIN_VARIANT (pointed_to_1); 558169689Skan if (TREE_CODE (mv2) != ARRAY_TYPE) 559169689Skan mv2 = TYPE_MAIN_VARIANT (pointed_to_2); 560169689Skan target = composite_type (mv1, mv2); 561169689Skan t1 = build_pointer_type (c_build_qualified_type 562169689Skan (target, 563169689Skan TYPE_QUALS (pointed_to_1) | 564169689Skan TYPE_QUALS (pointed_to_2))); 565169689Skan return build_type_attribute_variant (t1, attributes); 566169689Skan} 567169689Skan 568169689Skan/* Return the common type for two arithmetic types under the usual 569169689Skan arithmetic conversions. The default conversions have already been 570169689Skan applied, and enumerated types converted to their compatible integer 571169689Skan types. The resulting type is unqualified and has no attributes. 572169689Skan 573169689Skan This is the type for the result of most arithmetic operations 574169689Skan if the operands have the given two types. */ 575169689Skan 576169689Skanstatic tree 577169689Skanc_common_type (tree t1, tree t2) 578169689Skan{ 579169689Skan enum tree_code code1; 580169689Skan enum tree_code code2; 581169689Skan 582169689Skan /* If one type is nonsense, use the other. */ 583169689Skan if (t1 == error_mark_node) 584169689Skan return t2; 585169689Skan if (t2 == error_mark_node) 586169689Skan return t1; 587169689Skan 588169689Skan if (TYPE_QUALS (t1) != TYPE_UNQUALIFIED) 589169689Skan t1 = TYPE_MAIN_VARIANT (t1); 590169689Skan 591169689Skan if (TYPE_QUALS (t2) != TYPE_UNQUALIFIED) 592169689Skan t2 = TYPE_MAIN_VARIANT (t2); 593169689Skan 594169689Skan if (TYPE_ATTRIBUTES (t1) != NULL_TREE) 595169689Skan t1 = build_type_attribute_variant (t1, NULL_TREE); 596169689Skan 597169689Skan if (TYPE_ATTRIBUTES (t2) != NULL_TREE) 598169689Skan t2 = build_type_attribute_variant (t2, NULL_TREE); 599169689Skan 600169689Skan /* Save time if the two types are the same. */ 601169689Skan 602169689Skan if (t1 == t2) return t1; 603169689Skan 604169689Skan code1 = TREE_CODE (t1); 605169689Skan code2 = TREE_CODE (t2); 606169689Skan 607169689Skan gcc_assert (code1 == VECTOR_TYPE || code1 == COMPLEX_TYPE 608169689Skan || code1 == REAL_TYPE || code1 == INTEGER_TYPE); 609169689Skan gcc_assert (code2 == VECTOR_TYPE || code2 == COMPLEX_TYPE 610169689Skan || code2 == REAL_TYPE || code2 == INTEGER_TYPE); 611169689Skan 612169689Skan /* When one operand is a decimal float type, the other operand cannot be 613169689Skan a generic float type or a complex type. We also disallow vector types 614169689Skan here. */ 615169689Skan if ((DECIMAL_FLOAT_TYPE_P (t1) || DECIMAL_FLOAT_TYPE_P (t2)) 616169689Skan && !(DECIMAL_FLOAT_TYPE_P (t1) && DECIMAL_FLOAT_TYPE_P (t2))) 617169689Skan { 618169689Skan if (code1 == VECTOR_TYPE || code2 == VECTOR_TYPE) 619169689Skan { 620169689Skan error ("can%'t mix operands of decimal float and vector types"); 621169689Skan return error_mark_node; 622169689Skan } 623169689Skan if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE) 624169689Skan { 625169689Skan error ("can%'t mix operands of decimal float and complex types"); 626169689Skan return error_mark_node; 627169689Skan } 628169689Skan if (code1 == REAL_TYPE && code2 == REAL_TYPE) 629169689Skan { 630169689Skan error ("can%'t mix operands of decimal float and other float types"); 631169689Skan return error_mark_node; 632169689Skan } 633169689Skan } 634169689Skan 635169689Skan /* If one type is a vector type, return that type. (How the usual 636169689Skan arithmetic conversions apply to the vector types extension is not 637169689Skan precisely specified.) */ 638169689Skan if (code1 == VECTOR_TYPE) 639169689Skan return t1; 640169689Skan 641169689Skan if (code2 == VECTOR_TYPE) 642169689Skan return t2; 643169689Skan 644169689Skan /* If one type is complex, form the common type of the non-complex 645169689Skan components, then make that complex. Use T1 or T2 if it is the 646169689Skan required type. */ 647169689Skan if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE) 648169689Skan { 649169689Skan tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1; 650169689Skan tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2; 651169689Skan tree subtype = c_common_type (subtype1, subtype2); 652169689Skan 653169689Skan if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype) 654169689Skan return t1; 655169689Skan else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype) 656169689Skan return t2; 657169689Skan else 658169689Skan return build_complex_type (subtype); 659169689Skan } 660169689Skan 661169689Skan /* If only one is real, use it as the result. */ 662169689Skan 663169689Skan if (code1 == REAL_TYPE && code2 != REAL_TYPE) 664169689Skan return t1; 665169689Skan 666169689Skan if (code2 == REAL_TYPE && code1 != REAL_TYPE) 667169689Skan return t2; 668169689Skan 669169689Skan /* If both are real and either are decimal floating point types, use 670169689Skan the decimal floating point type with the greater precision. */ 671169689Skan 672169689Skan if (code1 == REAL_TYPE && code2 == REAL_TYPE) 673169689Skan { 674169689Skan if (TYPE_MAIN_VARIANT (t1) == dfloat128_type_node 675169689Skan || TYPE_MAIN_VARIANT (t2) == dfloat128_type_node) 676169689Skan return dfloat128_type_node; 677169689Skan else if (TYPE_MAIN_VARIANT (t1) == dfloat64_type_node 678169689Skan || TYPE_MAIN_VARIANT (t2) == dfloat64_type_node) 679169689Skan return dfloat64_type_node; 680169689Skan else if (TYPE_MAIN_VARIANT (t1) == dfloat32_type_node 681169689Skan || TYPE_MAIN_VARIANT (t2) == dfloat32_type_node) 682169689Skan return dfloat32_type_node; 683169689Skan } 684169689Skan 685169689Skan /* Both real or both integers; use the one with greater precision. */ 686169689Skan 687169689Skan if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2)) 688169689Skan return t1; 689169689Skan else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1)) 690169689Skan return t2; 691169689Skan 692169689Skan /* Same precision. Prefer long longs to longs to ints when the 693169689Skan same precision, following the C99 rules on integer type rank 694169689Skan (which are equivalent to the C90 rules for C90 types). */ 695169689Skan 696169689Skan if (TYPE_MAIN_VARIANT (t1) == long_long_unsigned_type_node 697169689Skan || TYPE_MAIN_VARIANT (t2) == long_long_unsigned_type_node) 698169689Skan return long_long_unsigned_type_node; 699169689Skan 700169689Skan if (TYPE_MAIN_VARIANT (t1) == long_long_integer_type_node 701169689Skan || TYPE_MAIN_VARIANT (t2) == long_long_integer_type_node) 702169689Skan { 703169689Skan if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2)) 704169689Skan return long_long_unsigned_type_node; 705169689Skan else 706169689Skan return long_long_integer_type_node; 707169689Skan } 708169689Skan 709169689Skan if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node 710169689Skan || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node) 711169689Skan return long_unsigned_type_node; 712169689Skan 713169689Skan if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node 714169689Skan || TYPE_MAIN_VARIANT (t2) == long_integer_type_node) 715169689Skan { 716169689Skan /* But preserve unsignedness from the other type, 717169689Skan since long cannot hold all the values of an unsigned int. */ 718169689Skan if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2)) 719169689Skan return long_unsigned_type_node; 720169689Skan else 721169689Skan return long_integer_type_node; 722169689Skan } 723169689Skan 724169689Skan /* Likewise, prefer long double to double even if same size. */ 725169689Skan if (TYPE_MAIN_VARIANT (t1) == long_double_type_node 726169689Skan || TYPE_MAIN_VARIANT (t2) == long_double_type_node) 727169689Skan return long_double_type_node; 728169689Skan 729169689Skan /* Otherwise prefer the unsigned one. */ 730169689Skan 731169689Skan if (TYPE_UNSIGNED (t1)) 732169689Skan return t1; 733169689Skan else 734169689Skan return t2; 735169689Skan} 73618334Speter 737169689Skan/* Wrapper around c_common_type that is used by c-common.c and other 738169689Skan front end optimizations that remove promotions. ENUMERAL_TYPEs 739169689Skan are allowed here and are converted to their compatible integer types. 740169689Skan BOOLEAN_TYPEs are allowed here and return either boolean_type_node or 741169689Skan preferably a non-Boolean type as the common type. */ 742169689Skantree 743169689Skancommon_type (tree t1, tree t2) 744169689Skan{ 745169689Skan if (TREE_CODE (t1) == ENUMERAL_TYPE) 746169689Skan t1 = c_common_type_for_size (TYPE_PRECISION (t1), 1); 747169689Skan if (TREE_CODE (t2) == ENUMERAL_TYPE) 748169689Skan t2 = c_common_type_for_size (TYPE_PRECISION (t2), 1); 749169689Skan 750169689Skan /* If both types are BOOLEAN_TYPE, then return boolean_type_node. */ 751169689Skan if (TREE_CODE (t1) == BOOLEAN_TYPE 752169689Skan && TREE_CODE (t2) == BOOLEAN_TYPE) 753169689Skan return boolean_type_node; 754169689Skan 755169689Skan /* If either type is BOOLEAN_TYPE, then return the other. */ 756169689Skan if (TREE_CODE (t1) == BOOLEAN_TYPE) 757169689Skan return t2; 758169689Skan if (TREE_CODE (t2) == BOOLEAN_TYPE) 759169689Skan return t1; 760169689Skan 761169689Skan return c_common_type (t1, t2); 762169689Skan} 763169689Skan 76418334Speter/* Return 1 if TYPE1 and TYPE2 are compatible types for assignment 76518334Speter or various other operations. Return 2 if they are compatible 76618334Speter but a warning may be needed if you use them together. */ 76718334Speter 76818334Speterint 769169689Skancomptypes (tree type1, tree type2) 77018334Speter{ 771169689Skan const struct tagged_tu_seen_cache * tagged_tu_seen_base1 = tagged_tu_seen_base; 772169689Skan int val; 773169689Skan 774169689Skan val = comptypes_internal (type1, type2); 775169689Skan free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1); 776169689Skan 777169689Skan return val; 778169689Skan} 779169689Skan 780169689Skan/* Return 1 if TYPE1 and TYPE2 are compatible types for assignment 781169689Skan or various other operations. Return 2 if they are compatible 782169689Skan but a warning may be needed if you use them together. This 783169689Skan differs from comptypes, in that we don't free the seen types. */ 784169689Skan 785169689Skanstatic int 786169689Skancomptypes_internal (tree type1, tree type2) 787169689Skan{ 78890075Sobrien tree t1 = type1; 78990075Sobrien tree t2 = type2; 79018334Speter int attrval, val; 79118334Speter 79218334Speter /* Suppress errors caused by previously reported errors. */ 79318334Speter 79450397Sobrien if (t1 == t2 || !t1 || !t2 79550397Sobrien || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK) 79618334Speter return 1; 79718334Speter 79890075Sobrien /* If either type is the internal version of sizetype, return the 79990075Sobrien language version. */ 80090075Sobrien if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1) 801169689Skan && TYPE_ORIG_SIZE_TYPE (t1)) 802169689Skan t1 = TYPE_ORIG_SIZE_TYPE (t1); 80390075Sobrien 80490075Sobrien if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2) 805169689Skan && TYPE_ORIG_SIZE_TYPE (t2)) 806169689Skan t2 = TYPE_ORIG_SIZE_TYPE (t2); 80790075Sobrien 808169689Skan 809132718Skan /* Enumerated types are compatible with integer types, but this is 810132718Skan not transitive: two enumerated types in the same translation unit 811132718Skan are compatible with each other only if they are the same type. */ 81218334Speter 813132718Skan if (TREE_CODE (t1) == ENUMERAL_TYPE && TREE_CODE (t2) != ENUMERAL_TYPE) 814169689Skan t1 = c_common_type_for_size (TYPE_PRECISION (t1), TYPE_UNSIGNED (t1)); 815132718Skan else if (TREE_CODE (t2) == ENUMERAL_TYPE && TREE_CODE (t1) != ENUMERAL_TYPE) 816169689Skan t2 = c_common_type_for_size (TYPE_PRECISION (t2), TYPE_UNSIGNED (t2)); 81718334Speter 81818334Speter if (t1 == t2) 81918334Speter return 1; 82018334Speter 82118334Speter /* Different classes of types can't be compatible. */ 82218334Speter 823132718Skan if (TREE_CODE (t1) != TREE_CODE (t2)) 824132718Skan return 0; 82518334Speter 826169689Skan /* Qualifiers must match. C99 6.7.3p9 */ 82718334Speter 82852284Sobrien if (TYPE_QUALS (t1) != TYPE_QUALS (t2)) 82918334Speter return 0; 83018334Speter 83118334Speter /* Allow for two different type nodes which have essentially the same 83218334Speter definition. Note that we already checked for equality of the type 83350397Sobrien qualifiers (just above). */ 83418334Speter 835169689Skan if (TREE_CODE (t1) != ARRAY_TYPE 836169689Skan && TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2)) 83718334Speter return 1; 83818334Speter 83918334Speter /* 1 if no need for warning yet, 2 if warning cause has been seen. */ 840169689Skan if (!(attrval = targetm.comp_type_attributes (t1, t2))) 84118334Speter return 0; 84218334Speter 84318334Speter /* 1 if no need for warning yet, 2 if warning cause has been seen. */ 84418334Speter val = 0; 84518334Speter 84618334Speter switch (TREE_CODE (t1)) 84718334Speter { 84818334Speter case POINTER_TYPE: 849169689Skan /* Do not remove mode or aliasing information. */ 850169689Skan if (TYPE_MODE (t1) != TYPE_MODE (t2) 851169689Skan || TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2)) 852132718Skan break; 85318334Speter val = (TREE_TYPE (t1) == TREE_TYPE (t2) 854169689Skan ? 1 : comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2))); 85518334Speter break; 85618334Speter 85718334Speter case FUNCTION_TYPE: 858169689Skan val = function_types_compatible_p (t1, t2); 85918334Speter break; 86018334Speter 86118334Speter case ARRAY_TYPE: 86218334Speter { 86318334Speter tree d1 = TYPE_DOMAIN (t1); 86418334Speter tree d2 = TYPE_DOMAIN (t2); 86590075Sobrien bool d1_variable, d2_variable; 86690075Sobrien bool d1_zero, d2_zero; 86718334Speter val = 1; 86818334Speter 86918334Speter /* Target types must match incl. qualifiers. */ 87018334Speter if (TREE_TYPE (t1) != TREE_TYPE (t2) 871169689Skan && 0 == (val = comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2)))) 87218334Speter return 0; 87318334Speter 87418334Speter /* Sizes must match unless one is missing or variable. */ 87590075Sobrien if (d1 == 0 || d2 == 0 || d1 == d2) 87618334Speter break; 87718334Speter 878169689Skan d1_zero = !TYPE_MAX_VALUE (d1); 879169689Skan d2_zero = !TYPE_MAX_VALUE (d2); 88090075Sobrien 881169689Skan d1_variable = (!d1_zero 88290075Sobrien && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST 88390075Sobrien || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST)); 884169689Skan d2_variable = (!d2_zero 88590075Sobrien && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST 88690075Sobrien || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST)); 887169689Skan d1_variable = d1_variable || (d1_zero && c_vla_type_p (t1)); 888169689Skan d2_variable = d2_variable || (d2_zero && c_vla_type_p (t2)); 88990075Sobrien 89090075Sobrien if (d1_variable || d2_variable) 89190075Sobrien break; 89290075Sobrien if (d1_zero && d2_zero) 89390075Sobrien break; 89490075Sobrien if (d1_zero || d2_zero 895169689Skan || !tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2)) 896169689Skan || !tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2))) 89790075Sobrien val = 0; 89890075Sobrien 899169689Skan break; 90018334Speter } 90118334Speter 902169689Skan case ENUMERAL_TYPE: 90318334Speter case RECORD_TYPE: 904132718Skan case UNION_TYPE: 905132718Skan if (val != 1 && !same_translation_unit_p (t1, t2)) 906169689Skan { 907169689Skan tree a1 = TYPE_ATTRIBUTES (t1); 908169689Skan tree a2 = TYPE_ATTRIBUTES (t2); 909169689Skan 910169689Skan if (! attribute_list_contained (a1, a2) 911169689Skan && ! attribute_list_contained (a2, a1)) 912169689Skan break; 913169689Skan 914169689Skan if (attrval != 2) 915169689Skan return tagged_types_tu_compatible_p (t1, t2); 916169689Skan val = tagged_types_tu_compatible_p (t1, t2); 917169689Skan } 91818334Speter break; 91950397Sobrien 920132718Skan case VECTOR_TYPE: 921169689Skan val = TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2) 922169689Skan && comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2)); 923132718Skan break; 924132718Skan 92550397Sobrien default: 92650397Sobrien break; 92718334Speter } 92818334Speter return attrval == 2 && val == 1 ? 2 : val; 92918334Speter} 93018334Speter 93118334Speter/* Return 1 if TTL and TTR are pointers to types that are equivalent, 932169689Skan ignoring their qualifiers. */ 93318334Speter 93418334Speterstatic int 935169689Skancomp_target_types (tree ttl, tree ttr) 93618334Speter{ 93718334Speter int val; 938169689Skan tree mvl, mvr; 93918334Speter 940169689Skan /* Do not lose qualifiers on element types of array types that are 941169689Skan pointer targets by taking their TYPE_MAIN_VARIANT. */ 942169689Skan mvl = TREE_TYPE (ttl); 943169689Skan mvr = TREE_TYPE (ttr); 944169689Skan if (TREE_CODE (mvl) != ARRAY_TYPE) 945169689Skan mvl = TYPE_MAIN_VARIANT (mvl); 946169689Skan if (TREE_CODE (mvr) != ARRAY_TYPE) 947169689Skan mvr = TYPE_MAIN_VARIANT (mvr); 948169689Skan val = comptypes (mvl, mvr); 94918334Speter 95018334Speter if (val == 2 && pedantic) 95118334Speter pedwarn ("types are not quite compatible"); 95218334Speter return val; 95318334Speter} 95418334Speter 95518334Speter/* Subroutines of `comptypes'. */ 95618334Speter 957169689Skan/* Determine whether two trees derive from the same translation unit. 958169689Skan If the CONTEXT chain ends in a null, that tree's context is still 959169689Skan being parsed, so if two trees have context chains ending in null, 960132718Skan they're in the same translation unit. */ 961169689Skanint 962132718Skansame_translation_unit_p (tree t1, tree t2) 963132718Skan{ 964132718Skan while (t1 && TREE_CODE (t1) != TRANSLATION_UNIT_DECL) 965132718Skan switch (TREE_CODE_CLASS (TREE_CODE (t1))) 966132718Skan { 967169689Skan case tcc_declaration: 968169689Skan t1 = DECL_CONTEXT (t1); break; 969169689Skan case tcc_type: 970169689Skan t1 = TYPE_CONTEXT (t1); break; 971169689Skan case tcc_exceptional: 972169689Skan t1 = BLOCK_SUPERCONTEXT (t1); break; /* assume block */ 973169689Skan default: gcc_unreachable (); 974132718Skan } 975132718Skan 976132718Skan while (t2 && TREE_CODE (t2) != TRANSLATION_UNIT_DECL) 977132718Skan switch (TREE_CODE_CLASS (TREE_CODE (t2))) 978132718Skan { 979169689Skan case tcc_declaration: 980169689Skan t2 = DECL_CONTEXT (t2); break; 981169689Skan case tcc_type: 982169689Skan t2 = TYPE_CONTEXT (t2); break; 983169689Skan case tcc_exceptional: 984169689Skan t2 = BLOCK_SUPERCONTEXT (t2); break; /* assume block */ 985169689Skan default: gcc_unreachable (); 986132718Skan } 987132718Skan 988132718Skan return t1 == t2; 989132718Skan} 990132718Skan 991169689Skan/* Allocate the seen two types, assuming that they are compatible. */ 992132718Skan 993169689Skanstatic struct tagged_tu_seen_cache * 994169689Skanalloc_tagged_tu_seen_cache (tree t1, tree t2) 995169689Skan{ 996169689Skan struct tagged_tu_seen_cache *tu = XNEW (struct tagged_tu_seen_cache); 997169689Skan tu->next = tagged_tu_seen_base; 998169689Skan tu->t1 = t1; 999169689Skan tu->t2 = t2; 1000132718Skan 1001169689Skan tagged_tu_seen_base = tu; 1002132718Skan 1003169689Skan /* The C standard says that two structures in different translation 1004169689Skan units are compatible with each other only if the types of their 1005169689Skan fields are compatible (among other things). We assume that they 1006169689Skan are compatible until proven otherwise when building the cache. 1007169689Skan An example where this can occur is: 1008169689Skan struct a 1009169689Skan { 1010169689Skan struct a *next; 1011169689Skan }; 1012169689Skan If we are comparing this against a similar struct in another TU, 1013169689Skan and did not assume they were compatible, we end up with an infinite 1014169689Skan loop. */ 1015169689Skan tu->val = 1; 1016169689Skan return tu; 1017169689Skan} 1018132718Skan 1019169689Skan/* Free the seen types until we get to TU_TIL. */ 1020169689Skan 1021169689Skanstatic void 1022169689Skanfree_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache *tu_til) 1023169689Skan{ 1024169689Skan const struct tagged_tu_seen_cache *tu = tagged_tu_seen_base; 1025169689Skan while (tu != tu_til) 1026169689Skan { 1027169689Skan struct tagged_tu_seen_cache *tu1 = (struct tagged_tu_seen_cache*)tu; 1028169689Skan tu = tu1->next; 1029169689Skan free (tu1); 1030169689Skan } 1031169689Skan tagged_tu_seen_base = tu_til; 1032169689Skan} 1033169689Skan 1034132718Skan/* Return 1 if two 'struct', 'union', or 'enum' types T1 and T2 are 1035132718Skan compatible. If the two types are not the same (which has been 1036132718Skan checked earlier), this can only happen when multiple translation 1037132718Skan units are being compiled. See C99 6.2.7 paragraph 1 for the exact 1038132718Skan rules. */ 1039132718Skan 1040132718Skanstatic int 1041169689Skantagged_types_tu_compatible_p (tree t1, tree t2) 1042132718Skan{ 1043132718Skan tree s1, s2; 1044132718Skan bool needs_warning = false; 1045132718Skan 1046132718Skan /* We have to verify that the tags of the types are the same. This 1047132718Skan is harder than it looks because this may be a typedef, so we have 1048132718Skan to go look at the original type. It may even be a typedef of a 1049169689Skan typedef... 1050169689Skan In the case of compiler-created builtin structs the TYPE_DECL 1051169689Skan may be a dummy, with no DECL_ORIGINAL_TYPE. Don't fault. */ 1052132718Skan while (TYPE_NAME (t1) 1053132718Skan && TREE_CODE (TYPE_NAME (t1)) == TYPE_DECL 1054132718Skan && DECL_ORIGINAL_TYPE (TYPE_NAME (t1))) 1055132718Skan t1 = DECL_ORIGINAL_TYPE (TYPE_NAME (t1)); 1056132718Skan 1057132718Skan while (TYPE_NAME (t2) 1058132718Skan && TREE_CODE (TYPE_NAME (t2)) == TYPE_DECL 1059132718Skan && DECL_ORIGINAL_TYPE (TYPE_NAME (t2))) 1060132718Skan t2 = DECL_ORIGINAL_TYPE (TYPE_NAME (t2)); 1061132718Skan 1062132718Skan /* C90 didn't have the requirement that the two tags be the same. */ 1063132718Skan if (flag_isoc99 && TYPE_NAME (t1) != TYPE_NAME (t2)) 1064132718Skan return 0; 1065132718Skan 1066132718Skan /* C90 didn't say what happened if one or both of the types were 1067132718Skan incomplete; we choose to follow C99 rules here, which is that they 1068132718Skan are compatible. */ 1069132718Skan if (TYPE_SIZE (t1) == NULL 1070132718Skan || TYPE_SIZE (t2) == NULL) 1071132718Skan return 1; 1072132718Skan 1073132718Skan { 1074169689Skan const struct tagged_tu_seen_cache * tts_i; 1075132718Skan for (tts_i = tagged_tu_seen_base; tts_i != NULL; tts_i = tts_i->next) 1076132718Skan if (tts_i->t1 == t1 && tts_i->t2 == t2) 1077169689Skan return tts_i->val; 1078132718Skan } 1079132718Skan 1080132718Skan switch (TREE_CODE (t1)) 1081132718Skan { 1082132718Skan case ENUMERAL_TYPE: 1083132718Skan { 1084169689Skan struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2); 1085169689Skan /* Speed up the case where the type values are in the same order. */ 1086169689Skan tree tv1 = TYPE_VALUES (t1); 1087169689Skan tree tv2 = TYPE_VALUES (t2); 1088169689Skan 1089169689Skan if (tv1 == tv2) 1090169689Skan { 1091169689Skan return 1; 1092169689Skan } 1093169689Skan 1094169689Skan for (;tv1 && tv2; tv1 = TREE_CHAIN (tv1), tv2 = TREE_CHAIN (tv2)) 1095169689Skan { 1096169689Skan if (TREE_PURPOSE (tv1) != TREE_PURPOSE (tv2)) 1097169689Skan break; 1098169689Skan if (simple_cst_equal (TREE_VALUE (tv1), TREE_VALUE (tv2)) != 1) 1099169689Skan { 1100169689Skan tu->val = 0; 1101169689Skan return 0; 1102169689Skan } 1103169689Skan } 1104169689Skan 1105169689Skan if (tv1 == NULL_TREE && tv2 == NULL_TREE) 1106169689Skan { 1107169689Skan return 1; 1108169689Skan } 1109169689Skan if (tv1 == NULL_TREE || tv2 == NULL_TREE) 1110169689Skan { 1111169689Skan tu->val = 0; 1112169689Skan return 0; 1113169689Skan } 1114169689Skan 1115132718Skan if (list_length (TYPE_VALUES (t1)) != list_length (TYPE_VALUES (t2))) 1116169689Skan { 1117169689Skan tu->val = 0; 1118169689Skan return 0; 1119169689Skan } 1120132718Skan 1121132718Skan for (s1 = TYPE_VALUES (t1); s1; s1 = TREE_CHAIN (s1)) 1122132718Skan { 1123132718Skan s2 = purpose_member (TREE_PURPOSE (s1), TYPE_VALUES (t2)); 1124132718Skan if (s2 == NULL 1125132718Skan || simple_cst_equal (TREE_VALUE (s1), TREE_VALUE (s2)) != 1) 1126169689Skan { 1127169689Skan tu->val = 0; 1128169689Skan return 0; 1129169689Skan } 1130132718Skan } 1131132718Skan return 1; 1132132718Skan } 1133132718Skan 1134132718Skan case UNION_TYPE: 1135132718Skan { 1136169689Skan struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2); 1137132718Skan if (list_length (TYPE_FIELDS (t1)) != list_length (TYPE_FIELDS (t2))) 1138169689Skan { 1139169689Skan tu->val = 0; 1140169689Skan return 0; 1141169689Skan } 1142132718Skan 1143169689Skan /* Speed up the common case where the fields are in the same order. */ 1144169689Skan for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2); s1 && s2; 1145169689Skan s1 = TREE_CHAIN (s1), s2 = TREE_CHAIN (s2)) 1146169689Skan { 1147169689Skan int result; 1148169689Skan 1149169689Skan 1150169689Skan if (DECL_NAME (s1) == NULL 1151169689Skan || DECL_NAME (s1) != DECL_NAME (s2)) 1152169689Skan break; 1153169689Skan result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2)); 1154169689Skan if (result == 0) 1155169689Skan { 1156169689Skan tu->val = 0; 1157169689Skan return 0; 1158169689Skan } 1159169689Skan if (result == 2) 1160169689Skan needs_warning = true; 1161169689Skan 1162169689Skan if (TREE_CODE (s1) == FIELD_DECL 1163169689Skan && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1), 1164169689Skan DECL_FIELD_BIT_OFFSET (s2)) != 1) 1165169689Skan { 1166169689Skan tu->val = 0; 1167169689Skan return 0; 1168169689Skan } 1169169689Skan } 1170169689Skan if (!s1 && !s2) 1171169689Skan { 1172169689Skan tu->val = needs_warning ? 2 : 1; 1173169689Skan return tu->val; 1174169689Skan } 1175169689Skan 1176132718Skan for (s1 = TYPE_FIELDS (t1); s1; s1 = TREE_CHAIN (s1)) 1177132718Skan { 1178132718Skan bool ok = false; 1179132718Skan 1180132718Skan if (DECL_NAME (s1) != NULL) 1181169689Skan for (s2 = TYPE_FIELDS (t2); s2; s2 = TREE_CHAIN (s2)) 1182132718Skan if (DECL_NAME (s1) == DECL_NAME (s2)) 1183132718Skan { 1184132718Skan int result; 1185169689Skan result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2)); 1186132718Skan if (result == 0) 1187169689Skan { 1188169689Skan tu->val = 0; 1189169689Skan return 0; 1190169689Skan } 1191132718Skan if (result == 2) 1192132718Skan needs_warning = true; 1193132718Skan 1194132718Skan if (TREE_CODE (s1) == FIELD_DECL 1195132718Skan && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1), 1196132718Skan DECL_FIELD_BIT_OFFSET (s2)) != 1) 1197132718Skan break; 1198132718Skan 1199132718Skan ok = true; 1200132718Skan break; 1201132718Skan } 1202169689Skan if (!ok) 1203169689Skan { 1204169689Skan tu->val = 0; 1205169689Skan return 0; 1206169689Skan } 1207132718Skan } 1208169689Skan tu->val = needs_warning ? 2 : 10; 1209169689Skan return tu->val; 1210132718Skan } 1211132718Skan 1212132718Skan case RECORD_TYPE: 1213132718Skan { 1214169689Skan struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2); 1215132718Skan 1216132718Skan for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2); 1217132718Skan s1 && s2; 1218132718Skan s1 = TREE_CHAIN (s1), s2 = TREE_CHAIN (s2)) 1219132718Skan { 1220132718Skan int result; 1221132718Skan if (TREE_CODE (s1) != TREE_CODE (s2) 1222132718Skan || DECL_NAME (s1) != DECL_NAME (s2)) 1223132718Skan break; 1224169689Skan result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2)); 1225132718Skan if (result == 0) 1226132718Skan break; 1227132718Skan if (result == 2) 1228132718Skan needs_warning = true; 1229132718Skan 1230132718Skan if (TREE_CODE (s1) == FIELD_DECL 1231132718Skan && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1), 1232132718Skan DECL_FIELD_BIT_OFFSET (s2)) != 1) 1233132718Skan break; 1234132718Skan } 1235132718Skan if (s1 && s2) 1236169689Skan tu->val = 0; 1237169689Skan else 1238169689Skan tu->val = needs_warning ? 2 : 1; 1239169689Skan return tu->val; 1240132718Skan } 1241132718Skan 1242132718Skan default: 1243169689Skan gcc_unreachable (); 1244132718Skan } 1245132718Skan} 1246132718Skan 124718334Speter/* Return 1 if two function types F1 and F2 are compatible. 124818334Speter If either type specifies no argument types, 124918334Speter the other must specify a fixed number of self-promoting arg types. 1250132718Skan Otherwise, if one type specifies only the number of arguments, 125118334Speter the other must specify that number of self-promoting arg types. 125218334Speter Otherwise, the argument types must match. */ 125318334Speter 125418334Speterstatic int 1255169689Skanfunction_types_compatible_p (tree f1, tree f2) 125618334Speter{ 125718334Speter tree args1, args2; 125818334Speter /* 1 if no need for warning yet, 2 if warning cause has been seen. */ 125918334Speter int val = 1; 126018334Speter int val1; 1261132718Skan tree ret1, ret2; 126218334Speter 1263132718Skan ret1 = TREE_TYPE (f1); 1264132718Skan ret2 = TREE_TYPE (f2); 1265132718Skan 1266169689Skan /* 'volatile' qualifiers on a function's return type used to mean 1267169689Skan the function is noreturn. */ 1268169689Skan if (TYPE_VOLATILE (ret1) != TYPE_VOLATILE (ret2)) 1269169689Skan pedwarn ("function return types not compatible due to %<volatile%>"); 1270132718Skan if (TYPE_VOLATILE (ret1)) 1271132718Skan ret1 = build_qualified_type (TYPE_MAIN_VARIANT (ret1), 1272132718Skan TYPE_QUALS (ret1) & ~TYPE_QUAL_VOLATILE); 1273132718Skan if (TYPE_VOLATILE (ret2)) 1274132718Skan ret2 = build_qualified_type (TYPE_MAIN_VARIANT (ret2), 1275132718Skan TYPE_QUALS (ret2) & ~TYPE_QUAL_VOLATILE); 1276169689Skan val = comptypes_internal (ret1, ret2); 1277132718Skan if (val == 0) 127818334Speter return 0; 127918334Speter 128018334Speter args1 = TYPE_ARG_TYPES (f1); 128118334Speter args2 = TYPE_ARG_TYPES (f2); 128218334Speter 128318334Speter /* An unspecified parmlist matches any specified parmlist 128418334Speter whose argument types don't need default promotions. */ 128518334Speter 128618334Speter if (args1 == 0) 128718334Speter { 128818334Speter if (!self_promoting_args_p (args2)) 128918334Speter return 0; 129018334Speter /* If one of these types comes from a non-prototype fn definition, 129118334Speter compare that with the other type's arglist. 129218334Speter If they don't match, ask for a warning (but no error). */ 129318334Speter if (TYPE_ACTUAL_ARG_TYPES (f1) 1294169689Skan && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1))) 129518334Speter val = 2; 129618334Speter return val; 129718334Speter } 129818334Speter if (args2 == 0) 129918334Speter { 130018334Speter if (!self_promoting_args_p (args1)) 130118334Speter return 0; 130218334Speter if (TYPE_ACTUAL_ARG_TYPES (f2) 1303169689Skan && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2))) 130418334Speter val = 2; 130518334Speter return val; 130618334Speter } 130718334Speter 130818334Speter /* Both types have argument lists: compare them and propagate results. */ 1309169689Skan val1 = type_lists_compatible_p (args1, args2); 131018334Speter return val1 != 1 ? val1 : val; 131118334Speter} 131218334Speter 131318334Speter/* Check two lists of types for compatibility, 131418334Speter returning 0 for incompatible, 1 for compatible, 131518334Speter or 2 for compatible with warning. */ 131618334Speter 131718334Speterstatic int 1318169689Skantype_lists_compatible_p (tree args1, tree args2) 131918334Speter{ 132018334Speter /* 1 if no need for warning yet, 2 if warning cause has been seen. */ 132118334Speter int val = 1; 132218334Speter int newval = 0; 132318334Speter 132418334Speter while (1) 132518334Speter { 1326169689Skan tree a1, mv1, a2, mv2; 132718334Speter if (args1 == 0 && args2 == 0) 132818334Speter return val; 132918334Speter /* If one list is shorter than the other, 133018334Speter they fail to match. */ 133118334Speter if (args1 == 0 || args2 == 0) 133218334Speter return 0; 1333169689Skan mv1 = a1 = TREE_VALUE (args1); 1334169689Skan mv2 = a2 = TREE_VALUE (args2); 1335169689Skan if (mv1 && mv1 != error_mark_node && TREE_CODE (mv1) != ARRAY_TYPE) 1336169689Skan mv1 = TYPE_MAIN_VARIANT (mv1); 1337169689Skan if (mv2 && mv2 != error_mark_node && TREE_CODE (mv2) != ARRAY_TYPE) 1338169689Skan mv2 = TYPE_MAIN_VARIANT (mv2); 133918334Speter /* A null pointer instead of a type 134018334Speter means there is supposed to be an argument 134118334Speter but nothing is specified about what type it has. 134218334Speter So match anything that self-promotes. */ 1343169689Skan if (a1 == 0) 134418334Speter { 1345169689Skan if (c_type_promotes_to (a2) != a2) 134618334Speter return 0; 134718334Speter } 1348169689Skan else if (a2 == 0) 134918334Speter { 1350169689Skan if (c_type_promotes_to (a1) != a1) 135118334Speter return 0; 135218334Speter } 1353132718Skan /* If one of the lists has an error marker, ignore this arg. */ 1354169689Skan else if (TREE_CODE (a1) == ERROR_MARK 1355169689Skan || TREE_CODE (a2) == ERROR_MARK) 1356132718Skan ; 1357169689Skan else if (!(newval = comptypes_internal (mv1, mv2))) 135818334Speter { 135918334Speter /* Allow wait (union {union wait *u; int *i} *) 136018334Speter and wait (union wait *) to be compatible. */ 1361169689Skan if (TREE_CODE (a1) == UNION_TYPE 1362169689Skan && (TYPE_NAME (a1) == 0 1363169689Skan || TYPE_TRANSPARENT_UNION (a1)) 1364169689Skan && TREE_CODE (TYPE_SIZE (a1)) == INTEGER_CST 1365169689Skan && tree_int_cst_equal (TYPE_SIZE (a1), 1366169689Skan TYPE_SIZE (a2))) 136718334Speter { 136818334Speter tree memb; 1369169689Skan for (memb = TYPE_FIELDS (a1); 137018334Speter memb; memb = TREE_CHAIN (memb)) 1371169689Skan { 1372169689Skan tree mv3 = TREE_TYPE (memb); 1373169689Skan if (mv3 && mv3 != error_mark_node 1374169689Skan && TREE_CODE (mv3) != ARRAY_TYPE) 1375169689Skan mv3 = TYPE_MAIN_VARIANT (mv3); 1376169689Skan if (comptypes_internal (mv3, mv2)) 1377169689Skan break; 1378169689Skan } 137918334Speter if (memb == 0) 138018334Speter return 0; 138118334Speter } 1382169689Skan else if (TREE_CODE (a2) == UNION_TYPE 1383169689Skan && (TYPE_NAME (a2) == 0 1384169689Skan || TYPE_TRANSPARENT_UNION (a2)) 1385169689Skan && TREE_CODE (TYPE_SIZE (a2)) == INTEGER_CST 1386169689Skan && tree_int_cst_equal (TYPE_SIZE (a2), 1387169689Skan TYPE_SIZE (a1))) 138818334Speter { 138918334Speter tree memb; 1390169689Skan for (memb = TYPE_FIELDS (a2); 139118334Speter memb; memb = TREE_CHAIN (memb)) 1392169689Skan { 1393169689Skan tree mv3 = TREE_TYPE (memb); 1394169689Skan if (mv3 && mv3 != error_mark_node 1395169689Skan && TREE_CODE (mv3) != ARRAY_TYPE) 1396169689Skan mv3 = TYPE_MAIN_VARIANT (mv3); 1397169689Skan if (comptypes_internal (mv3, mv1)) 1398169689Skan break; 1399169689Skan } 140018334Speter if (memb == 0) 140118334Speter return 0; 140218334Speter } 140318334Speter else 140418334Speter return 0; 140518334Speter } 140618334Speter 140718334Speter /* comptypes said ok, but record if it said to warn. */ 140818334Speter if (newval > val) 140918334Speter val = newval; 141018334Speter 141118334Speter args1 = TREE_CHAIN (args1); 141218334Speter args2 = TREE_CHAIN (args2); 141318334Speter } 141418334Speter} 141518334Speter 141618334Speter/* Compute the size to increment a pointer by. */ 141718334Speter 1418169689Skanstatic tree 1419132718Skanc_size_in_bytes (tree type) 142018334Speter{ 142118334Speter enum tree_code code = TREE_CODE (type); 142218334Speter 142390075Sobrien if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK) 142490075Sobrien return size_one_node; 142590075Sobrien 142690075Sobrien if (!COMPLETE_OR_VOID_TYPE_P (type)) 142718334Speter { 142818334Speter error ("arithmetic on pointer to an incomplete type"); 142990075Sobrien return size_one_node; 143018334Speter } 143118334Speter 143218334Speter /* Convert in case a char is more than one unit. */ 143390075Sobrien return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type), 143490075Sobrien size_int (TYPE_PRECISION (char_type_node) 143590075Sobrien / BITS_PER_UNIT)); 143618334Speter} 143718334Speter 143890075Sobrien/* Return either DECL or its known constant value (if it has one). */ 143918334Speter 144018334Spetertree 1441132718Skandecl_constant_value (tree decl) 144218334Speter{ 144350397Sobrien if (/* Don't change a variable array bound or initial value to a constant 1444169689Skan in a place where a variable is invalid. Note that DECL_INITIAL 1445169689Skan isn't valid for a PARM_DECL. */ 144650397Sobrien current_function_decl != 0 1447169689Skan && TREE_CODE (decl) != PARM_DECL 1448169689Skan && !TREE_THIS_VOLATILE (decl) 144990075Sobrien && TREE_READONLY (decl) 145018334Speter && DECL_INITIAL (decl) != 0 145118334Speter && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK 145218334Speter /* This is invalid if initial value is not constant. 145318334Speter If it has either a function call, a memory reference, 145418334Speter or a variable, then re-evaluating it could give different results. */ 145518334Speter && TREE_CONSTANT (DECL_INITIAL (decl)) 145618334Speter /* Check for cases where this is sub-optimal, even though valid. */ 145790075Sobrien && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR) 145818334Speter return DECL_INITIAL (decl); 145918334Speter return decl; 146018334Speter} 146118334Speter 146290075Sobrien/* Return either DECL or its known constant value (if it has one), but 146390075Sobrien return DECL if pedantic or DECL has mode BLKmode. This is for 146490075Sobrien bug-compatibility with the old behavior of decl_constant_value 146590075Sobrien (before GCC 3.0); every use of this function is a bug and it should 146690075Sobrien be removed before GCC 3.1. It is not appropriate to use pedantic 146790075Sobrien in a way that affects optimization, and BLKmode is probably not the 146890075Sobrien right test for avoiding misoptimizations either. */ 146918334Speter 147090075Sobrienstatic tree 1471132718Skandecl_constant_value_for_broken_optimization (tree decl) 147218334Speter{ 1473169689Skan tree ret; 1474169689Skan 147590075Sobrien if (pedantic || DECL_MODE (decl) == BLKmode) 147690075Sobrien return decl; 1477169689Skan 1478169689Skan ret = decl_constant_value (decl); 1479169689Skan /* Avoid unwanted tree sharing between the initializer and current 1480169689Skan function's body where the tree can be modified e.g. by the 1481169689Skan gimplifier. */ 1482169689Skan if (ret != decl && TREE_STATIC (decl)) 1483169689Skan ret = unshare_expr (ret); 1484169689Skan return ret; 148590075Sobrien} 148618334Speter 1487169689Skan/* Convert the array expression EXP to a pointer. */ 148890075Sobrienstatic tree 1489169689Skanarray_to_pointer_conversion (tree exp) 149090075Sobrien{ 1491169689Skan tree orig_exp = exp; 149290075Sobrien tree type = TREE_TYPE (exp); 1493169689Skan tree adr; 1494169689Skan tree restype = TREE_TYPE (type); 1495169689Skan tree ptrtype; 149690075Sobrien 1497169689Skan gcc_assert (TREE_CODE (type) == ARRAY_TYPE); 149890075Sobrien 1499169689Skan STRIP_TYPE_NOPS (exp); 150018334Speter 1501169689Skan if (TREE_NO_WARNING (orig_exp)) 1502169689Skan TREE_NO_WARNING (exp) = 1; 150350397Sobrien 1504169689Skan ptrtype = build_pointer_type (restype); 1505169689Skan 1506169689Skan if (TREE_CODE (exp) == INDIRECT_REF) 1507169689Skan return convert (ptrtype, TREE_OPERAND (exp, 0)); 1508169689Skan 1509169689Skan if (TREE_CODE (exp) == VAR_DECL) 151018334Speter { 1511169689Skan /* We are making an ADDR_EXPR of ptrtype. This is a valid 1512169689Skan ADDR_EXPR because it's the best way of representing what 1513169689Skan happens in C when we take the address of an array and place 1514169689Skan it in a pointer to the element type. */ 1515169689Skan adr = build1 (ADDR_EXPR, ptrtype, exp); 1516169689Skan if (!c_mark_addressable (exp)) 1517169689Skan return error_mark_node; 1518169689Skan TREE_SIDE_EFFECTS (adr) = 0; /* Default would be, same as EXP. */ 1519169689Skan return adr; 152018334Speter } 152118334Speter 1522169689Skan /* This way is better for a COMPONENT_REF since it can 1523169689Skan simplify the offset for a component. */ 1524169689Skan adr = build_unary_op (ADDR_EXPR, exp, 1); 1525169689Skan return convert (ptrtype, adr); 1526169689Skan} 152718334Speter 1528169689Skan/* Convert the function expression EXP to a pointer. */ 1529169689Skanstatic tree 1530169689Skanfunction_to_pointer_conversion (tree exp) 1531169689Skan{ 1532169689Skan tree orig_exp = exp; 153318334Speter 1534169689Skan gcc_assert (TREE_CODE (TREE_TYPE (exp)) == FUNCTION_TYPE); 153518334Speter 1536169689Skan STRIP_TYPE_NOPS (exp); 153718334Speter 1538169689Skan if (TREE_NO_WARNING (orig_exp)) 1539169689Skan TREE_NO_WARNING (exp) = 1; 154018334Speter 1541169689Skan return build_unary_op (ADDR_EXPR, exp, 0); 154218334Speter} 154390075Sobrien 1544169689Skan/* Perform the default conversion of arrays and functions to pointers. 1545169689Skan Return the result of converting EXP. For any other expression, just 1546169689Skan return EXP after removing NOPs. */ 154790075Sobrien 1548169689Skanstruct c_expr 1549169689Skandefault_function_array_conversion (struct c_expr exp) 155090075Sobrien{ 1551169689Skan tree orig_exp = exp.value; 1552169689Skan tree type = TREE_TYPE (exp.value); 155390075Sobrien enum tree_code code = TREE_CODE (type); 155490075Sobrien 1555169689Skan switch (code) 1556169689Skan { 1557169689Skan case ARRAY_TYPE: 1558169689Skan { 1559169689Skan bool not_lvalue = false; 1560169689Skan bool lvalue_array_p; 156190075Sobrien 1562169689Skan while ((TREE_CODE (exp.value) == NON_LVALUE_EXPR 1563169689Skan || TREE_CODE (exp.value) == NOP_EXPR 1564169689Skan || TREE_CODE (exp.value) == CONVERT_EXPR) 1565169689Skan && TREE_TYPE (TREE_OPERAND (exp.value, 0)) == type) 1566169689Skan { 1567169689Skan if (TREE_CODE (exp.value) == NON_LVALUE_EXPR) 1568169689Skan not_lvalue = true; 1569169689Skan exp.value = TREE_OPERAND (exp.value, 0); 1570169689Skan } 157190075Sobrien 1572169689Skan if (TREE_NO_WARNING (orig_exp)) 1573169689Skan TREE_NO_WARNING (exp.value) = 1; 1574169689Skan 1575169689Skan lvalue_array_p = !not_lvalue && lvalue_p (exp.value); 1576169689Skan if (!flag_isoc99 && !lvalue_array_p) 1577169689Skan { 1578169689Skan /* Before C99, non-lvalue arrays do not decay to pointers. 1579169689Skan Normally, using such an array would be invalid; but it can 1580169689Skan be used correctly inside sizeof or as a statement expression. 1581169689Skan Thus, do not give an error here; an error will result later. */ 1582169689Skan return exp; 1583169689Skan } 1584169689Skan 1585169689Skan exp.value = array_to_pointer_conversion (exp.value); 1586169689Skan } 1587169689Skan break; 1588169689Skan case FUNCTION_TYPE: 1589169689Skan exp.value = function_to_pointer_conversion (exp.value); 1590169689Skan break; 1591169689Skan default: 1592169689Skan STRIP_TYPE_NOPS (exp.value); 1593169689Skan if (TREE_NO_WARNING (orig_exp)) 1594169689Skan TREE_NO_WARNING (exp.value) = 1; 1595169689Skan break; 159690075Sobrien } 159790075Sobrien 1598169689Skan return exp; 1599169689Skan} 160090075Sobrien 160190075Sobrien 1602169689Skan/* EXP is an expression of integer type. Apply the integer promotions 1603169689Skan to it and return the promoted value. */ 160490075Sobrien 1605169689Skantree 1606169689Skanperform_integral_promotions (tree exp) 1607169689Skan{ 1608169689Skan tree type = TREE_TYPE (exp); 1609169689Skan enum tree_code code = TREE_CODE (type); 1610169689Skan 1611169689Skan gcc_assert (INTEGRAL_TYPE_P (type)); 1612169689Skan 161390075Sobrien /* Normally convert enums to int, 161490075Sobrien but convert wide enums to something wider. */ 161590075Sobrien if (code == ENUMERAL_TYPE) 161690075Sobrien { 1617117395Skan type = c_common_type_for_size (MAX (TYPE_PRECISION (type), 1618117395Skan TYPE_PRECISION (integer_type_node)), 1619117395Skan ((TYPE_PRECISION (type) 1620117395Skan >= TYPE_PRECISION (integer_type_node)) 1621169689Skan && TYPE_UNSIGNED (type))); 162290075Sobrien 162390075Sobrien return convert (type, exp); 162490075Sobrien } 162590075Sobrien 1626169689Skan /* ??? This should no longer be needed now bit-fields have their 1627169689Skan proper types. */ 162890075Sobrien if (TREE_CODE (exp) == COMPONENT_REF 162990075Sobrien && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1)) 163090075Sobrien /* If it's thinner than an int, promote it like a 163190075Sobrien c_promoting_integer_type_p, otherwise leave it alone. */ 163290075Sobrien && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)), 163390075Sobrien TYPE_PRECISION (integer_type_node))) 1634117395Skan return convert (integer_type_node, exp); 163590075Sobrien 163690075Sobrien if (c_promoting_integer_type_p (type)) 163790075Sobrien { 1638117395Skan /* Preserve unsignedness if not really getting any wider. */ 1639169689Skan if (TYPE_UNSIGNED (type) 1640117395Skan && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)) 164190075Sobrien return convert (unsigned_type_node, exp); 164290075Sobrien 164390075Sobrien return convert (integer_type_node, exp); 164490075Sobrien } 164590075Sobrien 1646169689Skan return exp; 1647169689Skan} 1648169689Skan 1649169689Skan 1650169689Skan/* Perform default promotions for C data used in expressions. 1651169689Skan Enumeral types or short or char are converted to int. 1652169689Skan In addition, manifest constants symbols are replaced by their values. */ 1653169689Skan 1654169689Skantree 1655169689Skandefault_conversion (tree exp) 1656169689Skan{ 1657169689Skan tree orig_exp; 1658169689Skan tree type = TREE_TYPE (exp); 1659169689Skan enum tree_code code = TREE_CODE (type); 1660169689Skan 1661169689Skan /* Functions and arrays have been converted during parsing. */ 1662169689Skan gcc_assert (code != FUNCTION_TYPE); 1663169689Skan if (code == ARRAY_TYPE) 1664169689Skan return exp; 1665169689Skan 1666169689Skan /* Constants can be used directly unless they're not loadable. */ 1667169689Skan if (TREE_CODE (exp) == CONST_DECL) 1668169689Skan exp = DECL_INITIAL (exp); 1669169689Skan 1670169689Skan /* Replace a nonvolatile const static variable with its value unless 1671169689Skan it is an array, in which case we must be sure that taking the 1672169689Skan address of the array produces consistent results. */ 1673169689Skan else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE) 1674169689Skan { 1675169689Skan exp = decl_constant_value_for_broken_optimization (exp); 1676169689Skan type = TREE_TYPE (exp); 1677169689Skan } 1678169689Skan 1679169689Skan /* Strip no-op conversions. */ 1680169689Skan orig_exp = exp; 1681169689Skan STRIP_TYPE_NOPS (exp); 1682169689Skan 1683169689Skan if (TREE_NO_WARNING (orig_exp)) 1684169689Skan TREE_NO_WARNING (exp) = 1; 1685169689Skan 1686169689Skan if (INTEGRAL_TYPE_P (type)) 1687169689Skan return perform_integral_promotions (exp); 1688169689Skan 168990075Sobrien if (code == VOID_TYPE) 169090075Sobrien { 169190075Sobrien error ("void value not ignored as it ought to be"); 169290075Sobrien return error_mark_node; 169390075Sobrien } 169490075Sobrien return exp; 169590075Sobrien} 169618334Speter 169790075Sobrien/* Look up COMPONENT in a structure or union DECL. 169818334Speter 169990075Sobrien If the component name is not found, returns NULL_TREE. Otherwise, 170090075Sobrien the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL 170190075Sobrien stepping down the chain to the component, which is in the last 170290075Sobrien TREE_VALUE of the list. Normally the list is of length one, but if 170390075Sobrien the component is embedded within (nested) anonymous structures or 170490075Sobrien unions, the list steps down the chain to the component. */ 1705132718Skan 170618334Speterstatic tree 1707132718Skanlookup_field (tree decl, tree component) 170818334Speter{ 170990075Sobrien tree type = TREE_TYPE (decl); 171018334Speter tree field; 171118334Speter 171218334Speter /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers 171318334Speter to the field elements. Use a binary search on this array to quickly 171418334Speter find the element. Otherwise, do a linear search. TYPE_LANG_SPECIFIC 171518334Speter will always be set for structures which have many elements. */ 171618334Speter 1717169689Skan if (TYPE_LANG_SPECIFIC (type) && TYPE_LANG_SPECIFIC (type)->s) 171818334Speter { 171918334Speter int bot, top, half; 1720132718Skan tree *field_array = &TYPE_LANG_SPECIFIC (type)->s->elts[0]; 172118334Speter 172218334Speter field = TYPE_FIELDS (type); 172318334Speter bot = 0; 1724132718Skan top = TYPE_LANG_SPECIFIC (type)->s->len; 172518334Speter while (top - bot > 1) 172618334Speter { 172718334Speter half = (top - bot + 1) >> 1; 172818334Speter field = field_array[bot+half]; 172918334Speter 173018334Speter if (DECL_NAME (field) == NULL_TREE) 173118334Speter { 173218334Speter /* Step through all anon unions in linear fashion. */ 173318334Speter while (DECL_NAME (field_array[bot]) == NULL_TREE) 173418334Speter { 173518334Speter field = field_array[bot++]; 173650397Sobrien if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE 173750397Sobrien || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE) 173890075Sobrien { 173990075Sobrien tree anon = lookup_field (field, component); 174050397Sobrien 174190075Sobrien if (anon) 174290075Sobrien return tree_cons (NULL_TREE, field, anon); 1743132718Skan } 174418334Speter } 174518334Speter 174618334Speter /* Entire record is only anon unions. */ 174718334Speter if (bot > top) 174818334Speter return NULL_TREE; 174918334Speter 175018334Speter /* Restart the binary search, with new lower bound. */ 175118334Speter continue; 175218334Speter } 175318334Speter 175418334Speter if (DECL_NAME (field) == component) 175518334Speter break; 175618334Speter if (DECL_NAME (field) < component) 175718334Speter bot += half; 175818334Speter else 175918334Speter top = bot + half; 176018334Speter } 176118334Speter 176218334Speter if (DECL_NAME (field_array[bot]) == component) 176318334Speter field = field_array[bot]; 176418334Speter else if (DECL_NAME (field) != component) 176590075Sobrien return NULL_TREE; 176618334Speter } 176718334Speter else 176818334Speter { 176918334Speter for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 177018334Speter { 177190075Sobrien if (DECL_NAME (field) == NULL_TREE 177290075Sobrien && (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE 177390075Sobrien || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)) 177418334Speter { 177590075Sobrien tree anon = lookup_field (field, component); 177650397Sobrien 177790075Sobrien if (anon) 177890075Sobrien return tree_cons (NULL_TREE, field, anon); 177918334Speter } 178018334Speter 178118334Speter if (DECL_NAME (field) == component) 178218334Speter break; 178318334Speter } 178490075Sobrien 178590075Sobrien if (field == NULL_TREE) 178690075Sobrien return NULL_TREE; 178718334Speter } 178818334Speter 178990075Sobrien return tree_cons (NULL_TREE, field, NULL_TREE); 179018334Speter} 179118334Speter 179218334Speter/* Make an expression to refer to the COMPONENT field of 179318334Speter structure or union value DATUM. COMPONENT is an IDENTIFIER_NODE. */ 179418334Speter 179518334Spetertree 1796132718Skanbuild_component_ref (tree datum, tree component) 179718334Speter{ 179890075Sobrien tree type = TREE_TYPE (datum); 179990075Sobrien enum tree_code code = TREE_CODE (type); 180090075Sobrien tree field = NULL; 180190075Sobrien tree ref; 180218334Speter 1803169689Skan if (!objc_is_public (datum, component)) 1804169689Skan return error_mark_node; 1805169689Skan 180618334Speter /* See if there is a field or component with name COMPONENT. */ 180718334Speter 180818334Speter if (code == RECORD_TYPE || code == UNION_TYPE) 180918334Speter { 181090075Sobrien if (!COMPLETE_TYPE_P (type)) 181118334Speter { 1812117395Skan c_incomplete_type_error (NULL_TREE, type); 181318334Speter return error_mark_node; 181418334Speter } 181518334Speter 181690075Sobrien field = lookup_field (datum, component); 181718334Speter 181818334Speter if (!field) 181918334Speter { 1820169689Skan error ("%qT has no member named %qE", type, component); 182118334Speter return error_mark_node; 182218334Speter } 182318334Speter 182490075Sobrien /* Chain the COMPONENT_REFs if necessary down to the FIELD. 182590075Sobrien This might be better solved in future the way the C++ front 182690075Sobrien end does it - by giving the anonymous entities each a 182790075Sobrien separate name and type, and then have build_component_ref 182890075Sobrien recursively call itself. We can't do that here. */ 1829117395Skan do 183018334Speter { 183190075Sobrien tree subdatum = TREE_VALUE (field); 1832169689Skan int quals; 1833169689Skan tree subtype; 183490075Sobrien 183590075Sobrien if (TREE_TYPE (subdatum) == error_mark_node) 183690075Sobrien return error_mark_node; 183790075Sobrien 1838169689Skan quals = TYPE_QUALS (strip_array_types (TREE_TYPE (subdatum))); 1839169689Skan quals |= TYPE_QUALS (TREE_TYPE (datum)); 1840169689Skan subtype = c_build_qualified_type (TREE_TYPE (subdatum), quals); 1841169689Skan 1842169689Skan ref = build3 (COMPONENT_REF, subtype, datum, subdatum, 1843169689Skan NULL_TREE); 184490075Sobrien if (TREE_READONLY (datum) || TREE_READONLY (subdatum)) 184518334Speter TREE_READONLY (ref) = 1; 184690075Sobrien if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (subdatum)) 184718334Speter TREE_THIS_VOLATILE (ref) = 1; 184890075Sobrien 184990075Sobrien if (TREE_DEPRECATED (subdatum)) 185090075Sobrien warn_deprecated_use (subdatum); 185190075Sobrien 185218334Speter datum = ref; 1853117395Skan 1854117395Skan field = TREE_CHAIN (field); 185518334Speter } 1856117395Skan while (field); 185718334Speter 185818334Speter return ref; 185918334Speter } 186018334Speter else if (code != ERROR_MARK) 1861169689Skan error ("request for member %qE in something not a structure or union", 1862169689Skan component); 186318334Speter 186418334Speter return error_mark_node; 186518334Speter} 186618334Speter 186718334Speter/* Given an expression PTR for a pointer, return an expression 186818334Speter for the value pointed to. 186918334Speter ERRORSTRING is the name of the operator to appear in error messages. */ 187018334Speter 187118334Spetertree 1872132718Skanbuild_indirect_ref (tree ptr, const char *errorstring) 187318334Speter{ 187490075Sobrien tree pointer = default_conversion (ptr); 187590075Sobrien tree type = TREE_TYPE (pointer); 187618334Speter 187718334Speter if (TREE_CODE (type) == POINTER_TYPE) 187818334Speter { 187918334Speter if (TREE_CODE (pointer) == ADDR_EXPR 188018334Speter && (TREE_TYPE (TREE_OPERAND (pointer, 0)) 188118334Speter == TREE_TYPE (type))) 188218334Speter return TREE_OPERAND (pointer, 0); 188318334Speter else 188418334Speter { 188518334Speter tree t = TREE_TYPE (type); 1886169689Skan tree ref; 188718334Speter 1888169689Skan ref = build1 (INDIRECT_REF, t, pointer); 1889169689Skan 189090075Sobrien if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE) 189118334Speter { 189218334Speter error ("dereferencing pointer to incomplete type"); 189318334Speter return error_mark_node; 189418334Speter } 189590075Sobrien if (VOID_TYPE_P (t) && skip_evaluation == 0) 1896169689Skan warning (0, "dereferencing %<void *%> pointer"); 189718334Speter 189818334Speter /* We *must* set TREE_READONLY when dereferencing a pointer to const, 189918334Speter so that we get the proper error message if the result is used 190018334Speter to assign to. Also, &* is supposed to be a no-op. 190118334Speter And ANSI C seems to specify that the type of the result 190218334Speter should be the const type. */ 190318334Speter /* A de-reference of a pointer to const is not a const. It is valid 190418334Speter to change it via some other pointer. */ 190518334Speter TREE_READONLY (ref) = TYPE_READONLY (t); 190618334Speter TREE_SIDE_EFFECTS (ref) 1907132718Skan = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer); 190818334Speter TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t); 190918334Speter return ref; 191018334Speter } 191118334Speter } 191218334Speter else if (TREE_CODE (pointer) != ERROR_MARK) 1913169689Skan error ("invalid type argument of %qs", errorstring); 191418334Speter return error_mark_node; 191518334Speter} 191618334Speter 191718334Speter/* This handles expressions of the form "a[i]", which denotes 191818334Speter an array reference. 191918334Speter 192018334Speter This is logically equivalent in C to *(a+i), but we may do it differently. 192118334Speter If A is a variable or a member, we generate a primitive ARRAY_REF. 192218334Speter This avoids forcing the array out of registers, and can work on 192318334Speter arrays that are not lvalues (for example, members of structures returned 192418334Speter by functions). */ 192518334Speter 192618334Spetertree 1927132718Skanbuild_array_ref (tree array, tree index) 192818334Speter{ 1929169689Skan bool swapped = false; 193018334Speter if (TREE_TYPE (array) == error_mark_node 193118334Speter || TREE_TYPE (index) == error_mark_node) 193218334Speter return error_mark_node; 193318334Speter 1934169689Skan if (TREE_CODE (TREE_TYPE (array)) != ARRAY_TYPE 1935169689Skan && TREE_CODE (TREE_TYPE (array)) != POINTER_TYPE) 193618334Speter { 1937169689Skan tree temp; 1938169689Skan if (TREE_CODE (TREE_TYPE (index)) != ARRAY_TYPE 1939169689Skan && TREE_CODE (TREE_TYPE (index)) != POINTER_TYPE) 194018334Speter { 1941169689Skan error ("subscripted value is neither array nor pointer"); 194218334Speter return error_mark_node; 194318334Speter } 1944169689Skan temp = array; 1945169689Skan array = index; 1946169689Skan index = temp; 1947169689Skan swapped = true; 1948169689Skan } 194918334Speter 1950169689Skan if (!INTEGRAL_TYPE_P (TREE_TYPE (index))) 1951169689Skan { 1952169689Skan error ("array subscript is not an integer"); 1953169689Skan return error_mark_node; 1954169689Skan } 1955169689Skan 1956169689Skan if (TREE_CODE (TREE_TYPE (TREE_TYPE (array))) == FUNCTION_TYPE) 1957169689Skan { 1958169689Skan error ("subscripted value is pointer to function"); 1959169689Skan return error_mark_node; 1960169689Skan } 1961169689Skan 1962169689Skan /* ??? Existing practice has been to warn only when the char 1963169689Skan index is syntactically the index, not for char[array]. */ 1964169689Skan if (!swapped) 1965169689Skan warn_array_subscript_with_type_char (index); 1966169689Skan 1967169689Skan /* Apply default promotions *after* noticing character types. */ 1968169689Skan index = default_conversion (index); 1969169689Skan 1970169689Skan gcc_assert (TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE); 1971169689Skan 1972169689Skan if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE) 1973169689Skan { 1974169689Skan tree rval, type; 1975169689Skan 197618334Speter /* An array that is indexed by a non-constant 197718334Speter cannot be stored in a register; we must be able to do 197818334Speter address arithmetic on its address. 197918334Speter Likewise an array of elements of variable size. */ 198018334Speter if (TREE_CODE (index) != INTEGER_CST 198190075Sobrien || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array))) 198218334Speter && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST)) 198318334Speter { 1984117395Skan if (!c_mark_addressable (array)) 198518334Speter return error_mark_node; 198618334Speter } 198718334Speter /* An array that is indexed by a constant value which is not within 198818334Speter the array bounds cannot be stored in a register either; because we 198918334Speter would get a crash in store_bit_field/extract_bit_field when trying 199018334Speter to access a non-existent part of the register. */ 199118334Speter if (TREE_CODE (index) == INTEGER_CST 1992169689Skan && TYPE_DOMAIN (TREE_TYPE (array)) 1993169689Skan && !int_fits_type_p (index, TYPE_DOMAIN (TREE_TYPE (array)))) 199418334Speter { 1995117395Skan if (!c_mark_addressable (array)) 199618334Speter return error_mark_node; 199718334Speter } 199818334Speter 199918334Speter if (pedantic) 200018334Speter { 200118334Speter tree foo = array; 200218334Speter while (TREE_CODE (foo) == COMPONENT_REF) 200318334Speter foo = TREE_OPERAND (foo, 0); 2004169689Skan if (TREE_CODE (foo) == VAR_DECL && C_DECL_REGISTER (foo)) 2005169689Skan pedwarn ("ISO C forbids subscripting %<register%> array"); 2006169689Skan else if (!flag_isoc99 && !lvalue_p (foo)) 2007117395Skan pedwarn ("ISO C90 forbids subscripting non-lvalue array"); 200818334Speter } 200918334Speter 2010169689Skan type = TREE_TYPE (TREE_TYPE (array)); 2011169689Skan if (TREE_CODE (type) != ARRAY_TYPE) 2012169689Skan type = TYPE_MAIN_VARIANT (type); 2013169689Skan rval = build4 (ARRAY_REF, type, array, index, NULL_TREE, NULL_TREE); 201418334Speter /* Array ref is const/volatile if the array elements are 2015169689Skan or if the array is. */ 201618334Speter TREE_READONLY (rval) 201718334Speter |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array))) 201818334Speter | TREE_READONLY (array)); 201918334Speter TREE_SIDE_EFFECTS (rval) 202018334Speter |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array))) 202118334Speter | TREE_SIDE_EFFECTS (array)); 202218334Speter TREE_THIS_VOLATILE (rval) 202318334Speter |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array))) 202418334Speter /* This was added by rms on 16 Nov 91. 2025132718Skan It fixes vol struct foo *a; a->elts[1] 202618334Speter in an inline function. 202718334Speter Hope it doesn't break something else. */ 202818334Speter | TREE_THIS_VOLATILE (array)); 202918334Speter return require_complete_type (fold (rval)); 203018334Speter } 2031169689Skan else 2032169689Skan { 2033169689Skan tree ar = default_conversion (array); 203418334Speter 2035169689Skan if (ar == error_mark_node) 2036169689Skan return ar; 203718334Speter 2038169689Skan gcc_assert (TREE_CODE (TREE_TYPE (ar)) == POINTER_TYPE); 2039169689Skan gcc_assert (TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) != FUNCTION_TYPE); 204050397Sobrien 2041169689Skan return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, index, 0), 2042169689Skan "array indexing"); 2043169689Skan } 204418334Speter} 204518334Speter 204690075Sobrien/* Build an external reference to identifier ID. FUN indicates 2047169689Skan whether this will be used for a function call. LOC is the source 2048169689Skan location of the identifier. */ 204990075Sobrientree 2050169689Skanbuild_external_ref (tree id, int fun, location_t loc) 205190075Sobrien{ 205290075Sobrien tree ref; 205390075Sobrien tree decl = lookup_name (id); 205490075Sobrien 2055169689Skan /* In Objective-C, an instance variable (ivar) may be preferred to 2056169689Skan whatever lookup_name() found. */ 2057169689Skan decl = objc_lookup_ivar (decl, id); 2058169689Skan 2059132718Skan if (decl && decl != error_mark_node) 2060169689Skan ref = decl; 2061132718Skan else if (fun) 2062132718Skan /* Implicit function declaration. */ 2063132718Skan ref = implicitly_declare (id); 2064132718Skan else if (decl == error_mark_node) 2065132718Skan /* Don't complain about something that's already been 2066132718Skan complained about. */ 2067132718Skan return error_mark_node; 2068132718Skan else 2069132718Skan { 2070169689Skan undeclared_variable (id, loc); 2071132718Skan return error_mark_node; 2072132718Skan } 207390075Sobrien 207490075Sobrien if (TREE_TYPE (ref) == error_mark_node) 207590075Sobrien return error_mark_node; 207690075Sobrien 2077132718Skan if (TREE_DEPRECATED (ref)) 2078132718Skan warn_deprecated_use (ref); 2079132718Skan 2080103445Skan if (!skip_evaluation) 2081103445Skan assemble_external (ref); 208290075Sobrien TREE_USED (ref) = 1; 208390075Sobrien 2084169689Skan if (TREE_CODE (ref) == FUNCTION_DECL && !in_alignof) 2085169689Skan { 2086169689Skan if (!in_sizeof && !in_typeof) 2087169689Skan C_DECL_USED (ref) = 1; 2088169689Skan else if (DECL_INITIAL (ref) == 0 2089169689Skan && DECL_EXTERNAL (ref) 2090169689Skan && !TREE_PUBLIC (ref)) 2091169689Skan record_maybe_used_decl (ref); 2092169689Skan } 2093169689Skan 209490075Sobrien if (TREE_CODE (ref) == CONST_DECL) 209590075Sobrien { 2096169689Skan used_types_insert (TREE_TYPE (ref)); 209790075Sobrien ref = DECL_INITIAL (ref); 209890075Sobrien TREE_CONSTANT (ref) = 1; 2099169689Skan TREE_INVARIANT (ref) = 1; 210090075Sobrien } 2101117395Skan else if (current_function_decl != 0 2102132718Skan && !DECL_FILE_SCOPE_P (current_function_decl) 2103117395Skan && (TREE_CODE (ref) == VAR_DECL 2104117395Skan || TREE_CODE (ref) == PARM_DECL 2105117395Skan || TREE_CODE (ref) == FUNCTION_DECL)) 2106117395Skan { 2107117395Skan tree context = decl_function_context (ref); 2108132718Skan 2109117395Skan if (context != 0 && context != current_function_decl) 2110117395Skan DECL_NONLOCAL (ref) = 1; 2111117395Skan } 2112189824Sdas /* C99 6.7.4p3: An inline definition of a function with external 2113189824Sdas linkage ... shall not contain a reference to an identifier with 2114189824Sdas internal linkage. */ 2115189824Sdas else if (current_function_decl != 0 2116189824Sdas && DECL_DECLARED_INLINE_P (current_function_decl) 2117189824Sdas && DECL_EXTERNAL (current_function_decl) 2118189824Sdas && VAR_OR_FUNCTION_DECL_P (ref) 2119189824Sdas && DECL_FILE_SCOPE_P (ref) 2120189824Sdas && pedantic 2121189824Sdas && (TREE_CODE (ref) != VAR_DECL || TREE_STATIC (ref)) 2122189824Sdas && ! TREE_PUBLIC (ref)) 2123189824Sdas pedwarn ("%H%qD is static but used in inline function %qD " 2124189824Sdas "which is not static", &loc, ref, current_function_decl); 212590075Sobrien 212690075Sobrien return ref; 212790075Sobrien} 212890075Sobrien 2129169689Skan/* Record details of decls possibly used inside sizeof or typeof. */ 2130169689Skanstruct maybe_used_decl 2131169689Skan{ 2132169689Skan /* The decl. */ 2133169689Skan tree decl; 2134169689Skan /* The level seen at (in_sizeof + in_typeof). */ 2135169689Skan int level; 2136169689Skan /* The next one at this level or above, or NULL. */ 2137169689Skan struct maybe_used_decl *next; 2138169689Skan}; 2139169689Skan 2140169689Skanstatic struct maybe_used_decl *maybe_used_decls; 2141169689Skan 2142169689Skan/* Record that DECL, an undefined static function reference seen 2143169689Skan inside sizeof or typeof, might be used if the operand of sizeof is 2144169689Skan a VLA type or the operand of typeof is a variably modified 2145169689Skan type. */ 2146169689Skan 2147169689Skanstatic void 2148169689Skanrecord_maybe_used_decl (tree decl) 2149169689Skan{ 2150169689Skan struct maybe_used_decl *t = XOBNEW (&parser_obstack, struct maybe_used_decl); 2151169689Skan t->decl = decl; 2152169689Skan t->level = in_sizeof + in_typeof; 2153169689Skan t->next = maybe_used_decls; 2154169689Skan maybe_used_decls = t; 2155169689Skan} 2156169689Skan 2157169689Skan/* Pop the stack of decls possibly used inside sizeof or typeof. If 2158169689Skan USED is false, just discard them. If it is true, mark them used 2159169689Skan (if no longer inside sizeof or typeof) or move them to the next 2160169689Skan level up (if still inside sizeof or typeof). */ 2161169689Skan 2162169689Skanvoid 2163169689Skanpop_maybe_used (bool used) 2164169689Skan{ 2165169689Skan struct maybe_used_decl *p = maybe_used_decls; 2166169689Skan int cur_level = in_sizeof + in_typeof; 2167169689Skan while (p && p->level > cur_level) 2168169689Skan { 2169169689Skan if (used) 2170169689Skan { 2171169689Skan if (cur_level == 0) 2172169689Skan C_DECL_USED (p->decl) = 1; 2173169689Skan else 2174169689Skan p->level = cur_level; 2175169689Skan } 2176169689Skan p = p->next; 2177169689Skan } 2178169689Skan if (!used || cur_level == 0) 2179169689Skan maybe_used_decls = p; 2180169689Skan} 2181169689Skan 2182169689Skan/* Return the result of sizeof applied to EXPR. */ 2183169689Skan 2184169689Skanstruct c_expr 2185169689Skanc_expr_sizeof_expr (struct c_expr expr) 2186169689Skan{ 2187169689Skan struct c_expr ret; 2188169689Skan if (expr.value == error_mark_node) 2189169689Skan { 2190169689Skan ret.value = error_mark_node; 2191169689Skan ret.original_code = ERROR_MARK; 2192169689Skan pop_maybe_used (false); 2193169689Skan } 2194169689Skan else 2195169689Skan { 2196169689Skan ret.value = c_sizeof (TREE_TYPE (expr.value)); 2197169689Skan ret.original_code = ERROR_MARK; 2198169689Skan if (c_vla_type_p (TREE_TYPE (expr.value))) 2199169689Skan { 2200169689Skan /* sizeof is evaluated when given a vla (C99 6.5.3.4p2). */ 2201169689Skan ret.value = build2 (COMPOUND_EXPR, TREE_TYPE (ret.value), expr.value, ret.value); 2202169689Skan } 2203169689Skan pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (expr.value))); 2204169689Skan } 2205169689Skan return ret; 2206169689Skan} 2207169689Skan 2208169689Skan/* Return the result of sizeof applied to T, a structure for the type 2209169689Skan name passed to sizeof (rather than the type itself). */ 2210169689Skan 2211169689Skanstruct c_expr 2212169689Skanc_expr_sizeof_type (struct c_type_name *t) 2213169689Skan{ 2214169689Skan tree type; 2215169689Skan struct c_expr ret; 2216169689Skan type = groktypename (t); 2217169689Skan ret.value = c_sizeof (type); 2218169689Skan ret.original_code = ERROR_MARK; 2219169689Skan pop_maybe_used (type != error_mark_node 2220169689Skan ? C_TYPE_VARIABLE_SIZE (type) : false); 2221169689Skan return ret; 2222169689Skan} 2223169689Skan 222418334Speter/* Build a function call to function FUNCTION with parameters PARAMS. 222518334Speter PARAMS is a list--a chain of TREE_LIST nodes--in which the 222618334Speter TREE_VALUE of each node is a parameter-expression. 222718334Speter FUNCTION's data type may be a function type or a pointer-to-function. */ 222818334Speter 222918334Spetertree 2230132718Skanbuild_function_call (tree function, tree params) 223118334Speter{ 223290075Sobrien tree fntype, fundecl = 0; 223390075Sobrien tree coerced_params; 2234132718Skan tree name = NULL_TREE, result; 2235132718Skan tree tem; 223618334Speter 223718334Speter /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */ 223818334Speter STRIP_TYPE_NOPS (function); 223918334Speter 224018334Speter /* Convert anything with function type to a pointer-to-function. */ 224118334Speter if (TREE_CODE (function) == FUNCTION_DECL) 224218334Speter { 2243169689Skan /* Implement type-directed function overloading for builtins. 2244169689Skan resolve_overloaded_builtin and targetm.resolve_overloaded_builtin 2245169689Skan handle all the type checking. The result is a complete expression 2246169689Skan that implements this function call. */ 2247169689Skan tem = resolve_overloaded_builtin (function, params); 2248169689Skan if (tem) 2249169689Skan return tem; 2250169689Skan 225118334Speter name = DECL_NAME (function); 225218334Speter fundecl = function; 225318334Speter } 2254169689Skan if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE) 2255169689Skan function = function_to_pointer_conversion (function); 225618334Speter 2257169689Skan /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF 2258169689Skan expressions, like those used for ObjC messenger dispatches. */ 2259169689Skan function = objc_rewrite_function_call (function, params); 2260169689Skan 226118334Speter fntype = TREE_TYPE (function); 226218334Speter 226318334Speter if (TREE_CODE (fntype) == ERROR_MARK) 226418334Speter return error_mark_node; 226518334Speter 226618334Speter if (!(TREE_CODE (fntype) == POINTER_TYPE 226718334Speter && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE)) 226818334Speter { 2269169689Skan error ("called object %qE is not a function", function); 227018334Speter return error_mark_node; 227118334Speter } 227218334Speter 227396263Sobrien if (fundecl && TREE_THIS_VOLATILE (fundecl)) 227496263Sobrien current_function_returns_abnormally = 1; 227596263Sobrien 227618334Speter /* fntype now gets the type of function pointed to. */ 227718334Speter fntype = TREE_TYPE (fntype); 227818334Speter 2279132718Skan /* Check that the function is called through a compatible prototype. 2280132718Skan If it is not, replace the call by a trap, wrapped up in a compound 2281132718Skan expression if necessary. This has the nice side-effect to prevent 2282132718Skan the tree-inliner from generating invalid assignment trees which may 2283169689Skan blow up in the RTL expander later. */ 2284169689Skan if ((TREE_CODE (function) == NOP_EXPR 2285169689Skan || TREE_CODE (function) == CONVERT_EXPR) 2286132718Skan && TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR 2287132718Skan && TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL 2288169689Skan && !comptypes (fntype, TREE_TYPE (tem))) 2289132718Skan { 2290132718Skan tree return_type = TREE_TYPE (fntype); 2291132718Skan tree trap = build_function_call (built_in_decls[BUILT_IN_TRAP], 2292132718Skan NULL_TREE); 2293132718Skan 2294132718Skan /* This situation leads to run-time undefined behavior. We can't, 2295132718Skan therefore, simply error unless we can prove that all possible 2296132718Skan executions of the program must execute the code. */ 2297169689Skan warning (0, "function called through a non-compatible type"); 2298132718Skan 2299132718Skan /* We can, however, treat "undefined" any way we please. 2300132718Skan Call abort to encourage the user to fix the program. */ 2301132718Skan inform ("if this code is reached, the program will abort"); 2302132718Skan 2303132718Skan if (VOID_TYPE_P (return_type)) 2304132718Skan return trap; 2305132718Skan else 2306132718Skan { 2307132718Skan tree rhs; 2308132718Skan 2309132718Skan if (AGGREGATE_TYPE_P (return_type)) 2310132718Skan rhs = build_compound_literal (return_type, 2311169689Skan build_constructor (return_type, 0)); 2312132718Skan else 2313169689Skan rhs = fold_convert (return_type, integer_zero_node); 2314132718Skan 2315169689Skan return build2 (COMPOUND_EXPR, return_type, trap, rhs); 2316132718Skan } 2317132718Skan } 2318132718Skan 231918334Speter /* Convert the parameters to the types declared in the 232018334Speter function prototype, or apply default promotions. */ 232118334Speter 232218334Speter coerced_params 2323169689Skan = convert_arguments (TYPE_ARG_TYPES (fntype), params, function, fundecl); 232418334Speter 2325169689Skan if (coerced_params == error_mark_node) 2326169689Skan return error_mark_node; 2327169689Skan 2328117395Skan /* Check that the arguments to the function are valid. */ 232918334Speter 2330169689Skan check_function_arguments (TYPE_ATTRIBUTES (fntype), coerced_params, 2331169689Skan TYPE_ARG_TYPES (fntype)); 233218334Speter 2333132718Skan if (require_constant_value) 2334132718Skan { 2335169689Skan result = fold_build3_initializer (CALL_EXPR, TREE_TYPE (fntype), 2336169689Skan function, coerced_params, NULL_TREE); 2337132718Skan 2338132718Skan if (TREE_CONSTANT (result) 2339132718Skan && (name == NULL_TREE 2340132718Skan || strncmp (IDENTIFIER_POINTER (name), "__builtin_", 10) != 0)) 2341132718Skan pedwarn_init ("initializer element is not constant"); 2342132718Skan } 2343132718Skan else 2344169689Skan result = fold_build3 (CALL_EXPR, TREE_TYPE (fntype), 2345169689Skan function, coerced_params, NULL_TREE); 2346132718Skan 234790075Sobrien if (VOID_TYPE_P (TREE_TYPE (result))) 234890075Sobrien return result; 234990075Sobrien return require_complete_type (result); 235018334Speter} 235118334Speter 235218334Speter/* Convert the argument expressions in the list VALUES 235318334Speter to the types in the list TYPELIST. The result is a list of converted 2354169689Skan argument expressions, unless there are too few arguments in which 2355169689Skan case it is error_mark_node. 235618334Speter 235718334Speter If TYPELIST is exhausted, or when an element has NULL as its type, 235818334Speter perform the default conversions. 235918334Speter 236018334Speter PARMLIST is the chain of parm decls for the function being called. 236118334Speter It may be 0, if that info is not available. 236218334Speter It is used only for generating error messages. 236318334Speter 2364169689Skan FUNCTION is a tree for the called function. It is used only for 2365169689Skan error messages, where it is formatted with %qE. 236618334Speter 236718334Speter This is also where warnings about wrong number of args are generated. 236818334Speter 236918334Speter Both VALUES and the returned value are chains of TREE_LIST nodes 237018334Speter with the elements of the list in the TREE_VALUE slots of those nodes. */ 237118334Speter 237218334Speterstatic tree 2373169689Skanconvert_arguments (tree typelist, tree values, tree function, tree fundecl) 237418334Speter{ 237590075Sobrien tree typetail, valtail; 237690075Sobrien tree result = NULL; 237718334Speter int parmnum; 2378169689Skan tree selector; 237918334Speter 2380169689Skan /* Change pointer to function to the function itself for 2381169689Skan diagnostics. */ 2382169689Skan if (TREE_CODE (function) == ADDR_EXPR 2383169689Skan && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL) 2384169689Skan function = TREE_OPERAND (function, 0); 2385169689Skan 2386169689Skan /* Handle an ObjC selector specially for diagnostics. */ 2387169689Skan selector = objc_message_selector (); 2388169689Skan 238918334Speter /* Scan the given expressions and types, producing individual 239018334Speter converted arguments and pushing them on RESULT in reverse order. */ 239118334Speter 239218334Speter for (valtail = values, typetail = typelist, parmnum = 0; 239318334Speter valtail; 239418334Speter valtail = TREE_CHAIN (valtail), parmnum++) 239518334Speter { 239690075Sobrien tree type = typetail ? TREE_VALUE (typetail) : 0; 239790075Sobrien tree val = TREE_VALUE (valtail); 2398169689Skan tree rname = function; 2399169689Skan int argnum = parmnum + 1; 2400169689Skan const char *invalid_func_diag; 240118334Speter 240218334Speter if (type == void_type_node) 240318334Speter { 2404169689Skan error ("too many arguments to function %qE", function); 240518334Speter break; 240618334Speter } 240718334Speter 2408169689Skan if (selector && argnum > 2) 2409169689Skan { 2410169689Skan rname = selector; 2411169689Skan argnum -= 2; 2412169689Skan } 241318334Speter 2414169689Skan STRIP_TYPE_NOPS (val); 241518334Speter 241618334Speter val = require_complete_type (val); 241718334Speter 241818334Speter if (type != 0) 241918334Speter { 242018334Speter /* Formal parm type is specified by a function prototype. */ 242118334Speter tree parmval; 242218334Speter 2423169689Skan if (type == error_mark_node || !COMPLETE_TYPE_P (type)) 242418334Speter { 242518334Speter error ("type of formal parameter %d is incomplete", parmnum + 1); 242618334Speter parmval = val; 242718334Speter } 242818334Speter else 242918334Speter { 243018334Speter /* Optionally warn about conversions that 243118334Speter differ from the default conversions. */ 243290075Sobrien if (warn_conversion || warn_traditional) 243318334Speter { 2434169689Skan unsigned int formal_prec = TYPE_PRECISION (type); 243518334Speter 243618334Speter if (INTEGRAL_TYPE_P (type) 243718334Speter && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) 2438169689Skan warning (0, "passing argument %d of %qE as integer " 2439169689Skan "rather than floating due to prototype", 2440169689Skan argnum, rname); 244190075Sobrien if (INTEGRAL_TYPE_P (type) 244290075Sobrien && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE) 2443169689Skan warning (0, "passing argument %d of %qE as integer " 2444169689Skan "rather than complex due to prototype", 2445169689Skan argnum, rname); 244618334Speter else if (TREE_CODE (type) == COMPLEX_TYPE 244718334Speter && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) 2448169689Skan warning (0, "passing argument %d of %qE as complex " 2449169689Skan "rather than floating due to prototype", 2450169689Skan argnum, rname); 245118334Speter else if (TREE_CODE (type) == REAL_TYPE 245218334Speter && INTEGRAL_TYPE_P (TREE_TYPE (val))) 2453169689Skan warning (0, "passing argument %d of %qE as floating " 2454169689Skan "rather than integer due to prototype", 2455169689Skan argnum, rname); 245690075Sobrien else if (TREE_CODE (type) == COMPLEX_TYPE 245790075Sobrien && INTEGRAL_TYPE_P (TREE_TYPE (val))) 2458169689Skan warning (0, "passing argument %d of %qE as complex " 2459169689Skan "rather than integer due to prototype", 2460169689Skan argnum, rname); 246118334Speter else if (TREE_CODE (type) == REAL_TYPE 246218334Speter && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE) 2463169689Skan warning (0, "passing argument %d of %qE as floating " 2464169689Skan "rather than complex due to prototype", 2465169689Skan argnum, rname); 246618334Speter /* ??? At some point, messages should be written about 246718334Speter conversions between complex types, but that's too messy 246818334Speter to do now. */ 246918334Speter else if (TREE_CODE (type) == REAL_TYPE 247018334Speter && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) 247118334Speter { 247218334Speter /* Warn if any argument is passed as `float', 247318334Speter since without a prototype it would be `double'. */ 2474169689Skan if (formal_prec == TYPE_PRECISION (float_type_node) 2475169689Skan && type != dfloat32_type_node) 2476169689Skan warning (0, "passing argument %d of %qE as %<float%> " 2477169689Skan "rather than %<double%> due to prototype", 2478169689Skan argnum, rname); 2479169689Skan 2480169689Skan /* Warn if mismatch between argument and prototype 2481169689Skan for decimal float types. Warn of conversions with 2482169689Skan binary float types and of precision narrowing due to 2483169689Skan prototype. */ 2484169689Skan else if (type != TREE_TYPE (val) 2485169689Skan && (type == dfloat32_type_node 2486169689Skan || type == dfloat64_type_node 2487169689Skan || type == dfloat128_type_node 2488169689Skan || TREE_TYPE (val) == dfloat32_type_node 2489169689Skan || TREE_TYPE (val) == dfloat64_type_node 2490169689Skan || TREE_TYPE (val) == dfloat128_type_node) 2491169689Skan && (formal_prec 2492169689Skan <= TYPE_PRECISION (TREE_TYPE (val)) 2493169689Skan || (type == dfloat128_type_node 2494169689Skan && (TREE_TYPE (val) 2495169689Skan != dfloat64_type_node 2496169689Skan && (TREE_TYPE (val) 2497169689Skan != dfloat32_type_node))) 2498169689Skan || (type == dfloat64_type_node 2499169689Skan && (TREE_TYPE (val) 2500169689Skan != dfloat32_type_node)))) 2501169689Skan warning (0, "passing argument %d of %qE as %qT " 2502169689Skan "rather than %qT due to prototype", 2503169689Skan argnum, rname, type, TREE_TYPE (val)); 2504169689Skan 250518334Speter } 250690075Sobrien /* Detect integer changing in width or signedness. 250790075Sobrien These warnings are only activated with 250890075Sobrien -Wconversion, not with -Wtraditional. */ 250990075Sobrien else if (warn_conversion && INTEGRAL_TYPE_P (type) 251018334Speter && INTEGRAL_TYPE_P (TREE_TYPE (val))) 251118334Speter { 251218334Speter tree would_have_been = default_conversion (val); 251318334Speter tree type1 = TREE_TYPE (would_have_been); 251418334Speter 251518334Speter if (TREE_CODE (type) == ENUMERAL_TYPE 251690075Sobrien && (TYPE_MAIN_VARIANT (type) 251790075Sobrien == TYPE_MAIN_VARIANT (TREE_TYPE (val)))) 251818334Speter /* No warning if function asks for enum 251918334Speter and the actual arg is that enum type. */ 252018334Speter ; 252118334Speter else if (formal_prec != TYPE_PRECISION (type1)) 2522169689Skan warning (OPT_Wconversion, "passing argument %d of %qE " 2523169689Skan "with different width due to prototype", 2524169689Skan argnum, rname); 2525169689Skan else if (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (type1)) 252618334Speter ; 252718334Speter /* Don't complain if the formal parameter type 252818334Speter is an enum, because we can't tell now whether 252918334Speter the value was an enum--even the same enum. */ 253018334Speter else if (TREE_CODE (type) == ENUMERAL_TYPE) 253118334Speter ; 253218334Speter else if (TREE_CODE (val) == INTEGER_CST 253318334Speter && int_fits_type_p (val, type)) 253418334Speter /* Change in signedness doesn't matter 253518334Speter if a constant value is unaffected. */ 253618334Speter ; 253718334Speter /* If the value is extended from a narrower 253818334Speter unsigned type, it doesn't matter whether we 253918334Speter pass it as signed or unsigned; the value 254018334Speter certainly is the same either way. */ 254118334Speter else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type) 2542169689Skan && TYPE_UNSIGNED (TREE_TYPE (val))) 254318334Speter ; 2544169689Skan else if (TYPE_UNSIGNED (type)) 2545169689Skan warning (OPT_Wconversion, "passing argument %d of %qE " 2546169689Skan "as unsigned due to prototype", 2547169689Skan argnum, rname); 254818334Speter else 2549169689Skan warning (OPT_Wconversion, "passing argument %d of %qE " 2550169689Skan "as signed due to prototype", argnum, rname); 255118334Speter } 255218334Speter } 255318334Speter 2554169689Skan parmval = convert_for_assignment (type, val, ic_argpass, 2555169689Skan fundecl, function, 2556169689Skan parmnum + 1); 2557132718Skan 2558132718Skan if (targetm.calls.promote_prototypes (fundecl ? TREE_TYPE (fundecl) : 0) 255990075Sobrien && INTEGRAL_TYPE_P (type) 256018334Speter && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))) 256118334Speter parmval = default_conversion (parmval); 256218334Speter } 256318334Speter result = tree_cons (NULL_TREE, parmval, result); 256418334Speter } 256518334Speter else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE 2566169689Skan && (TYPE_PRECISION (TREE_TYPE (val)) 2567169689Skan < TYPE_PRECISION (double_type_node)) 2568169689Skan && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (val)))) 256918334Speter /* Convert `float' to `double'. */ 257018334Speter result = tree_cons (NULL_TREE, convert (double_type_node, val), result); 2571169689Skan else if ((invalid_func_diag = 2572169689Skan targetm.calls.invalid_arg_for_unprototyped_fn (typelist, fundecl, val))) 2573169689Skan { 2574169689Skan error (invalid_func_diag); 2575169689Skan return error_mark_node; 2576169689Skan } 257718334Speter else 257818334Speter /* Convert `short' and `char' to full-size `int'. */ 257918334Speter result = tree_cons (NULL_TREE, default_conversion (val), result); 258018334Speter 258118334Speter if (typetail) 258218334Speter typetail = TREE_CHAIN (typetail); 258318334Speter } 258418334Speter 258518334Speter if (typetail != 0 && TREE_VALUE (typetail) != void_type_node) 258618334Speter { 2587169689Skan error ("too few arguments to function %qE", function); 2588169689Skan return error_mark_node; 258918334Speter } 259018334Speter 259118334Speter return nreverse (result); 259218334Speter} 259318334Speter 2594169689Skan/* This is the entry point used by the parser to build unary operators 2595169689Skan in the input. CODE, a tree_code, specifies the unary operator, and 2596169689Skan ARG is the operand. For unary plus, the C parser currently uses 2597169689Skan CONVERT_EXPR for code. */ 259818334Speter 2599169689Skanstruct c_expr 2600169689Skanparser_build_unary_op (enum tree_code code, struct c_expr arg) 260118334Speter{ 2602169689Skan struct c_expr result; 260318334Speter 2604169689Skan result.original_code = ERROR_MARK; 2605169689Skan result.value = build_unary_op (code, arg.value, 0); 2606169689Skan overflow_warning (result.value); 2607169689Skan return result; 2608169689Skan} 260918334Speter 2610169689Skan/* This is the entry point used by the parser to build binary operators 2611169689Skan in the input. CODE, a tree_code, specifies the binary operator, and 2612169689Skan ARG1 and ARG2 are the operands. In addition to constructing the 2613169689Skan expression, we check for operands that were written with other binary 2614169689Skan operators in a way that is likely to confuse the user. */ 261590075Sobrien 2616169689Skanstruct c_expr 2617169689Skanparser_build_binary_op (enum tree_code code, struct c_expr arg1, 2618169689Skan struct c_expr arg2) 2619169689Skan{ 2620169689Skan struct c_expr result; 262118334Speter 2622169689Skan enum tree_code code1 = arg1.original_code; 2623169689Skan enum tree_code code2 = arg2.original_code; 2624169689Skan 2625169689Skan result.value = build_binary_op (code, arg1.value, arg2.value, 1); 2626169689Skan result.original_code = code; 2627169689Skan 2628169689Skan if (TREE_CODE (result.value) == ERROR_MARK) 2629169689Skan return result; 2630169689Skan 263118334Speter /* Check for cases such as x+y<<z which users are likely 2632169689Skan to misinterpret. */ 263318334Speter if (warn_parentheses) 263418334Speter { 263518334Speter if (code == LSHIFT_EXPR || code == RSHIFT_EXPR) 263618334Speter { 263718334Speter if (code1 == PLUS_EXPR || code1 == MINUS_EXPR 263818334Speter || code2 == PLUS_EXPR || code2 == MINUS_EXPR) 2639169689Skan warning (OPT_Wparentheses, 2640169689Skan "suggest parentheses around + or - inside shift"); 264118334Speter } 264218334Speter 264318334Speter if (code == TRUTH_ORIF_EXPR) 264418334Speter { 264518334Speter if (code1 == TRUTH_ANDIF_EXPR 264618334Speter || code2 == TRUTH_ANDIF_EXPR) 2647169689Skan warning (OPT_Wparentheses, 2648169689Skan "suggest parentheses around && within ||"); 264918334Speter } 265018334Speter 265118334Speter if (code == BIT_IOR_EXPR) 265218334Speter { 265318334Speter if (code1 == BIT_AND_EXPR || code1 == BIT_XOR_EXPR 265418334Speter || code1 == PLUS_EXPR || code1 == MINUS_EXPR 265518334Speter || code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR 265618334Speter || code2 == PLUS_EXPR || code2 == MINUS_EXPR) 2657169689Skan warning (OPT_Wparentheses, 2658169689Skan "suggest parentheses around arithmetic in operand of |"); 265918334Speter /* Check cases like x|y==z */ 2660169689Skan if (TREE_CODE_CLASS (code1) == tcc_comparison 2661169689Skan || TREE_CODE_CLASS (code2) == tcc_comparison) 2662169689Skan warning (OPT_Wparentheses, 2663169689Skan "suggest parentheses around comparison in operand of |"); 266418334Speter } 266518334Speter 266618334Speter if (code == BIT_XOR_EXPR) 266718334Speter { 266818334Speter if (code1 == BIT_AND_EXPR 266918334Speter || code1 == PLUS_EXPR || code1 == MINUS_EXPR 267018334Speter || code2 == BIT_AND_EXPR 267118334Speter || code2 == PLUS_EXPR || code2 == MINUS_EXPR) 2672169689Skan warning (OPT_Wparentheses, 2673169689Skan "suggest parentheses around arithmetic in operand of ^"); 267418334Speter /* Check cases like x^y==z */ 2675169689Skan if (TREE_CODE_CLASS (code1) == tcc_comparison 2676169689Skan || TREE_CODE_CLASS (code2) == tcc_comparison) 2677169689Skan warning (OPT_Wparentheses, 2678169689Skan "suggest parentheses around comparison in operand of ^"); 267918334Speter } 268018334Speter 268118334Speter if (code == BIT_AND_EXPR) 268218334Speter { 268318334Speter if (code1 == PLUS_EXPR || code1 == MINUS_EXPR 268418334Speter || code2 == PLUS_EXPR || code2 == MINUS_EXPR) 2685169689Skan warning (OPT_Wparentheses, 2686169689Skan "suggest parentheses around + or - in operand of &"); 268718334Speter /* Check cases like x&y==z */ 2688169689Skan if (TREE_CODE_CLASS (code1) == tcc_comparison 2689169689Skan || TREE_CODE_CLASS (code2) == tcc_comparison) 2690169689Skan warning (OPT_Wparentheses, 2691169689Skan "suggest parentheses around comparison in operand of &"); 269218334Speter } 2693169689Skan /* Similarly, check for cases like 1<=i<=10 that are probably errors. */ 2694169689Skan if (TREE_CODE_CLASS (code) == tcc_comparison 2695169689Skan && (TREE_CODE_CLASS (code1) == tcc_comparison 2696169689Skan || TREE_CODE_CLASS (code2) == tcc_comparison)) 2697169689Skan warning (OPT_Wparentheses, "comparisons like X<=Y<=Z do not " 2698169689Skan "have their mathematical meaning"); 2699169689Skan 270018334Speter } 270118334Speter 2702169689Skan /* Warn about comparisons against string literals, with the exception 2703169689Skan of testing for equality or inequality of a string literal with NULL. */ 2704169689Skan if (code == EQ_EXPR || code == NE_EXPR) 270518334Speter { 2706169689Skan if ((code1 == STRING_CST && !integer_zerop (arg2.value)) 2707169689Skan || (code2 == STRING_CST && !integer_zerop (arg1.value))) 2708169689Skan warning (OPT_Waddress, 2709169689Skan "comparison with string literal results in unspecified behaviour"); 271018334Speter } 2711169689Skan else if (TREE_CODE_CLASS (code) == tcc_comparison 2712169689Skan && (code1 == STRING_CST || code2 == STRING_CST)) 2713169689Skan warning (OPT_Waddress, 2714169689Skan "comparison with string literal results in unspecified behaviour"); 271518334Speter 2716169689Skan overflow_warning (result.value); 2717169689Skan 271818334Speter return result; 271918334Speter} 272018334Speter 272118334Speter/* Return a tree for the difference of pointers OP0 and OP1. 272218334Speter The resulting tree has type int. */ 272318334Speter 272418334Speterstatic tree 2725132718Skanpointer_diff (tree op0, tree op1) 272618334Speter{ 272718334Speter tree restype = ptrdiff_type_node; 272818334Speter 272918334Speter tree target_type = TREE_TYPE (TREE_TYPE (op0)); 273090075Sobrien tree con0, con1, lit0, lit1; 273190075Sobrien tree orig_op1 = op1; 273218334Speter 273318334Speter if (pedantic || warn_pointer_arith) 273418334Speter { 273518334Speter if (TREE_CODE (target_type) == VOID_TYPE) 2736169689Skan pedwarn ("pointer of type %<void *%> used in subtraction"); 273718334Speter if (TREE_CODE (target_type) == FUNCTION_TYPE) 273818334Speter pedwarn ("pointer to a function used in subtraction"); 273918334Speter } 274018334Speter 274190075Sobrien /* If the conversion to ptrdiff_type does anything like widening or 274290075Sobrien converting a partial to an integral mode, we get a convert_expression 274390075Sobrien that is in the way to do any simplifications. 274490075Sobrien (fold-const.c doesn't know that the extra bits won't be needed. 274590075Sobrien split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a 274690075Sobrien different mode in place.) 274790075Sobrien So first try to find a common term here 'by hand'; we want to cover 274890075Sobrien at least the cases that occur in legal static initializers. */ 2749169689Skan if ((TREE_CODE (op0) == NOP_EXPR || TREE_CODE (op0) == CONVERT_EXPR) 2750169689Skan && (TYPE_PRECISION (TREE_TYPE (op0)) 2751169689Skan == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0))))) 2752169689Skan con0 = TREE_OPERAND (op0, 0); 2753169689Skan else 2754169689Skan con0 = op0; 2755169689Skan if ((TREE_CODE (op1) == NOP_EXPR || TREE_CODE (op1) == CONVERT_EXPR) 2756169689Skan && (TYPE_PRECISION (TREE_TYPE (op1)) 2757169689Skan == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0))))) 2758169689Skan con1 = TREE_OPERAND (op1, 0); 2759169689Skan else 2760169689Skan con1 = op1; 276190075Sobrien 276290075Sobrien if (TREE_CODE (con0) == PLUS_EXPR) 276390075Sobrien { 276490075Sobrien lit0 = TREE_OPERAND (con0, 1); 276590075Sobrien con0 = TREE_OPERAND (con0, 0); 276690075Sobrien } 276790075Sobrien else 276890075Sobrien lit0 = integer_zero_node; 276990075Sobrien 277090075Sobrien if (TREE_CODE (con1) == PLUS_EXPR) 277190075Sobrien { 277290075Sobrien lit1 = TREE_OPERAND (con1, 1); 277390075Sobrien con1 = TREE_OPERAND (con1, 0); 277490075Sobrien } 277590075Sobrien else 277690075Sobrien lit1 = integer_zero_node; 277790075Sobrien 277890075Sobrien if (operand_equal_p (con0, con1, 0)) 277990075Sobrien { 278090075Sobrien op0 = lit0; 278190075Sobrien op1 = lit1; 278290075Sobrien } 278390075Sobrien 278490075Sobrien 278518334Speter /* First do the subtraction as integers; 278650397Sobrien then drop through to build the divide operator. 278750397Sobrien Do not do default conversions on the minus operator 278850397Sobrien in case restype is a short type. */ 278918334Speter 279018334Speter op0 = build_binary_op (MINUS_EXPR, convert (restype, op0), 279150397Sobrien convert (restype, op1), 0); 279218334Speter /* This generates an error if op1 is pointer to incomplete type. */ 279390075Sobrien if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1)))) 279418334Speter error ("arithmetic on pointer to an incomplete type"); 279518334Speter 279618334Speter /* This generates an error if op0 is pointer to incomplete type. */ 279718334Speter op1 = c_size_in_bytes (target_type); 279818334Speter 279918334Speter /* Divide by the size, in easiest possible way. */ 2800169689Skan return fold_build2 (EXACT_DIV_EXPR, restype, op0, convert (restype, op1)); 280118334Speter} 280218334Speter 280318334Speter/* Construct and perhaps optimize a tree representation 280418334Speter for a unary operation. CODE, a tree_code, specifies the operation 280590075Sobrien and XARG is the operand. 280690075Sobrien For any CODE other than ADDR_EXPR, FLAG nonzero suppresses 280790075Sobrien the default promotions (such as from short to int). 280890075Sobrien For ADDR_EXPR, the default promotions are not applied; FLAG nonzero 280990075Sobrien allows non-lvalues; this is only used to handle conversion of non-lvalue 281090075Sobrien arrays to pointers in C99. */ 281118334Speter 281218334Spetertree 2813132718Skanbuild_unary_op (enum tree_code code, tree xarg, int flag) 281418334Speter{ 281518334Speter /* No default_conversion here. It causes trouble for ADDR_EXPR. */ 281690075Sobrien tree arg = xarg; 281790075Sobrien tree argtype = 0; 281890075Sobrien enum tree_code typecode = TREE_CODE (TREE_TYPE (arg)); 281918334Speter tree val; 282090075Sobrien int noconvert = flag; 2821169689Skan const char *invalid_op_diag; 282218334Speter 282318334Speter if (typecode == ERROR_MARK) 282418334Speter return error_mark_node; 282590075Sobrien if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE) 282618334Speter typecode = INTEGER_TYPE; 282718334Speter 2828169689Skan if ((invalid_op_diag 2829169689Skan = targetm.invalid_unary_op (code, TREE_TYPE (xarg)))) 2830169689Skan { 2831169689Skan error (invalid_op_diag); 2832169689Skan return error_mark_node; 2833169689Skan } 2834169689Skan 283518334Speter switch (code) 283618334Speter { 283718334Speter case CONVERT_EXPR: 283818334Speter /* This is used for unary plus, because a CONVERT_EXPR 283918334Speter is enough to prevent anybody from looking inside for 284018334Speter associativity, but won't generate any code. */ 284118334Speter if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE 2842169689Skan || typecode == COMPLEX_TYPE 2843169689Skan || typecode == VECTOR_TYPE)) 284452284Sobrien { 284552284Sobrien error ("wrong type argument to unary plus"); 284652284Sobrien return error_mark_node; 284752284Sobrien } 284818334Speter else if (!noconvert) 284918334Speter arg = default_conversion (arg); 2850117395Skan arg = non_lvalue (arg); 285118334Speter break; 285218334Speter 285318334Speter case NEGATE_EXPR: 285418334Speter if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE 2855117395Skan || typecode == COMPLEX_TYPE 2856117395Skan || typecode == VECTOR_TYPE)) 285752284Sobrien { 285852284Sobrien error ("wrong type argument to unary minus"); 285952284Sobrien return error_mark_node; 286052284Sobrien } 286118334Speter else if (!noconvert) 286218334Speter arg = default_conversion (arg); 286318334Speter break; 286418334Speter 286518334Speter case BIT_NOT_EXPR: 2866117395Skan if (typecode == INTEGER_TYPE || typecode == VECTOR_TYPE) 286718334Speter { 2868117395Skan if (!noconvert) 2869117395Skan arg = default_conversion (arg); 2870117395Skan } 2871117395Skan else if (typecode == COMPLEX_TYPE) 2872117395Skan { 287318334Speter code = CONJ_EXPR; 287490075Sobrien if (pedantic) 2875169689Skan pedwarn ("ISO C does not support %<~%> for complex conjugation"); 287618334Speter if (!noconvert) 287718334Speter arg = default_conversion (arg); 287818334Speter } 2879117395Skan else 288052284Sobrien { 288152284Sobrien error ("wrong type argument to bit-complement"); 288252284Sobrien return error_mark_node; 288352284Sobrien } 288418334Speter break; 288518334Speter 288618334Speter case ABS_EXPR: 2887132718Skan if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE)) 288852284Sobrien { 288952284Sobrien error ("wrong type argument to abs"); 289052284Sobrien return error_mark_node; 289152284Sobrien } 289218334Speter else if (!noconvert) 289318334Speter arg = default_conversion (arg); 289418334Speter break; 289518334Speter 289618334Speter case CONJ_EXPR: 289718334Speter /* Conjugating a real value is a no-op, but allow it anyway. */ 289818334Speter if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE 289918334Speter || typecode == COMPLEX_TYPE)) 290052284Sobrien { 290152284Sobrien error ("wrong type argument to conjugation"); 290252284Sobrien return error_mark_node; 290352284Sobrien } 290418334Speter else if (!noconvert) 290518334Speter arg = default_conversion (arg); 290618334Speter break; 290718334Speter 290818334Speter case TRUTH_NOT_EXPR: 290918334Speter if (typecode != INTEGER_TYPE 291018334Speter && typecode != REAL_TYPE && typecode != POINTER_TYPE 2911169689Skan && typecode != COMPLEX_TYPE) 291218334Speter { 291352284Sobrien error ("wrong type argument to unary exclamation mark"); 291452284Sobrien return error_mark_node; 291518334Speter } 2916169689Skan arg = c_objc_common_truthvalue_conversion (arg); 291718334Speter return invert_truthvalue (arg); 291818334Speter 291918334Speter case REALPART_EXPR: 292018334Speter if (TREE_CODE (arg) == COMPLEX_CST) 292118334Speter return TREE_REALPART (arg); 292218334Speter else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE) 2923169689Skan return fold_build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg); 292418334Speter else 292518334Speter return arg; 292618334Speter 292718334Speter case IMAGPART_EXPR: 292818334Speter if (TREE_CODE (arg) == COMPLEX_CST) 292918334Speter return TREE_IMAGPART (arg); 293018334Speter else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE) 2931169689Skan return fold_build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg); 293218334Speter else 293318334Speter return convert (TREE_TYPE (arg), integer_zero_node); 2934132718Skan 293518334Speter case PREINCREMENT_EXPR: 293618334Speter case POSTINCREMENT_EXPR: 293718334Speter case PREDECREMENT_EXPR: 293818334Speter case POSTDECREMENT_EXPR: 293918334Speter 294018334Speter /* Increment or decrement the real part of the value, 294118334Speter and don't change the imaginary part. */ 294218334Speter if (typecode == COMPLEX_TYPE) 294318334Speter { 294418334Speter tree real, imag; 294518334Speter 294690075Sobrien if (pedantic) 2947169689Skan pedwarn ("ISO C does not support %<++%> and %<--%>" 2948169689Skan " on complex types"); 294990075Sobrien 295018334Speter arg = stabilize_reference (arg); 295118334Speter real = build_unary_op (REALPART_EXPR, arg, 1); 295218334Speter imag = build_unary_op (IMAGPART_EXPR, arg, 1); 2953169689Skan return build2 (COMPLEX_EXPR, TREE_TYPE (arg), 2954169689Skan build_unary_op (code, real, 1), imag); 295518334Speter } 295618334Speter 295718334Speter /* Report invalid types. */ 295818334Speter 295918334Speter if (typecode != POINTER_TYPE 296018334Speter && typecode != INTEGER_TYPE && typecode != REAL_TYPE) 296118334Speter { 296290075Sobrien if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) 2963169689Skan error ("wrong type argument to increment"); 2964169689Skan else 2965169689Skan error ("wrong type argument to decrement"); 296690075Sobrien 296752284Sobrien return error_mark_node; 296818334Speter } 296918334Speter 297018334Speter { 297190075Sobrien tree inc; 297218334Speter tree result_type = TREE_TYPE (arg); 297318334Speter 2974117395Skan arg = get_unwidened (arg, 0); 2975117395Skan argtype = TREE_TYPE (arg); 2976117395Skan 297718334Speter /* Compute the increment. */ 297818334Speter 297918334Speter if (typecode == POINTER_TYPE) 298018334Speter { 298118334Speter /* If pointer target is an undefined struct, 298218334Speter we just cannot know how to do the arithmetic. */ 298390075Sobrien if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type))) 298490075Sobrien { 298590075Sobrien if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) 298690075Sobrien error ("increment of pointer to unknown structure"); 298790075Sobrien else 298890075Sobrien error ("decrement of pointer to unknown structure"); 298990075Sobrien } 299018334Speter else if ((pedantic || warn_pointer_arith) 299118334Speter && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE 299218334Speter || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)) 2993169689Skan { 299490075Sobrien if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) 299590075Sobrien pedwarn ("wrong type argument to increment"); 299690075Sobrien else 299790075Sobrien pedwarn ("wrong type argument to decrement"); 299890075Sobrien } 299990075Sobrien 300018334Speter inc = c_size_in_bytes (TREE_TYPE (result_type)); 300118334Speter } 300218334Speter else 300318334Speter inc = integer_one_node; 300418334Speter 300518334Speter inc = convert (argtype, inc); 300618334Speter 300718334Speter /* Complain about anything else that is not a true lvalue. */ 300818334Speter if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR 300918334Speter || code == POSTINCREMENT_EXPR) 3010169689Skan ? lv_increment 3011169689Skan : lv_decrement))) 301218334Speter return error_mark_node; 301318334Speter 301418334Speter /* Report a read-only lvalue. */ 301518334Speter if (TREE_READONLY (arg)) 3016169689Skan { 3017169689Skan readonly_error (arg, 3018169689Skan ((code == PREINCREMENT_EXPR 3019169689Skan || code == POSTINCREMENT_EXPR) 3020169689Skan ? lv_increment : lv_decrement)); 3021169689Skan return error_mark_node; 3022169689Skan } 302318334Speter 302490075Sobrien if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE) 302590075Sobrien val = boolean_increment (code, arg); 302690075Sobrien else 3027169689Skan val = build2 (code, TREE_TYPE (arg), arg, inc); 302818334Speter TREE_SIDE_EFFECTS (val) = 1; 302918334Speter val = convert (result_type, val); 303018334Speter if (TREE_CODE (val) != code) 3031169689Skan TREE_NO_WARNING (val) = 1; 303218334Speter return val; 303318334Speter } 303418334Speter 303518334Speter case ADDR_EXPR: 303690075Sobrien /* Note that this operation never does default_conversion. */ 303718334Speter 303818334Speter /* Let &* cancel out to simplify resulting code. */ 303918334Speter if (TREE_CODE (arg) == INDIRECT_REF) 304018334Speter { 304118334Speter /* Don't let this be an lvalue. */ 304218334Speter if (lvalue_p (TREE_OPERAND (arg, 0))) 304318334Speter return non_lvalue (TREE_OPERAND (arg, 0)); 304418334Speter return TREE_OPERAND (arg, 0); 304518334Speter } 304618334Speter 304718334Speter /* For &x[y], return x+y */ 304818334Speter if (TREE_CODE (arg) == ARRAY_REF) 304918334Speter { 3050169689Skan tree op0 = TREE_OPERAND (arg, 0); 3051169689Skan if (!c_mark_addressable (op0)) 305218334Speter return error_mark_node; 3053169689Skan return build_binary_op (PLUS_EXPR, 3054169689Skan (TREE_CODE (TREE_TYPE (op0)) == ARRAY_TYPE 3055169689Skan ? array_to_pointer_conversion (op0) 3056169689Skan : op0), 305718334Speter TREE_OPERAND (arg, 1), 1); 305818334Speter } 305918334Speter 306018334Speter /* Anything not already handled and not a true memory reference 306190075Sobrien or a non-lvalue array is an error. */ 306290075Sobrien else if (typecode != FUNCTION_TYPE && !flag 3063169689Skan && !lvalue_or_else (arg, lv_addressof)) 306418334Speter return error_mark_node; 306518334Speter 306618334Speter /* Ordinary case; arg is a COMPONENT_REF or a decl. */ 306718334Speter argtype = TREE_TYPE (arg); 306890075Sobrien 306952284Sobrien /* If the lvalue is const or volatile, merge that into the type 3070169689Skan to which the address will point. Note that you can't get a 307152284Sobrien restricted pointer by taking the address of something, so we 307252284Sobrien only have to deal with `const' and `volatile' here. */ 3073169689Skan if ((DECL_P (arg) || REFERENCE_CLASS_P (arg)) 307490075Sobrien && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg))) 307590075Sobrien argtype = c_build_type_variant (argtype, 307690075Sobrien TREE_READONLY (arg), 307790075Sobrien TREE_THIS_VOLATILE (arg)); 307818334Speter 3079117395Skan if (!c_mark_addressable (arg)) 308018334Speter return error_mark_node; 308118334Speter 3082169689Skan gcc_assert (TREE_CODE (arg) != COMPONENT_REF 3083169689Skan || !DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1))); 308418334Speter 3085169689Skan argtype = build_pointer_type (argtype); 308618334Speter 3087169689Skan /* ??? Cope with user tricks that amount to offsetof. Delete this 3088169689Skan when we have proper support for integer constant expressions. */ 3089169689Skan val = get_base_address (arg); 3090169689Skan if (val && TREE_CODE (val) == INDIRECT_REF 3091169689Skan && TREE_CONSTANT (TREE_OPERAND (val, 0))) 3092169689Skan { 3093169689Skan tree op0 = fold_convert (argtype, fold_offsetof (arg, val)), op1; 309418334Speter 3095169689Skan op1 = fold_convert (argtype, TREE_OPERAND (val, 0)); 3096169689Skan return fold_build2 (PLUS_EXPR, argtype, op0, op1); 3097169689Skan } 309818334Speter 3099169689Skan val = build1 (ADDR_EXPR, argtype, arg); 310018334Speter 3101169689Skan return val; 310250397Sobrien 310350397Sobrien default: 3104169689Skan gcc_unreachable (); 310518334Speter } 310618334Speter 310752284Sobrien if (argtype == 0) 310852284Sobrien argtype = TREE_TYPE (arg); 3109169689Skan return require_constant_value ? fold_build1_initializer (code, argtype, arg) 3110169689Skan : fold_build1 (code, argtype, arg); 311118334Speter} 311218334Speter 311318334Speter/* Return nonzero if REF is an lvalue valid for this language. 311418334Speter Lvalues can be assigned, unless their type has TYPE_READONLY. 3115169689Skan Lvalues can have their address taken, unless they have C_DECL_REGISTER. */ 311618334Speter 3117169689Skanstatic int 3118132718Skanlvalue_p (tree ref) 311918334Speter{ 312090075Sobrien enum tree_code code = TREE_CODE (ref); 312118334Speter 312218334Speter switch (code) 312318334Speter { 312418334Speter case REALPART_EXPR: 312518334Speter case IMAGPART_EXPR: 312618334Speter case COMPONENT_REF: 312718334Speter return lvalue_p (TREE_OPERAND (ref, 0)); 312818334Speter 312990075Sobrien case COMPOUND_LITERAL_EXPR: 313018334Speter case STRING_CST: 313118334Speter return 1; 313218334Speter 313318334Speter case INDIRECT_REF: 313418334Speter case ARRAY_REF: 313518334Speter case VAR_DECL: 313618334Speter case PARM_DECL: 313718334Speter case RESULT_DECL: 313818334Speter case ERROR_MARK: 313950397Sobrien return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE 314050397Sobrien && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE); 314150397Sobrien 314250397Sobrien case BIND_EXPR: 314350397Sobrien return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE; 314450397Sobrien 314550397Sobrien default: 314650397Sobrien return 0; 314718334Speter } 314818334Speter} 3149169689Skan 3150169689Skan/* Give an error for storing in something that is 'const'. */ 315118334Speter 315218334Speterstatic void 3153169689Skanreadonly_error (tree arg, enum lvalue_use use) 315418334Speter{ 3155169689Skan gcc_assert (use == lv_assign || use == lv_increment || use == lv_decrement 3156169689Skan || use == lv_asm); 3157169689Skan /* Using this macro rather than (for example) arrays of messages 3158169689Skan ensures that all the format strings are checked at compile 3159169689Skan time. */ 3160169689Skan#define READONLY_MSG(A, I, D, AS) (use == lv_assign ? (A) \ 3161169689Skan : (use == lv_increment ? (I) \ 3162169689Skan : (use == lv_decrement ? (D) : (AS)))) 316318334Speter if (TREE_CODE (arg) == COMPONENT_REF) 316418334Speter { 316518334Speter if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0)))) 3166169689Skan readonly_error (TREE_OPERAND (arg, 0), use); 316718334Speter else 3168169689Skan error (READONLY_MSG (G_("assignment of read-only member %qD"), 3169169689Skan G_("increment of read-only member %qD"), 3170169689Skan G_("decrement of read-only member %qD"), 3171169689Skan G_("read-only member %qD used as %<asm%> output")), 3172169689Skan TREE_OPERAND (arg, 1)); 317318334Speter } 317418334Speter else if (TREE_CODE (arg) == VAR_DECL) 3175169689Skan error (READONLY_MSG (G_("assignment of read-only variable %qD"), 3176169689Skan G_("increment of read-only variable %qD"), 3177169689Skan G_("decrement of read-only variable %qD"), 3178169689Skan G_("read-only variable %qD used as %<asm%> output")), 3179169689Skan arg); 318018334Speter else 3181169689Skan error (READONLY_MSG (G_("assignment of read-only location"), 3182169689Skan G_("increment of read-only location"), 3183169689Skan G_("decrement of read-only location"), 3184169689Skan G_("read-only location used as %<asm%> output"))); 318518334Speter} 3186169689Skan 3187169689Skan 3188169689Skan/* Return nonzero if REF is an lvalue valid for this language; 3189169689Skan otherwise, print an error message and return zero. USE says 3190169689Skan how the lvalue is being used and so selects the error message. */ 3191169689Skan 3192169689Skanstatic int 3193169689Skanlvalue_or_else (tree ref, enum lvalue_use use) 3194169689Skan{ 3195169689Skan int win = lvalue_p (ref); 3196169689Skan 3197169689Skan if (!win) 3198169689Skan lvalue_error (use); 3199169689Skan 3200169689Skan return win; 3201169689Skan} 320218334Speter 320318334Speter/* Mark EXP saying that we need to be able to take the 320418334Speter address of it; it should not be allocated in a register. 3205117395Skan Returns true if successful. */ 320618334Speter 3207117395Skanbool 3208132718Skanc_mark_addressable (tree exp) 320918334Speter{ 321090075Sobrien tree x = exp; 3211117395Skan 321218334Speter while (1) 321318334Speter switch (TREE_CODE (x)) 321418334Speter { 321550397Sobrien case COMPONENT_REF: 321650397Sobrien if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1))) 321750397Sobrien { 3218169689Skan error 3219169689Skan ("cannot take address of bit-field %qD", TREE_OPERAND (x, 1)); 3220117395Skan return false; 322150397Sobrien } 322250397Sobrien 322350397Sobrien /* ... fall through ... */ 322450397Sobrien 322518334Speter case ADDR_EXPR: 322618334Speter case ARRAY_REF: 322718334Speter case REALPART_EXPR: 322818334Speter case IMAGPART_EXPR: 322918334Speter x = TREE_OPERAND (x, 0); 323018334Speter break; 323118334Speter 323290075Sobrien case COMPOUND_LITERAL_EXPR: 323318334Speter case CONSTRUCTOR: 323418334Speter TREE_ADDRESSABLE (x) = 1; 3235117395Skan return true; 323618334Speter 323718334Speter case VAR_DECL: 323818334Speter case CONST_DECL: 323918334Speter case PARM_DECL: 324018334Speter case RESULT_DECL: 3241169689Skan if (C_DECL_REGISTER (x) 324218334Speter && DECL_NONLOCAL (x)) 324318334Speter { 3244132718Skan if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x)) 324518334Speter { 3246169689Skan error 3247169689Skan ("global register variable %qD used in nested function", x); 3248117395Skan return false; 324918334Speter } 3250169689Skan pedwarn ("register variable %qD used in nested function", x); 325118334Speter } 3252169689Skan else if (C_DECL_REGISTER (x)) 325318334Speter { 3254132718Skan if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x)) 3255169689Skan error ("address of global register variable %qD requested", x); 3256169689Skan else 3257169689Skan error ("address of register variable %qD requested", x); 3258169689Skan return false; 325918334Speter } 326018334Speter 326118334Speter /* drops in */ 326218334Speter case FUNCTION_DECL: 326318334Speter TREE_ADDRESSABLE (x) = 1; 3264132718Skan /* drops out */ 326518334Speter default: 3266117395Skan return true; 326718334Speter } 326818334Speter} 326918334Speter 327018334Speter/* Build and return a conditional expression IFEXP ? OP1 : OP2. */ 327118334Speter 327218334Spetertree 3273132718Skanbuild_conditional_expr (tree ifexp, tree op1, tree op2) 327418334Speter{ 327590075Sobrien tree type1; 327690075Sobrien tree type2; 327790075Sobrien enum tree_code code1; 327890075Sobrien enum tree_code code2; 327990075Sobrien tree result_type = NULL; 328018334Speter tree orig_op1 = op1, orig_op2 = op2; 328118334Speter 328218334Speter /* Promote both alternatives. */ 328318334Speter 328418334Speter if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE) 328518334Speter op1 = default_conversion (op1); 328618334Speter if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE) 328718334Speter op2 = default_conversion (op2); 328818334Speter 328918334Speter if (TREE_CODE (ifexp) == ERROR_MARK 329018334Speter || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK 329118334Speter || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK) 329218334Speter return error_mark_node; 329318334Speter 329418334Speter type1 = TREE_TYPE (op1); 329518334Speter code1 = TREE_CODE (type1); 329618334Speter type2 = TREE_TYPE (op2); 329718334Speter code2 = TREE_CODE (type2); 3298132718Skan 3299169689Skan /* C90 does not permit non-lvalue arrays in conditional expressions. 3300169689Skan In C99 they will be pointers by now. */ 3301169689Skan if (code1 == ARRAY_TYPE || code2 == ARRAY_TYPE) 3302169689Skan { 3303169689Skan error ("non-lvalue array in conditional expression"); 3304169689Skan return error_mark_node; 3305169689Skan } 3306169689Skan 330718334Speter /* Quickly detect the usual case where op1 and op2 have the same type 330818334Speter after promotion. */ 330918334Speter if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2)) 331018334Speter { 331118334Speter if (type1 == type2) 331218334Speter result_type = type1; 331318334Speter else 331418334Speter result_type = TYPE_MAIN_VARIANT (type1); 331518334Speter } 331690075Sobrien else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE 3317169689Skan || code1 == COMPLEX_TYPE) 3318169689Skan && (code2 == INTEGER_TYPE || code2 == REAL_TYPE 3319169689Skan || code2 == COMPLEX_TYPE)) 332018334Speter { 3321169689Skan result_type = c_common_type (type1, type2); 332290075Sobrien 332390075Sobrien /* If -Wsign-compare, warn here if type1 and type2 have 332490075Sobrien different signedness. We'll promote the signed to unsigned 332590075Sobrien and later code won't know it used to be different. 332690075Sobrien Do this check on the original types, so that explicit casts 332790075Sobrien will be considered, but default promotions won't. */ 3328132718Skan if (warn_sign_compare && !skip_evaluation) 332990075Sobrien { 3330169689Skan int unsigned_op1 = TYPE_UNSIGNED (TREE_TYPE (orig_op1)); 3331169689Skan int unsigned_op2 = TYPE_UNSIGNED (TREE_TYPE (orig_op2)); 333290075Sobrien 333390075Sobrien if (unsigned_op1 ^ unsigned_op2) 333490075Sobrien { 3335169689Skan bool ovf; 3336169689Skan 333790075Sobrien /* Do not warn if the result type is signed, since the 333890075Sobrien signed type will only be chosen if it can represent 333990075Sobrien all the values of the unsigned type. */ 3340169689Skan if (!TYPE_UNSIGNED (result_type)) 334190075Sobrien /* OK */; 334290075Sobrien /* Do not warn if the signed quantity is an unsuffixed 334390075Sobrien integer literal (or some static constant expression 334490075Sobrien involving such literals) and it is non-negative. */ 3345169689Skan else if ((unsigned_op2 3346169689Skan && tree_expr_nonnegative_warnv_p (op1, &ovf)) 3347169689Skan || (unsigned_op1 3348169689Skan && tree_expr_nonnegative_warnv_p (op2, &ovf))) 334990075Sobrien /* OK */; 335090075Sobrien else 3351169689Skan warning (0, "signed and unsigned type in conditional expression"); 335290075Sobrien } 335390075Sobrien } 335418334Speter } 335518334Speter else if (code1 == VOID_TYPE || code2 == VOID_TYPE) 335618334Speter { 335718334Speter if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE)) 335890075Sobrien pedwarn ("ISO C forbids conditional expr with only one void side"); 335918334Speter result_type = void_type_node; 336018334Speter } 336118334Speter else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE) 336218334Speter { 3363169689Skan if (comp_target_types (type1, type2)) 3364169689Skan result_type = common_pointer_type (type1, type2); 3365169689Skan else if (null_pointer_constant_p (orig_op1)) 336618334Speter result_type = qualify_type (type2, type1); 3367169689Skan else if (null_pointer_constant_p (orig_op2)) 336818334Speter result_type = qualify_type (type1, type2); 336990075Sobrien else if (VOID_TYPE_P (TREE_TYPE (type1))) 337018334Speter { 337118334Speter if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE) 3372169689Skan pedwarn ("ISO C forbids conditional expr between " 3373169689Skan "%<void *%> and function pointer"); 337490075Sobrien result_type = build_pointer_type (qualify_type (TREE_TYPE (type1), 337590075Sobrien TREE_TYPE (type2))); 337618334Speter } 337790075Sobrien else if (VOID_TYPE_P (TREE_TYPE (type2))) 337818334Speter { 337918334Speter if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE) 3380169689Skan pedwarn ("ISO C forbids conditional expr between " 3381169689Skan "%<void *%> and function pointer"); 338290075Sobrien result_type = build_pointer_type (qualify_type (TREE_TYPE (type2), 338390075Sobrien TREE_TYPE (type1))); 338418334Speter } 338518334Speter else 338618334Speter { 338718334Speter pedwarn ("pointer type mismatch in conditional expression"); 338818334Speter result_type = build_pointer_type (void_type_node); 338918334Speter } 339018334Speter } 339118334Speter else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE) 339218334Speter { 3393169689Skan if (!null_pointer_constant_p (orig_op2)) 339418334Speter pedwarn ("pointer/integer type mismatch in conditional expression"); 339518334Speter else 339618334Speter { 339718334Speter op2 = null_pointer_node; 339818334Speter } 339918334Speter result_type = type1; 340018334Speter } 340118334Speter else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE) 340218334Speter { 3403169689Skan if (!null_pointer_constant_p (orig_op1)) 340418334Speter pedwarn ("pointer/integer type mismatch in conditional expression"); 340518334Speter else 340618334Speter { 340718334Speter op1 = null_pointer_node; 340818334Speter } 340918334Speter result_type = type2; 341018334Speter } 341118334Speter 341218334Speter if (!result_type) 341318334Speter { 341418334Speter if (flag_cond_mismatch) 341518334Speter result_type = void_type_node; 341618334Speter else 341718334Speter { 341818334Speter error ("type mismatch in conditional expression"); 341918334Speter return error_mark_node; 342018334Speter } 342118334Speter } 342218334Speter 342318334Speter /* Merge const and volatile flags of the incoming types. */ 342418334Speter result_type 342518334Speter = build_type_variant (result_type, 342618334Speter TREE_READONLY (op1) || TREE_READONLY (op2), 342718334Speter TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2)); 342818334Speter 342918334Speter if (result_type != TREE_TYPE (op1)) 343018334Speter op1 = convert_and_check (result_type, op1); 343118334Speter if (result_type != TREE_TYPE (op2)) 343218334Speter op2 = convert_and_check (result_type, op2); 3433132718Skan 3434169689Skan return fold_build3 (COND_EXPR, result_type, ifexp, op1, op2); 343518334Speter} 343618334Speter 3437169689Skan/* Return a compound expression that performs two expressions and 3438169689Skan returns the value of the second of them. */ 343918334Speter 344018334Spetertree 3441169689Skanbuild_compound_expr (tree expr1, tree expr2) 344218334Speter{ 3443169689Skan if (!TREE_SIDE_EFFECTS (expr1)) 344418334Speter { 344518334Speter /* The left-hand operand of a comma expression is like an expression 3446169689Skan statement: with -Wextra or -Wunused, we should warn if it doesn't have 344718334Speter any side-effects, unless it was explicitly cast to (void). */ 3448169689Skan if (warn_unused_value) 3449169689Skan { 3450169689Skan if (VOID_TYPE_P (TREE_TYPE (expr1)) 3451169689Skan && (TREE_CODE (expr1) == NOP_EXPR 3452169689Skan || TREE_CODE (expr1) == CONVERT_EXPR)) 3453169689Skan ; /* (void) a, b */ 3454169689Skan else if (VOID_TYPE_P (TREE_TYPE (expr1)) 3455169689Skan && TREE_CODE (expr1) == COMPOUND_EXPR 3456169689Skan && (TREE_CODE (TREE_OPERAND (expr1, 1)) == CONVERT_EXPR 3457169689Skan || TREE_CODE (TREE_OPERAND (expr1, 1)) == NOP_EXPR)) 3458169689Skan ; /* (void) a, (void) b, c */ 3459169689Skan else 3460169689Skan warning (0, "left-hand operand of comma expression has no effect"); 3461169689Skan } 346218334Speter } 346318334Speter 346418334Speter /* With -Wunused, we should also warn if the left-hand operand does have 346518334Speter side-effects, but computes a value which is not used. For example, in 346618334Speter `foo() + bar(), baz()' the result of the `+' operator is not used, 346718334Speter so we should issue a warning. */ 346890075Sobrien else if (warn_unused_value) 3469169689Skan warn_if_unused_value (expr1, input_location); 347018334Speter 3471169689Skan if (expr2 == error_mark_node) 3472169689Skan return error_mark_node; 3473169689Skan 3474169689Skan return build2 (COMPOUND_EXPR, TREE_TYPE (expr2), expr1, expr2); 347518334Speter} 347618334Speter 347718334Speter/* Build an expression representing a cast to type TYPE of expression EXPR. */ 347818334Speter 347918334Spetertree 3480132718Skanbuild_c_cast (tree type, tree expr) 348118334Speter{ 348290075Sobrien tree value = expr; 3483132718Skan 348418334Speter if (type == error_mark_node || expr == error_mark_node) 348518334Speter return error_mark_node; 348618334Speter 3487117395Skan /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing 3488117395Skan only in <protocol> qualifications. But when constructing cast expressions, 3489117395Skan the protocols do matter and must be kept around. */ 3490169689Skan if (objc_is_object_ptr (type) && objc_is_object_ptr (TREE_TYPE (expr))) 3491169689Skan return build1 (NOP_EXPR, type, expr); 3492117395Skan 3493169689Skan type = TYPE_MAIN_VARIANT (type); 3494169689Skan 349518334Speter if (TREE_CODE (type) == ARRAY_TYPE) 349618334Speter { 349718334Speter error ("cast specifies array type"); 349818334Speter return error_mark_node; 349918334Speter } 350018334Speter 350118334Speter if (TREE_CODE (type) == FUNCTION_TYPE) 350218334Speter { 350318334Speter error ("cast specifies function type"); 350418334Speter return error_mark_node; 350518334Speter } 350618334Speter 350790075Sobrien if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value))) 350818334Speter { 350918334Speter if (pedantic) 351018334Speter { 351118334Speter if (TREE_CODE (type) == RECORD_TYPE 351218334Speter || TREE_CODE (type) == UNION_TYPE) 351390075Sobrien pedwarn ("ISO C forbids casting nonscalar to the same type"); 351418334Speter } 351518334Speter } 351618334Speter else if (TREE_CODE (type) == UNION_TYPE) 351718334Speter { 351818334Speter tree field; 351918334Speter 352018334Speter for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 352118334Speter if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)), 3522169689Skan TYPE_MAIN_VARIANT (TREE_TYPE (value)))) 352318334Speter break; 352418334Speter 352518334Speter if (field) 352618334Speter { 352718334Speter tree t; 352818334Speter 352918334Speter if (pedantic) 353090075Sobrien pedwarn ("ISO C forbids casts to union type"); 3531132718Skan t = digest_init (type, 3532169689Skan build_constructor_single (type, field, value), 3533169689Skan true, 0); 353418334Speter TREE_CONSTANT (t) = TREE_CONSTANT (value); 3535169689Skan TREE_INVARIANT (t) = TREE_INVARIANT (value); 353618334Speter return t; 353718334Speter } 353818334Speter error ("cast to union type from type not present in union"); 353918334Speter return error_mark_node; 354018334Speter } 354118334Speter else 354218334Speter { 354318334Speter tree otype, ovalue; 354418334Speter 354518334Speter if (type == void_type_node) 354618334Speter return build1 (CONVERT_EXPR, type, value); 354718334Speter 354818334Speter otype = TREE_TYPE (value); 354918334Speter 355018334Speter /* Optionally warn about potentially worrisome casts. */ 355118334Speter 355218334Speter if (warn_cast_qual 355318334Speter && TREE_CODE (type) == POINTER_TYPE 355418334Speter && TREE_CODE (otype) == POINTER_TYPE) 355518334Speter { 355650397Sobrien tree in_type = type; 355750397Sobrien tree in_otype = otype; 355896263Sobrien int added = 0; 355996263Sobrien int discarded = 0; 356050397Sobrien 356190075Sobrien /* Check that the qualifiers on IN_TYPE are a superset of 356290075Sobrien the qualifiers of IN_OTYPE. The outermost level of 356390075Sobrien POINTER_TYPE nodes is uninteresting and we stop as soon 356490075Sobrien as we hit a non-POINTER_TYPE node on either type. */ 356590075Sobrien do 356690075Sobrien { 356790075Sobrien in_otype = TREE_TYPE (in_otype); 356890075Sobrien in_type = TREE_TYPE (in_type); 356996263Sobrien 357096263Sobrien /* GNU C allows cv-qualified function types. 'const' 357196263Sobrien means the function is very pure, 'volatile' means it 357296263Sobrien can't return. We need to warn when such qualifiers 357396263Sobrien are added, not when they're taken away. */ 357496263Sobrien if (TREE_CODE (in_otype) == FUNCTION_TYPE 357596263Sobrien && TREE_CODE (in_type) == FUNCTION_TYPE) 357696263Sobrien added |= (TYPE_QUALS (in_type) & ~TYPE_QUALS (in_otype)); 357796263Sobrien else 357896263Sobrien discarded |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type)); 357990075Sobrien } 358090075Sobrien while (TREE_CODE (in_type) == POINTER_TYPE 358190075Sobrien && TREE_CODE (in_otype) == POINTER_TYPE); 358290075Sobrien 358396263Sobrien if (added) 3584169689Skan warning (0, "cast adds new qualifiers to function type"); 358596263Sobrien 358696263Sobrien if (discarded) 358752284Sobrien /* There are qualifiers present in IN_OTYPE that are not 358852284Sobrien present in IN_TYPE. */ 3589169689Skan warning (0, "cast discards qualifiers from pointer target type"); 359018334Speter } 359118334Speter 359218334Speter /* Warn about possible alignment problems. */ 3593169689Skan if (STRICT_ALIGNMENT 359418334Speter && TREE_CODE (type) == POINTER_TYPE 359518334Speter && TREE_CODE (otype) == POINTER_TYPE 359618334Speter && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE 359718334Speter && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE 359850397Sobrien /* Don't warn about opaque types, where the actual alignment 359950397Sobrien restriction is unknown. */ 360050397Sobrien && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE 360150397Sobrien || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE) 360250397Sobrien && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode) 360318334Speter && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype))) 3604169689Skan warning (OPT_Wcast_align, 3605169689Skan "cast increases required alignment of target type"); 360618334Speter 360718334Speter if (TREE_CODE (type) == INTEGER_TYPE 360818334Speter && TREE_CODE (otype) == POINTER_TYPE 3609169689Skan && TYPE_PRECISION (type) != TYPE_PRECISION (otype)) 3610169689Skan /* Unlike conversion of integers to pointers, where the 3611169689Skan warning is disabled for converting constants because 3612169689Skan of cases such as SIG_*, warn about converting constant 3613169689Skan pointers to integers. In some cases it may cause unwanted 3614169689Skan sign extension, and a warning is appropriate. */ 3615169689Skan warning (OPT_Wpointer_to_int_cast, 3616169689Skan "cast from pointer to integer of different size"); 361718334Speter 3618169689Skan if (TREE_CODE (value) == CALL_EXPR 361918334Speter && TREE_CODE (type) != TREE_CODE (otype)) 3620169689Skan warning (OPT_Wbad_function_cast, "cast from function call of type %qT " 3621169689Skan "to non-matching type %qT", otype, type); 362218334Speter 362318334Speter if (TREE_CODE (type) == POINTER_TYPE 362418334Speter && TREE_CODE (otype) == INTEGER_TYPE 362518334Speter && TYPE_PRECISION (type) != TYPE_PRECISION (otype) 362618334Speter /* Don't warn about converting any constant. */ 362718334Speter && !TREE_CONSTANT (value)) 3628169689Skan warning (OPT_Wint_to_pointer_cast, "cast to pointer from integer " 3629169689Skan "of different size"); 363018334Speter 3631169689Skan strict_aliasing_warning (otype, type, expr); 3632132718Skan 3633132718Skan /* If pedantic, warn for conversions between function and object 3634132718Skan pointer types, except for converting a null pointer constant 3635132718Skan to function pointer type. */ 3636132718Skan if (pedantic 3637132718Skan && TREE_CODE (type) == POINTER_TYPE 3638132718Skan && TREE_CODE (otype) == POINTER_TYPE 3639132718Skan && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE 3640132718Skan && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE) 3641132718Skan pedwarn ("ISO C forbids conversion of function pointer to object pointer type"); 3642132718Skan 3643132718Skan if (pedantic 3644132718Skan && TREE_CODE (type) == POINTER_TYPE 3645132718Skan && TREE_CODE (otype) == POINTER_TYPE 3646132718Skan && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE 3647132718Skan && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE 3648169689Skan && !null_pointer_constant_p (value)) 3649132718Skan pedwarn ("ISO C forbids conversion of object pointer to function pointer type"); 3650132718Skan 365118334Speter ovalue = value; 365218334Speter value = convert (type, value); 365318334Speter 365418334Speter /* Ignore any integer overflow caused by the cast. */ 365518334Speter if (TREE_CODE (value) == INTEGER_CST) 365618334Speter { 3657169689Skan if (CONSTANT_CLASS_P (ovalue) 3658169689Skan && (TREE_OVERFLOW (ovalue) || TREE_CONSTANT_OVERFLOW (ovalue))) 3659169689Skan { 3660169689Skan /* Avoid clobbering a shared constant. */ 3661169689Skan value = copy_node (value); 3662169689Skan TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue); 3663169689Skan TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue); 3664169689Skan } 3665169689Skan else if (TREE_OVERFLOW (value) || TREE_CONSTANT_OVERFLOW (value)) 3666169689Skan /* Reset VALUE's overflow flags, ensuring constant sharing. */ 3667169689Skan value = build_int_cst_wide (TREE_TYPE (value), 3668169689Skan TREE_INT_CST_LOW (value), 3669169689Skan TREE_INT_CST_HIGH (value)); 367018334Speter } 367118334Speter } 367218334Speter 3673169689Skan /* Don't let a cast be an lvalue. */ 3674169689Skan if (value == expr) 367518334Speter value = non_lvalue (value); 367618334Speter 367718334Speter return value; 367818334Speter} 367990075Sobrien 368090075Sobrien/* Interpret a cast of expression EXPR to type TYPE. */ 368190075Sobrientree 3682169689Skanc_cast_expr (struct c_type_name *type_name, tree expr) 368390075Sobrien{ 3684169689Skan tree type; 368590075Sobrien int saved_wsp = warn_strict_prototypes; 368690075Sobrien 368790075Sobrien /* This avoids warnings about unprototyped casts on 368890075Sobrien integers. E.g. "#define SIG_DFL (void(*)())0". */ 368990075Sobrien if (TREE_CODE (expr) == INTEGER_CST) 369090075Sobrien warn_strict_prototypes = 0; 3691169689Skan type = groktypename (type_name); 369290075Sobrien warn_strict_prototypes = saved_wsp; 369390075Sobrien 369490075Sobrien return build_c_cast (type, expr); 369590075Sobrien} 369618334Speter 369718334Speter/* Build an assignment expression of lvalue LHS from value RHS. 369818334Speter MODIFYCODE is the code for a binary operator that we use 369918334Speter to combine the old value of LHS with RHS to get the new value. 370018334Speter Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. */ 370118334Speter 370218334Spetertree 3703132718Skanbuild_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) 370418334Speter{ 370590075Sobrien tree result; 370618334Speter tree newrhs; 370718334Speter tree lhstype = TREE_TYPE (lhs); 370818334Speter tree olhstype = lhstype; 370918334Speter 371018334Speter /* Types that aren't fully specified cannot be used in assignments. */ 371118334Speter lhs = require_complete_type (lhs); 371218334Speter 371318334Speter /* Avoid duplicate error messages from operands that had errors. */ 371418334Speter if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK) 371518334Speter return error_mark_node; 371618334Speter 3717169689Skan if (!lvalue_or_else (lhs, lv_assign)) 3718169689Skan return error_mark_node; 371918334Speter 3720169689Skan STRIP_TYPE_NOPS (rhs); 3721169689Skan 372218334Speter newrhs = rhs; 372318334Speter 372418334Speter /* If a binary op has been requested, combine the old LHS value with the RHS 372518334Speter producing the value we should actually store into the LHS. */ 372618334Speter 372718334Speter if (modifycode != NOP_EXPR) 372818334Speter { 372918334Speter lhs = stabilize_reference (lhs); 373018334Speter newrhs = build_binary_op (modifycode, lhs, rhs, 1); 373118334Speter } 373218334Speter 3733169689Skan /* Give an error for storing in something that is 'const'. */ 373418334Speter 373518334Speter if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype) 373618334Speter || ((TREE_CODE (lhstype) == RECORD_TYPE 373718334Speter || TREE_CODE (lhstype) == UNION_TYPE) 373818334Speter && C_TYPE_FIELDS_READONLY (lhstype))) 3739169689Skan { 3740169689Skan readonly_error (lhs, lv_assign); 3741169689Skan return error_mark_node; 3742169689Skan } 374318334Speter 374418334Speter /* If storing into a structure or union member, 374518334Speter it has probably been given type `int'. 374618334Speter Compute the type that would go with 374718334Speter the actual amount of storage the member occupies. */ 374818334Speter 374918334Speter if (TREE_CODE (lhs) == COMPONENT_REF 375018334Speter && (TREE_CODE (lhstype) == INTEGER_TYPE 375190075Sobrien || TREE_CODE (lhstype) == BOOLEAN_TYPE 375218334Speter || TREE_CODE (lhstype) == REAL_TYPE 375318334Speter || TREE_CODE (lhstype) == ENUMERAL_TYPE)) 375418334Speter lhstype = TREE_TYPE (get_unwidened (lhs, 0)); 375518334Speter 375618334Speter /* If storing in a field that is in actuality a short or narrower than one, 375718334Speter we must store in the field in its actual type. */ 375818334Speter 375918334Speter if (lhstype != TREE_TYPE (lhs)) 376018334Speter { 376118334Speter lhs = copy_node (lhs); 376218334Speter TREE_TYPE (lhs) = lhstype; 376318334Speter } 376418334Speter 376518334Speter /* Convert new value to destination type. */ 376618334Speter 3767169689Skan newrhs = convert_for_assignment (lhstype, newrhs, ic_assign, 376818334Speter NULL_TREE, NULL_TREE, 0); 376918334Speter if (TREE_CODE (newrhs) == ERROR_MARK) 377018334Speter return error_mark_node; 377118334Speter 3772169689Skan /* Emit ObjC write barrier, if necessary. */ 3773169689Skan if (c_dialect_objc () && flag_objc_gc) 3774169689Skan { 3775169689Skan result = objc_generate_write_barrier (lhs, modifycode, newrhs); 3776169689Skan if (result) 3777169689Skan return result; 3778169689Skan } 377990075Sobrien 3780169689Skan /* Scan operands. */ 3781169689Skan 3782169689Skan result = build2 (MODIFY_EXPR, lhstype, lhs, newrhs); 378318334Speter TREE_SIDE_EFFECTS (result) = 1; 378418334Speter 378518334Speter /* If we got the LHS in a different type for storing in, 378618334Speter convert the result back to the nominal type of LHS 378718334Speter so that the value we return always has the same type 378818334Speter as the LHS argument. */ 378918334Speter 379018334Speter if (olhstype == TREE_TYPE (result)) 379118334Speter return result; 3792169689Skan return convert_for_assignment (olhstype, result, ic_assign, 379318334Speter NULL_TREE, NULL_TREE, 0); 379418334Speter} 379518334Speter 379618334Speter/* Convert value RHS to type TYPE as preparation for an assignment 379718334Speter to an lvalue of type TYPE. 379818334Speter The real work of conversion is done by `convert'. 379918334Speter The purpose of this function is to generate error messages 380018334Speter for assignments that are not allowed in C. 3801169689Skan ERRTYPE says whether it is argument passing, assignment, 3802169689Skan initialization or return. 380318334Speter 3804169689Skan FUNCTION is a tree for the function being called. 380518334Speter PARMNUM is the number of the argument, for printing in error messages. */ 380618334Speter 380718334Speterstatic tree 3808169689Skanconvert_for_assignment (tree type, tree rhs, enum impl_conv errtype, 3809169689Skan tree fundecl, tree function, int parmnum) 381018334Speter{ 381190075Sobrien enum tree_code codel = TREE_CODE (type); 381290075Sobrien tree rhstype; 381390075Sobrien enum tree_code coder; 3814169689Skan tree rname = NULL_TREE; 3815169689Skan bool objc_ok = false; 381618334Speter 3817169689Skan if (errtype == ic_argpass || errtype == ic_argpass_nonproto) 3818169689Skan { 3819169689Skan tree selector; 3820169689Skan /* Change pointer to function to the function itself for 3821169689Skan diagnostics. */ 3822169689Skan if (TREE_CODE (function) == ADDR_EXPR 3823169689Skan && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL) 3824169689Skan function = TREE_OPERAND (function, 0); 382518334Speter 3826169689Skan /* Handle an ObjC selector specially for diagnostics. */ 3827169689Skan selector = objc_message_selector (); 3828169689Skan rname = function; 3829169689Skan if (selector && parmnum > 2) 3830169689Skan { 3831169689Skan rname = selector; 3832169689Skan parmnum -= 2; 3833169689Skan } 3834169689Skan } 3835169689Skan 3836169689Skan /* This macro is used to emit diagnostics to ensure that all format 3837169689Skan strings are complete sentences, visible to gettext and checked at 3838169689Skan compile time. */ 3839169689Skan#define WARN_FOR_ASSIGNMENT(AR, AS, IN, RE) \ 3840169689Skan do { \ 3841169689Skan switch (errtype) \ 3842169689Skan { \ 3843169689Skan case ic_argpass: \ 3844169689Skan pedwarn (AR, parmnum, rname); \ 3845169689Skan break; \ 3846169689Skan case ic_argpass_nonproto: \ 3847169689Skan warning (0, AR, parmnum, rname); \ 3848169689Skan break; \ 3849169689Skan case ic_assign: \ 3850169689Skan pedwarn (AS); \ 3851169689Skan break; \ 3852169689Skan case ic_init: \ 3853169689Skan pedwarn (IN); \ 3854169689Skan break; \ 3855169689Skan case ic_return: \ 3856169689Skan pedwarn (RE); \ 3857169689Skan break; \ 3858169689Skan default: \ 3859169689Skan gcc_unreachable (); \ 3860169689Skan } \ 3861169689Skan } while (0) 3862169689Skan 3863169689Skan STRIP_TYPE_NOPS (rhs); 3864169689Skan 3865169689Skan if (optimize && TREE_CODE (rhs) == VAR_DECL 3866169689Skan && TREE_CODE (TREE_TYPE (rhs)) != ARRAY_TYPE) 386790075Sobrien rhs = decl_constant_value_for_broken_optimization (rhs); 386818334Speter 386918334Speter rhstype = TREE_TYPE (rhs); 387018334Speter coder = TREE_CODE (rhstype); 387118334Speter 387218334Speter if (coder == ERROR_MARK) 387318334Speter return error_mark_node; 387418334Speter 3875169689Skan if (c_dialect_objc ()) 3876169689Skan { 3877169689Skan int parmno; 3878169689Skan 3879169689Skan switch (errtype) 3880169689Skan { 3881169689Skan case ic_return: 3882169689Skan parmno = 0; 3883169689Skan break; 3884169689Skan 3885169689Skan case ic_assign: 3886169689Skan parmno = -1; 3887169689Skan break; 3888169689Skan 3889169689Skan case ic_init: 3890169689Skan parmno = -2; 3891169689Skan break; 3892169689Skan 3893169689Skan default: 3894169689Skan parmno = parmnum; 3895169689Skan break; 3896169689Skan } 3897169689Skan 3898169689Skan objc_ok = objc_compare_types (type, rhstype, parmno, rname); 3899169689Skan } 3900169689Skan 390118334Speter if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype)) 390218334Speter { 390318334Speter overflow_warning (rhs); 390418334Speter return rhs; 390518334Speter } 390618334Speter 390718334Speter if (coder == VOID_TYPE) 390818334Speter { 3909169689Skan /* Except for passing an argument to an unprototyped function, 3910169689Skan this is a constraint violation. When passing an argument to 3911169689Skan an unprototyped function, it is compile-time undefined; 3912169689Skan making it a constraint in that case was rejected in 3913169689Skan DR#252. */ 391418334Speter error ("void value not ignored as it ought to be"); 391518334Speter return error_mark_node; 391618334Speter } 3917132718Skan /* A type converts to a reference to it. 391890075Sobrien This code doesn't fully support references, it's just for the 391990075Sobrien special case of va_start and va_copy. */ 392090075Sobrien if (codel == REFERENCE_TYPE 3921169689Skan && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1) 392290075Sobrien { 3923117395Skan if (!lvalue_p (rhs)) 3924117395Skan { 3925117395Skan error ("cannot pass rvalue to reference parameter"); 3926117395Skan return error_mark_node; 3927117395Skan } 3928117395Skan if (!c_mark_addressable (rhs)) 392990075Sobrien return error_mark_node; 393090075Sobrien rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs); 393190075Sobrien 393290075Sobrien /* We already know that these two types are compatible, but they 393390075Sobrien may not be exactly identical. In fact, `TREE_TYPE (type)' is 393490075Sobrien likely to be __builtin_va_list and `TREE_TYPE (rhs)' is 393590075Sobrien likely to be va_list, a typedef to __builtin_va_list, which 393690075Sobrien is different enough that it will cause problems later. */ 393790075Sobrien if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type)) 393890075Sobrien rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs); 393990075Sobrien 394090075Sobrien rhs = build1 (NOP_EXPR, type, rhs); 394190075Sobrien return rhs; 394290075Sobrien } 3943132718Skan /* Some types can interconvert without explicit casts. */ 3944132718Skan else if (codel == VECTOR_TYPE && coder == VECTOR_TYPE 3945169689Skan && vector_types_convertible_p (type, TREE_TYPE (rhs))) 3946132718Skan return convert (type, rhs); 394718334Speter /* Arithmetic types all interconvert, and enum is treated like int. */ 3948132718Skan else if ((codel == INTEGER_TYPE || codel == REAL_TYPE 394990075Sobrien || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE 395090075Sobrien || codel == BOOLEAN_TYPE) 3951117395Skan && (coder == INTEGER_TYPE || coder == REAL_TYPE 395290075Sobrien || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE 395390075Sobrien || coder == BOOLEAN_TYPE)) 395418334Speter return convert_and_check (type, rhs); 395518334Speter 3956169689Skan /* Aggregates in different TUs might need conversion. */ 3957169689Skan if ((codel == RECORD_TYPE || codel == UNION_TYPE) 3958169689Skan && codel == coder 3959169689Skan && comptypes (type, rhstype)) 3960169689Skan return convert_and_check (type, rhs); 3961169689Skan 396250397Sobrien /* Conversion to a transparent union from its member types. 396350397Sobrien This applies only to function arguments. */ 3964169689Skan if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) 3965169689Skan && (errtype == ic_argpass || errtype == ic_argpass_nonproto)) 396618334Speter { 3967169689Skan tree memb, marginal_memb = NULL_TREE; 396818334Speter 3969169689Skan for (memb = TYPE_FIELDS (type); memb ; memb = TREE_CHAIN (memb)) 397018334Speter { 3971169689Skan tree memb_type = TREE_TYPE (memb); 397218334Speter 397350397Sobrien if (comptypes (TYPE_MAIN_VARIANT (memb_type), 3974169689Skan TYPE_MAIN_VARIANT (rhstype))) 397550397Sobrien break; 397650397Sobrien 397750397Sobrien if (TREE_CODE (memb_type) != POINTER_TYPE) 397850397Sobrien continue; 397950397Sobrien 398050397Sobrien if (coder == POINTER_TYPE) 398118334Speter { 398290075Sobrien tree ttl = TREE_TYPE (memb_type); 398390075Sobrien tree ttr = TREE_TYPE (rhstype); 398418334Speter 398518334Speter /* Any non-function converts to a [const][volatile] void * 398618334Speter and vice versa; otherwise, targets must be the same. 398718334Speter Meanwhile, the lhs target must have all the qualifiers of 398818334Speter the rhs. */ 398990075Sobrien if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr) 3990169689Skan || comp_target_types (memb_type, rhstype)) 399118334Speter { 399250397Sobrien /* If this type won't generate any warnings, use it. */ 399352284Sobrien if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr) 399452284Sobrien || ((TREE_CODE (ttr) == FUNCTION_TYPE 399552284Sobrien && TREE_CODE (ttl) == FUNCTION_TYPE) 399652284Sobrien ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr)) 399752284Sobrien == TYPE_QUALS (ttr)) 399852284Sobrien : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr)) 399952284Sobrien == TYPE_QUALS (ttl)))) 400050397Sobrien break; 400118334Speter 400250397Sobrien /* Keep looking for a better type, but remember this one. */ 4003169689Skan if (!marginal_memb) 4004169689Skan marginal_memb = memb; 400518334Speter } 400618334Speter } 400718334Speter 400818334Speter /* Can convert integer zero to any pointer type. */ 4009169689Skan if (null_pointer_constant_p (rhs)) 401050397Sobrien { 401150397Sobrien rhs = null_pointer_node; 401250397Sobrien break; 401350397Sobrien } 401418334Speter } 401550397Sobrien 4016169689Skan if (memb || marginal_memb) 401750397Sobrien { 4018169689Skan if (!memb) 401950397Sobrien { 402050397Sobrien /* We have only a marginally acceptable member type; 402150397Sobrien it needs a warning. */ 4022169689Skan tree ttl = TREE_TYPE (TREE_TYPE (marginal_memb)); 402390075Sobrien tree ttr = TREE_TYPE (rhstype); 402450397Sobrien 402550397Sobrien /* Const and volatile mean something different for function 402650397Sobrien types, so the usual warnings are not appropriate. */ 402750397Sobrien if (TREE_CODE (ttr) == FUNCTION_TYPE 402850397Sobrien && TREE_CODE (ttl) == FUNCTION_TYPE) 402950397Sobrien { 403050397Sobrien /* Because const and volatile on functions are 403150397Sobrien restrictions that say the function will not do 403250397Sobrien certain things, it is okay to use a const or volatile 403350397Sobrien function where an ordinary one is wanted, but not 403450397Sobrien vice-versa. */ 403552284Sobrien if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr)) 4036169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE " 4037169689Skan "makes qualified function " 4038169689Skan "pointer from unqualified"), 4039169689Skan G_("assignment makes qualified " 4040169689Skan "function pointer from " 4041169689Skan "unqualified"), 4042169689Skan G_("initialization makes qualified " 4043169689Skan "function pointer from " 4044169689Skan "unqualified"), 4045169689Skan G_("return makes qualified function " 4046169689Skan "pointer from unqualified")); 404750397Sobrien } 404852284Sobrien else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl)) 4049169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE discards " 4050169689Skan "qualifiers from pointer target type"), 4051169689Skan G_("assignment discards qualifiers " 4052169689Skan "from pointer target type"), 4053169689Skan G_("initialization discards qualifiers " 4054169689Skan "from pointer target type"), 4055169689Skan G_("return discards qualifiers from " 4056169689Skan "pointer target type")); 4057169689Skan 4058169689Skan memb = marginal_memb; 405950397Sobrien } 4060132718Skan 4061169689Skan if (pedantic && (!fundecl || !DECL_IN_SYSTEM_HEADER (fundecl))) 406290075Sobrien pedwarn ("ISO C prohibits argument conversion to union type"); 406350397Sobrien 4064169689Skan return build_constructor_single (type, memb, rhs); 406550397Sobrien } 406618334Speter } 406718334Speter 406818334Speter /* Conversions among pointers */ 406990075Sobrien else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE) 4070117395Skan && (coder == codel)) 407118334Speter { 407290075Sobrien tree ttl = TREE_TYPE (type); 407390075Sobrien tree ttr = TREE_TYPE (rhstype); 4074169689Skan tree mvl = ttl; 4075169689Skan tree mvr = ttr; 4076132718Skan bool is_opaque_pointer; 4077132718Skan int target_cmp = 0; /* Cache comp_target_types () result. */ 407818334Speter 4079169689Skan if (TREE_CODE (mvl) != ARRAY_TYPE) 4080169689Skan mvl = TYPE_MAIN_VARIANT (mvl); 4081169689Skan if (TREE_CODE (mvr) != ARRAY_TYPE) 4082169689Skan mvr = TYPE_MAIN_VARIANT (mvr); 4083132718Skan /* Opaque pointers are treated like void pointers. */ 4084169689Skan is_opaque_pointer = (targetm.vector_opaque_p (type) 4085169689Skan || targetm.vector_opaque_p (rhstype)) 4086169689Skan && TREE_CODE (ttl) == VECTOR_TYPE 4087169689Skan && TREE_CODE (ttr) == VECTOR_TYPE; 4088132718Skan 4089169689Skan /* C++ does not allow the implicit conversion void* -> T*. However, 4090169689Skan for the purpose of reducing the number of false positives, we 4091169689Skan tolerate the special case of 4092169689Skan 4093169689Skan int *p = NULL; 4094169689Skan 4095169689Skan where NULL is typically defined in C to be '(void *) 0'. */ 4096169689Skan if (VOID_TYPE_P (ttr) && rhs != null_pointer_node && !VOID_TYPE_P (ttl)) 4097169689Skan warning (OPT_Wc___compat, "request for implicit conversion from " 4098169689Skan "%qT to %qT not permitted in C++", rhstype, type); 4099169689Skan 4100169689Skan /* Check if the right-hand side has a format attribute but the 4101169689Skan left-hand side doesn't. */ 4102169689Skan if (warn_missing_format_attribute 4103169689Skan && check_missing_format_attribute (type, rhstype)) 4104169689Skan { 4105169689Skan switch (errtype) 4106169689Skan { 4107169689Skan case ic_argpass: 4108169689Skan case ic_argpass_nonproto: 4109169689Skan warning (OPT_Wmissing_format_attribute, 4110169689Skan "argument %d of %qE might be " 4111169689Skan "a candidate for a format attribute", 4112169689Skan parmnum, rname); 4113169689Skan break; 4114169689Skan case ic_assign: 4115169689Skan warning (OPT_Wmissing_format_attribute, 4116169689Skan "assignment left-hand side might be " 4117169689Skan "a candidate for a format attribute"); 4118169689Skan break; 4119169689Skan case ic_init: 4120169689Skan warning (OPT_Wmissing_format_attribute, 4121169689Skan "initialization left-hand side might be " 4122169689Skan "a candidate for a format attribute"); 4123169689Skan break; 4124169689Skan case ic_return: 4125169689Skan warning (OPT_Wmissing_format_attribute, 4126169689Skan "return type might be " 4127169689Skan "a candidate for a format attribute"); 4128169689Skan break; 4129169689Skan default: 4130169689Skan gcc_unreachable (); 4131169689Skan } 4132169689Skan } 4133169689Skan 413418334Speter /* Any non-function converts to a [const][volatile] void * 413518334Speter and vice versa; otherwise, targets must be the same. 413618334Speter Meanwhile, the lhs target must have all the qualifiers of the rhs. */ 413790075Sobrien if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr) 4138169689Skan || (target_cmp = comp_target_types (type, rhstype)) 4139132718Skan || is_opaque_pointer 4140169689Skan || (c_common_unsigned_type (mvl) 4141169689Skan == c_common_unsigned_type (mvr))) 414218334Speter { 414318334Speter if (pedantic 414490075Sobrien && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE) 414518334Speter || 414690075Sobrien (VOID_TYPE_P (ttr) 4147169689Skan && !null_pointer_constant_p (rhs) 414818334Speter && TREE_CODE (ttl) == FUNCTION_TYPE))) 4149169689Skan WARN_FOR_ASSIGNMENT (G_("ISO C forbids passing argument %d of " 4150169689Skan "%qE between function pointer " 4151169689Skan "and %<void *%>"), 4152169689Skan G_("ISO C forbids assignment between " 4153169689Skan "function pointer and %<void *%>"), 4154169689Skan G_("ISO C forbids initialization between " 4155169689Skan "function pointer and %<void *%>"), 4156169689Skan G_("ISO C forbids return between function " 4157169689Skan "pointer and %<void *%>")); 415818334Speter /* Const and volatile mean something different for function types, 415918334Speter so the usual warnings are not appropriate. */ 416018334Speter else if (TREE_CODE (ttr) != FUNCTION_TYPE 416118334Speter && TREE_CODE (ttl) != FUNCTION_TYPE) 416218334Speter { 416352284Sobrien if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl)) 4164169689Skan { 4165169689Skan /* Types differing only by the presence of the 'volatile' 4166169689Skan qualifier are acceptable if the 'volatile' has been added 4167169689Skan in by the Objective-C EH machinery. */ 4168169689Skan if (!objc_type_quals_match (ttl, ttr)) 4169169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE discards " 4170169689Skan "qualifiers from pointer target type"), 4171169689Skan G_("assignment discards qualifiers " 4172169689Skan "from pointer target type"), 4173169689Skan G_("initialization discards qualifiers " 4174169689Skan "from pointer target type"), 4175169689Skan G_("return discards qualifiers from " 4176169689Skan "pointer target type")); 4177169689Skan } 417818334Speter /* If this is not a case of ignoring a mismatch in signedness, 417918334Speter no warning. */ 418090075Sobrien else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr) 4181132718Skan || target_cmp) 418218334Speter ; 418318334Speter /* If there is a mismatch, do warn. */ 4184169689Skan else if (warn_pointer_sign) 4185169689Skan WARN_FOR_ASSIGNMENT (G_("pointer targets in passing argument " 4186169689Skan "%d of %qE differ in signedness"), 4187169689Skan G_("pointer targets in assignment " 4188169689Skan "differ in signedness"), 4189169689Skan G_("pointer targets in initialization " 4190169689Skan "differ in signedness"), 4191169689Skan G_("pointer targets in return differ " 4192169689Skan "in signedness")); 419318334Speter } 419418334Speter else if (TREE_CODE (ttl) == FUNCTION_TYPE 419518334Speter && TREE_CODE (ttr) == FUNCTION_TYPE) 419618334Speter { 419718334Speter /* Because const and volatile on functions are restrictions 419818334Speter that say the function will not do certain things, 419918334Speter it is okay to use a const or volatile function 420018334Speter where an ordinary one is wanted, but not vice-versa. */ 420152284Sobrien if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr)) 4202169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes " 4203169689Skan "qualified function pointer " 4204169689Skan "from unqualified"), 4205169689Skan G_("assignment makes qualified function " 4206169689Skan "pointer from unqualified"), 4207169689Skan G_("initialization makes qualified " 4208169689Skan "function pointer from unqualified"), 4209169689Skan G_("return makes qualified function " 4210169689Skan "pointer from unqualified")); 421118334Speter } 421218334Speter } 421318334Speter else 4214169689Skan /* Avoid warning about the volatile ObjC EH puts on decls. */ 4215169689Skan if (!objc_ok) 4216169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE from " 4217169689Skan "incompatible pointer type"), 4218169689Skan G_("assignment from incompatible pointer type"), 4219169689Skan G_("initialization from incompatible " 4220169689Skan "pointer type"), 4221169689Skan G_("return from incompatible pointer type")); 4222169689Skan 422318334Speter return convert (type, rhs); 422418334Speter } 4225122180Skan else if (codel == POINTER_TYPE && coder == ARRAY_TYPE) 4226122180Skan { 4227169689Skan /* ??? This should not be an error when inlining calls to 4228169689Skan unprototyped functions. */ 4229122180Skan error ("invalid use of non-lvalue array"); 4230122180Skan return error_mark_node; 4231122180Skan } 423218334Speter else if (codel == POINTER_TYPE && coder == INTEGER_TYPE) 423318334Speter { 423418334Speter /* An explicit constant 0 can convert to a pointer, 423518334Speter or one that results from arithmetic, even including 423618334Speter a cast to integer type. */ 4237169689Skan if (!null_pointer_constant_p (rhs)) 4238169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes " 4239169689Skan "pointer from integer without a cast"), 4240169689Skan G_("assignment makes pointer from integer " 4241169689Skan "without a cast"), 4242169689Skan G_("initialization makes pointer from " 4243169689Skan "integer without a cast"), 4244169689Skan G_("return makes pointer from integer " 4245169689Skan "without a cast")); 4246132718Skan 4247132718Skan return convert (type, rhs); 424818334Speter } 424918334Speter else if (codel == INTEGER_TYPE && coder == POINTER_TYPE) 425018334Speter { 4251169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes integer " 4252169689Skan "from pointer without a cast"), 4253169689Skan G_("assignment makes integer from pointer " 4254169689Skan "without a cast"), 4255169689Skan G_("initialization makes integer from pointer " 4256169689Skan "without a cast"), 4257169689Skan G_("return makes integer from pointer " 4258169689Skan "without a cast")); 425918334Speter return convert (type, rhs); 426018334Speter } 426190075Sobrien else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE) 426290075Sobrien return convert (type, rhs); 426318334Speter 4264169689Skan switch (errtype) 426518334Speter { 4266169689Skan case ic_argpass: 4267169689Skan case ic_argpass_nonproto: 4268169689Skan /* ??? This should not be an error when inlining calls to 4269169689Skan unprototyped functions. */ 4270169689Skan error ("incompatible type for argument %d of %qE", parmnum, rname); 4271169689Skan break; 4272169689Skan case ic_assign: 4273169689Skan error ("incompatible types in assignment"); 4274169689Skan break; 4275169689Skan case ic_init: 4276169689Skan error ("incompatible types in initialization"); 4277169689Skan break; 4278169689Skan case ic_return: 4279169689Skan error ("incompatible types in return"); 4280169689Skan break; 4281169689Skan default: 4282169689Skan gcc_unreachable (); 428318334Speter } 428418334Speter 428518334Speter return error_mark_node; 428618334Speter} 428718334Speter 4288132718Skan/* Convert VALUE for assignment into inlined parameter PARM. ARGNUM 4289169689Skan is used for error and warning reporting and indicates which argument 4290132718Skan is being processed. */ 429196263Sobrien 429296263Sobrientree 4293132718Skanc_convert_parm_for_inlining (tree parm, tree value, tree fn, int argnum) 429496263Sobrien{ 429596263Sobrien tree ret, type; 429696263Sobrien 4297169689Skan /* If FN was prototyped at the call site, the value has been converted 4298169689Skan already in convert_arguments. 4299169689Skan However, we might see a prototype now that was not in place when 4300169689Skan the function call was seen, so check that the VALUE actually matches 4301169689Skan PARM before taking an early exit. */ 4302169689Skan if (!value 4303169689Skan || (TYPE_ARG_TYPES (TREE_TYPE (fn)) 4304169689Skan && (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) 4305169689Skan == TYPE_MAIN_VARIANT (TREE_TYPE (value))))) 430696263Sobrien return value; 430796263Sobrien 430896263Sobrien type = TREE_TYPE (parm); 4309132718Skan ret = convert_for_assignment (type, value, 4310169689Skan ic_argpass_nonproto, fn, 4311169689Skan fn, argnum); 4312132718Skan if (targetm.calls.promote_prototypes (TREE_TYPE (fn)) 431396263Sobrien && INTEGRAL_TYPE_P (type) 431496263Sobrien && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))) 431596263Sobrien ret = default_conversion (ret); 431696263Sobrien return ret; 431796263Sobrien} 431818334Speter 431918334Speter/* If VALUE is a compound expr all of whose expressions are constant, then 432018334Speter return its value. Otherwise, return error_mark_node. 432118334Speter 432218334Speter This is for handling COMPOUND_EXPRs as initializer elements 432318334Speter which is allowed with a warning when -pedantic is specified. */ 432418334Speter 432518334Speterstatic tree 4326132718Skanvalid_compound_expr_initializer (tree value, tree endtype) 432718334Speter{ 432818334Speter if (TREE_CODE (value) == COMPOUND_EXPR) 432918334Speter { 433018334Speter if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype) 433118334Speter == error_mark_node) 433218334Speter return error_mark_node; 433318334Speter return valid_compound_expr_initializer (TREE_OPERAND (value, 1), 433418334Speter endtype); 433518334Speter } 4336169689Skan else if (!initializer_constant_valid_p (value, endtype)) 433718334Speter return error_mark_node; 433818334Speter else 433918334Speter return value; 434018334Speter} 434118334Speter 434218334Speter/* Perform appropriate conversions on the initial value of a variable, 434318334Speter store it in the declaration DECL, 434418334Speter and print any error messages that are appropriate. 434518334Speter If the init is invalid, store an ERROR_MARK. */ 434618334Speter 434718334Spetervoid 4348132718Skanstore_init_value (tree decl, tree init) 434918334Speter{ 435090075Sobrien tree value, type; 435118334Speter 435218334Speter /* If variable's type was invalidly declared, just ignore it. */ 435318334Speter 435418334Speter type = TREE_TYPE (decl); 435518334Speter if (TREE_CODE (type) == ERROR_MARK) 435618334Speter return; 435718334Speter 435818334Speter /* Digest the specified initializer into an expression. */ 435918334Speter 4360169689Skan value = digest_init (type, init, true, TREE_STATIC (decl)); 436118334Speter 436218334Speter /* Store the expression if valid; else report error. */ 436318334Speter 4364169689Skan if (!in_system_header 4365169689Skan && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && !TREE_STATIC (decl)) 4366169689Skan warning (OPT_Wtraditional, "traditional C rejects automatic " 4367169689Skan "aggregate initialization"); 436890075Sobrien 436918334Speter DECL_INITIAL (decl) = value; 437018334Speter 437118334Speter /* ANSI wants warnings about out-of-range constant initializers. */ 437218334Speter STRIP_TYPE_NOPS (value); 437318334Speter constant_expression_warning (value); 437490075Sobrien 437590075Sobrien /* Check if we need to set array size from compound literal size. */ 437690075Sobrien if (TREE_CODE (type) == ARRAY_TYPE 437790075Sobrien && TYPE_DOMAIN (type) == 0 437890075Sobrien && value != error_mark_node) 437990075Sobrien { 438090075Sobrien tree inside_init = init; 438190075Sobrien 4382169689Skan STRIP_TYPE_NOPS (inside_init); 438390075Sobrien inside_init = fold (inside_init); 438490075Sobrien 438590075Sobrien if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR) 438690075Sobrien { 4387169689Skan tree cldecl = COMPOUND_LITERAL_EXPR_DECL (inside_init); 438890075Sobrien 4389169689Skan if (TYPE_DOMAIN (TREE_TYPE (cldecl))) 439090075Sobrien { 439190075Sobrien /* For int foo[] = (int [3]){1}; we need to set array size 439290075Sobrien now since later on array initializer will be just the 439390075Sobrien brace enclosed list of the compound literal. */ 4394169689Skan type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type)); 4395169689Skan TREE_TYPE (decl) = type; 4396169689Skan TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (cldecl)); 439790075Sobrien layout_type (type); 4398169689Skan layout_decl (cldecl, 0); 439990075Sobrien } 440090075Sobrien } 440190075Sobrien } 440218334Speter} 440318334Speter 440418334Speter/* Methods for storing and printing names for error messages. */ 440518334Speter 440618334Speter/* Implement a spelling stack that allows components of a name to be pushed 440718334Speter and popped. Each element on the stack is this structure. */ 440818334Speter 440918334Speterstruct spelling 441018334Speter{ 441118334Speter int kind; 441218334Speter union 441318334Speter { 4414169689Skan unsigned HOST_WIDE_INT i; 441552284Sobrien const char *s; 441618334Speter } u; 441718334Speter}; 441818334Speter 441918334Speter#define SPELLING_STRING 1 442018334Speter#define SPELLING_MEMBER 2 442118334Speter#define SPELLING_BOUNDS 3 442218334Speter 442318334Speterstatic struct spelling *spelling; /* Next stack element (unused). */ 442418334Speterstatic struct spelling *spelling_base; /* Spelling stack base. */ 442518334Speterstatic int spelling_size; /* Size of the spelling stack. */ 442618334Speter 442718334Speter/* Macros to save and restore the spelling stack around push_... functions. 442818334Speter Alternative to SAVE_SPELLING_STACK. */ 442918334Speter 443018334Speter#define SPELLING_DEPTH() (spelling - spelling_base) 443190075Sobrien#define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH)) 443218334Speter 443318334Speter/* Push an element on the spelling stack with type KIND and assign VALUE 443418334Speter to MEMBER. */ 443518334Speter 443618334Speter#define PUSH_SPELLING(KIND, VALUE, MEMBER) \ 443718334Speter{ \ 443818334Speter int depth = SPELLING_DEPTH (); \ 443918334Speter \ 444018334Speter if (depth >= spelling_size) \ 444118334Speter { \ 444218334Speter spelling_size += 10; \ 4443169689Skan spelling_base = XRESIZEVEC (struct spelling, spelling_base, \ 4444169689Skan spelling_size); \ 444518334Speter RESTORE_SPELLING_DEPTH (depth); \ 444618334Speter } \ 444718334Speter \ 444818334Speter spelling->kind = (KIND); \ 444918334Speter spelling->MEMBER = (VALUE); \ 445018334Speter spelling++; \ 445118334Speter} 445218334Speter 445318334Speter/* Push STRING on the stack. Printed literally. */ 445418334Speter 445518334Speterstatic void 4456132718Skanpush_string (const char *string) 445718334Speter{ 445818334Speter PUSH_SPELLING (SPELLING_STRING, string, u.s); 445918334Speter} 446018334Speter 446118334Speter/* Push a member name on the stack. Printed as '.' STRING. */ 446218334Speter 446318334Speterstatic void 4464132718Skanpush_member_name (tree decl) 446518334Speter{ 446690075Sobrien const char *const string 446718334Speter = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>"; 446818334Speter PUSH_SPELLING (SPELLING_MEMBER, string, u.s); 446918334Speter} 447018334Speter 447118334Speter/* Push an array bounds on the stack. Printed as [BOUNDS]. */ 447218334Speter 447318334Speterstatic void 4474169689Skanpush_array_bounds (unsigned HOST_WIDE_INT bounds) 447518334Speter{ 447618334Speter PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i); 447718334Speter} 447818334Speter 447918334Speter/* Compute the maximum size in bytes of the printed spelling. */ 448018334Speter 448118334Speterstatic int 4482132718Skanspelling_length (void) 448318334Speter{ 448490075Sobrien int size = 0; 448590075Sobrien struct spelling *p; 448618334Speter 448718334Speter for (p = spelling_base; p < spelling; p++) 448818334Speter { 448918334Speter if (p->kind == SPELLING_BOUNDS) 449018334Speter size += 25; 449118334Speter else 449218334Speter size += strlen (p->u.s) + 1; 449318334Speter } 449418334Speter 449518334Speter return size; 449618334Speter} 449718334Speter 449818334Speter/* Print the spelling to BUFFER and return it. */ 449918334Speter 450018334Speterstatic char * 4501132718Skanprint_spelling (char *buffer) 450218334Speter{ 450390075Sobrien char *d = buffer; 450490075Sobrien struct spelling *p; 450518334Speter 450618334Speter for (p = spelling_base; p < spelling; p++) 450718334Speter if (p->kind == SPELLING_BOUNDS) 450818334Speter { 4509169689Skan sprintf (d, "[" HOST_WIDE_INT_PRINT_UNSIGNED "]", p->u.i); 451018334Speter d += strlen (d); 451118334Speter } 451218334Speter else 451318334Speter { 451490075Sobrien const char *s; 451518334Speter if (p->kind == SPELLING_MEMBER) 451618334Speter *d++ = '.'; 451750397Sobrien for (s = p->u.s; (*d = *s++); d++) 451818334Speter ; 451918334Speter } 452018334Speter *d++ = '\0'; 452118334Speter return buffer; 452218334Speter} 452318334Speter 452418334Speter/* Issue an error message for a bad initializer component. 452552284Sobrien MSGID identifies the message. 452652284Sobrien The component name is taken from the spelling stack. */ 452718334Speter 452818334Spetervoid 4529132718Skanerror_init (const char *msgid) 453018334Speter{ 453152284Sobrien char *ofwhat; 453218334Speter 453390075Sobrien error ("%s", _(msgid)); 4534169689Skan ofwhat = print_spelling ((char *) alloca (spelling_length () + 1)); 453518334Speter if (*ofwhat) 4536169689Skan error ("(near initialization for %qs)", ofwhat); 453718334Speter} 453818334Speter 453918334Speter/* Issue a pedantic warning for a bad initializer component. 454052284Sobrien MSGID identifies the message. 454152284Sobrien The component name is taken from the spelling stack. */ 454218334Speter 454318334Spetervoid 4544132718Skanpedwarn_init (const char *msgid) 454518334Speter{ 454652284Sobrien char *ofwhat; 454718334Speter 454890075Sobrien pedwarn ("%s", _(msgid)); 4549169689Skan ofwhat = print_spelling ((char *) alloca (spelling_length () + 1)); 455018334Speter if (*ofwhat) 4551169689Skan pedwarn ("(near initialization for %qs)", ofwhat); 455218334Speter} 455318334Speter 455418334Speter/* Issue a warning for a bad initializer component. 455552284Sobrien MSGID identifies the message. 455652284Sobrien The component name is taken from the spelling stack. */ 455718334Speter 455818334Speterstatic void 4559132718Skanwarning_init (const char *msgid) 456018334Speter{ 456152284Sobrien char *ofwhat; 456218334Speter 4563169689Skan warning (0, "%s", _(msgid)); 4564169689Skan ofwhat = print_spelling ((char *) alloca (spelling_length () + 1)); 456518334Speter if (*ofwhat) 4566169689Skan warning (0, "(near initialization for %qs)", ofwhat); 456718334Speter} 456818334Speter 4569169689Skan/* If TYPE is an array type and EXPR is a parenthesized string 4570169689Skan constant, warn if pedantic that EXPR is being used to initialize an 4571169689Skan object of type TYPE. */ 4572169689Skan 4573169689Skanvoid 4574169689Skanmaybe_warn_string_init (tree type, struct c_expr expr) 4575169689Skan{ 4576169689Skan if (pedantic 4577169689Skan && TREE_CODE (type) == ARRAY_TYPE 4578169689Skan && TREE_CODE (expr.value) == STRING_CST 4579169689Skan && expr.original_code != STRING_CST) 4580169689Skan pedwarn_init ("array initialized from parenthesized string constant"); 4581169689Skan} 4582169689Skan 458318334Speter/* Digest the parser output INIT as an initializer for type TYPE. 458418334Speter Return a C expression of type TYPE to represent the initial value. 458518334Speter 4586169689Skan If INIT is a string constant, STRICT_STRING is true if it is 4587169689Skan unparenthesized or we should not warn here for it being parenthesized. 4588169689Skan For other types of INIT, STRICT_STRING is not used. 4589169689Skan 4590117395Skan REQUIRE_CONSTANT requests an error if non-constant initializers or 4591117395Skan elements are seen. */ 459218334Speter 459318334Speterstatic tree 4594169689Skandigest_init (tree type, tree init, bool strict_string, int require_constant) 459518334Speter{ 459618334Speter enum tree_code code = TREE_CODE (type); 459718334Speter tree inside_init = init; 459818334Speter 459990075Sobrien if (type == error_mark_node 4600169689Skan || !init 460190075Sobrien || init == error_mark_node 460290075Sobrien || TREE_TYPE (init) == error_mark_node) 460390075Sobrien return error_mark_node; 460418334Speter 4605169689Skan STRIP_TYPE_NOPS (inside_init); 460618334Speter 460790075Sobrien inside_init = fold (inside_init); 460890075Sobrien 460918334Speter /* Initialization of an array of chars from a string constant 461018334Speter optionally enclosed in braces. */ 461118334Speter 4612169689Skan if (code == ARRAY_TYPE && inside_init 4613169689Skan && TREE_CODE (inside_init) == STRING_CST) 461418334Speter { 461518334Speter tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type)); 4616169689Skan /* Note that an array could be both an array of character type 4617169689Skan and an array of wchar_t if wchar_t is signed char or unsigned 4618169689Skan char. */ 4619169689Skan bool char_array = (typ1 == char_type_node 4620169689Skan || typ1 == signed_char_type_node 4621169689Skan || typ1 == unsigned_char_type_node); 4622169689Skan bool wchar_array = !!comptypes (typ1, wchar_type_node); 4623169689Skan if (char_array || wchar_array) 462418334Speter { 4625169689Skan struct c_expr expr; 4626169689Skan bool char_string; 4627169689Skan expr.value = inside_init; 4628169689Skan expr.original_code = (strict_string ? STRING_CST : ERROR_MARK); 4629169689Skan maybe_warn_string_init (type, expr); 4630169689Skan 4631169689Skan char_string 4632169689Skan = (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init))) 4633169689Skan == char_type_node); 4634169689Skan 463518334Speter if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), 4636169689Skan TYPE_MAIN_VARIANT (type))) 463718334Speter return inside_init; 463818334Speter 4639169689Skan if (!wchar_array && !char_string) 464018334Speter { 464152284Sobrien error_init ("char-array initialized from wide string"); 464218334Speter return error_mark_node; 464318334Speter } 4644169689Skan if (char_string && !char_array) 464518334Speter { 4646169689Skan error_init ("wchar_t-array initialized from non-wide string"); 464718334Speter return error_mark_node; 464818334Speter } 464918334Speter 465018334Speter TREE_TYPE (inside_init) = type; 465118334Speter if (TYPE_DOMAIN (type) != 0 465290075Sobrien && TYPE_SIZE (type) != 0 465390075Sobrien && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST 465418334Speter /* Subtract 1 (or sizeof (wchar_t)) 465518334Speter because it's ok to ignore the terminating null char 465618334Speter that is counted in the length of the constant. */ 465790075Sobrien && 0 > compare_tree_int (TYPE_SIZE_UNIT (type), 465890075Sobrien TREE_STRING_LENGTH (inside_init) 465990075Sobrien - ((TYPE_PRECISION (typ1) 466090075Sobrien != TYPE_PRECISION (char_type_node)) 466190075Sobrien ? (TYPE_PRECISION (wchar_type_node) 466290075Sobrien / BITS_PER_UNIT) 466390075Sobrien : 1))) 466490075Sobrien pedwarn_init ("initializer-string for array of chars is too long"); 466590075Sobrien 466618334Speter return inside_init; 466718334Speter } 4668169689Skan else if (INTEGRAL_TYPE_P (typ1)) 4669169689Skan { 4670169689Skan error_init ("array of inappropriate type initialized " 4671169689Skan "from string constant"); 4672169689Skan return error_mark_node; 4673169689Skan } 467418334Speter } 4675132718Skan 4676119256Skan /* Build a VECTOR_CST from a *constant* vector constructor. If the 4677119256Skan vector constructor is not constant (e.g. {1,2,3,foo()}) then punt 4678119256Skan below and handle as a constructor. */ 4679146895Skan if (code == VECTOR_TYPE 4680161651Skan && TREE_CODE (TREE_TYPE (inside_init)) == VECTOR_TYPE 4681161651Skan && vector_types_convertible_p (TREE_TYPE (inside_init), type) 4682146895Skan && TREE_CONSTANT (inside_init)) 4683146895Skan { 4684146895Skan if (TREE_CODE (inside_init) == VECTOR_CST 4685146895Skan && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), 4686169689Skan TYPE_MAIN_VARIANT (type))) 4687146895Skan return inside_init; 468818334Speter 4689146895Skan if (TREE_CODE (inside_init) == CONSTRUCTOR) 4690146895Skan { 4691169689Skan unsigned HOST_WIDE_INT ix; 4692169689Skan tree value; 4693169689Skan bool constant_p = true; 4694169689Skan 4695169689Skan /* Iterate through elements and check if all constructor 4696169689Skan elements are *_CSTs. */ 4697169689Skan FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (inside_init), ix, value) 4698169689Skan if (!CONSTANT_CLASS_P (value)) 4699169689Skan { 4700169689Skan constant_p = false; 4701169689Skan break; 4702169689Skan } 4703169689Skan 4704169689Skan if (constant_p) 4705169689Skan return build_vector_from_ctor (type, 4706169689Skan CONSTRUCTOR_ELTS (inside_init)); 4707169689Skan } 4708146895Skan } 4709146895Skan 471018334Speter /* Any type can be initialized 471118334Speter from an expression of the same type, optionally with braces. */ 471218334Speter 471318334Speter if (inside_init && TREE_TYPE (inside_init) != 0 471418334Speter && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), 4715169689Skan TYPE_MAIN_VARIANT (type)) 471618334Speter || (code == ARRAY_TYPE 4717169689Skan && comptypes (TREE_TYPE (inside_init), type)) 471896263Sobrien || (code == VECTOR_TYPE 4719169689Skan && comptypes (TREE_TYPE (inside_init), type)) 472018334Speter || (code == POINTER_TYPE 4721132718Skan && TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE 472218334Speter && comptypes (TREE_TYPE (TREE_TYPE (inside_init)), 4723169689Skan TREE_TYPE (type))))) 472418334Speter { 472590075Sobrien if (code == POINTER_TYPE) 4726122180Skan { 4727122180Skan if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE) 4728122180Skan { 4729169689Skan if (TREE_CODE (inside_init) == STRING_CST 4730169689Skan || TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR) 4731169689Skan inside_init = array_to_pointer_conversion (inside_init); 4732169689Skan else 4733169689Skan { 4734169689Skan error_init ("invalid use of non-lvalue array"); 4735169689Skan return error_mark_node; 4736169689Skan } 4737122180Skan } 4738169689Skan } 4739132718Skan 4740132718Skan if (code == VECTOR_TYPE) 4741132718Skan /* Although the types are compatible, we may require a 4742132718Skan conversion. */ 4743132718Skan inside_init = convert (type, inside_init); 4744132718Skan 4745169689Skan if (require_constant 4746169689Skan && (code == VECTOR_TYPE || !flag_isoc99) 474790075Sobrien && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR) 474818334Speter { 474990075Sobrien /* As an extension, allow initializing objects with static storage 475090075Sobrien duration with compound literals (which are then treated just as 4751169689Skan the brace enclosed list they contain). Also allow this for 4752169689Skan vectors, as we can only assign them with compound literals. */ 475390075Sobrien tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init); 475490075Sobrien inside_init = DECL_INITIAL (decl); 475590075Sobrien } 475690075Sobrien 475790075Sobrien if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST 475890075Sobrien && TREE_CODE (inside_init) != CONSTRUCTOR) 475990075Sobrien { 476052284Sobrien error_init ("array initialized from non-constant array expression"); 476118334Speter return error_mark_node; 476218334Speter } 476318334Speter 476418334Speter if (optimize && TREE_CODE (inside_init) == VAR_DECL) 476590075Sobrien inside_init = decl_constant_value_for_broken_optimization (inside_init); 476618334Speter 476718334Speter /* Compound expressions can only occur here if -pedantic or 476818334Speter -pedantic-errors is specified. In the later case, we always want 476918334Speter an error. In the former case, we simply want a warning. */ 477018334Speter if (require_constant && pedantic 477118334Speter && TREE_CODE (inside_init) == COMPOUND_EXPR) 477218334Speter { 477318334Speter inside_init 477418334Speter = valid_compound_expr_initializer (inside_init, 477518334Speter TREE_TYPE (inside_init)); 477618334Speter if (inside_init == error_mark_node) 477752284Sobrien error_init ("initializer element is not constant"); 477818334Speter else 477952284Sobrien pedwarn_init ("initializer element is not constant"); 478018334Speter if (flag_pedantic_errors) 478118334Speter inside_init = error_mark_node; 478218334Speter } 4783132718Skan else if (require_constant 4784169689Skan && !initializer_constant_valid_p (inside_init, 4785169689Skan TREE_TYPE (inside_init))) 478618334Speter { 478752284Sobrien error_init ("initializer element is not constant"); 478818334Speter inside_init = error_mark_node; 478918334Speter } 479018334Speter 4791169689Skan /* Added to enable additional -Wmissing-format-attribute warnings. */ 4792169689Skan if (TREE_CODE (TREE_TYPE (inside_init)) == POINTER_TYPE) 4793169689Skan inside_init = convert_for_assignment (type, inside_init, ic_init, NULL_TREE, 4794169689Skan NULL_TREE, 0); 479518334Speter return inside_init; 479618334Speter } 479718334Speter 479818334Speter /* Handle scalar types, including conversions. */ 479918334Speter 480018334Speter if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE 4801169689Skan || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE 4802169689Skan || code == VECTOR_TYPE) 480318334Speter { 4804169689Skan if (TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE 4805169689Skan && (TREE_CODE (init) == STRING_CST 4806169689Skan || TREE_CODE (init) == COMPOUND_LITERAL_EXPR)) 4807169689Skan init = array_to_pointer_conversion (init); 480818334Speter inside_init 4809169689Skan = convert_for_assignment (type, init, ic_init, 481018334Speter NULL_TREE, NULL_TREE, 0); 481118334Speter 4812169689Skan /* Check to see if we have already given an error message. */ 4813169689Skan if (inside_init == error_mark_node) 4814169689Skan ; 4815169689Skan else if (require_constant && !TREE_CONSTANT (inside_init)) 481618334Speter { 481752284Sobrien error_init ("initializer element is not constant"); 481818334Speter inside_init = error_mark_node; 481918334Speter } 482018334Speter else if (require_constant 4821169689Skan && !initializer_constant_valid_p (inside_init, 4822169689Skan TREE_TYPE (inside_init))) 482318334Speter { 482452284Sobrien error_init ("initializer element is not computable at load time"); 482518334Speter inside_init = error_mark_node; 482618334Speter } 482718334Speter 482818334Speter return inside_init; 482918334Speter } 483018334Speter 483118334Speter /* Come here only for records and arrays. */ 483218334Speter 483390075Sobrien if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) 483418334Speter { 483552284Sobrien error_init ("variable-sized object may not be initialized"); 483618334Speter return error_mark_node; 483718334Speter } 483818334Speter 483952284Sobrien error_init ("invalid initializer"); 484018334Speter return error_mark_node; 484118334Speter} 484218334Speter 484318334Speter/* Handle initializers that use braces. */ 484418334Speter 484518334Speter/* Type of object we are accumulating a constructor for. 484618334Speter This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */ 484718334Speterstatic tree constructor_type; 484818334Speter 484918334Speter/* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields 485018334Speter left to fill. */ 485118334Speterstatic tree constructor_fields; 485218334Speter 485318334Speter/* For an ARRAY_TYPE, this is the specified index 485490075Sobrien at which to store the next element we get. */ 485518334Speterstatic tree constructor_index; 485618334Speter 485718334Speter/* For an ARRAY_TYPE, this is the maximum index. */ 485818334Speterstatic tree constructor_max_index; 485918334Speter 486018334Speter/* For a RECORD_TYPE, this is the first field not yet written out. */ 486118334Speterstatic tree constructor_unfilled_fields; 486218334Speter 486318334Speter/* For an ARRAY_TYPE, this is the index of the first element 486490075Sobrien not yet written out. */ 486518334Speterstatic tree constructor_unfilled_index; 486618334Speter 486718334Speter/* In a RECORD_TYPE, the byte index of the next consecutive field. 486890075Sobrien This is so we can generate gaps between fields, when appropriate. */ 486918334Speterstatic tree constructor_bit_index; 487018334Speter 487118334Speter/* If we are saving up the elements rather than allocating them, 487218334Speter this is the list of elements so far (in reverse order, 487318334Speter most recent first). */ 4874169689Skanstatic VEC(constructor_elt,gc) *constructor_elements; 487518334Speter 487690075Sobrien/* 1 if constructor should be incrementally stored into a constructor chain, 487790075Sobrien 0 if all the elements should be kept in AVL tree. */ 487890075Sobrienstatic int constructor_incremental; 487990075Sobrien 488018334Speter/* 1 if so far this constructor's elements are all compile-time constants. */ 488118334Speterstatic int constructor_constant; 488218334Speter 488318334Speter/* 1 if so far this constructor's elements are all valid address constants. */ 488418334Speterstatic int constructor_simple; 488518334Speter 488618334Speter/* 1 if this constructor is erroneous so far. */ 488718334Speterstatic int constructor_erroneous; 488818334Speter 488950397Sobrien/* Structure for managing pending initializer elements, organized as an 489050397Sobrien AVL tree. */ 489150397Sobrien 489250397Sobrienstruct init_node 489350397Sobrien{ 489450397Sobrien struct init_node *left, *right; 489550397Sobrien struct init_node *parent; 489650397Sobrien int balance; 489750397Sobrien tree purpose; 489850397Sobrien tree value; 489950397Sobrien}; 490050397Sobrien 490150397Sobrien/* Tree of pending elements at this constructor level. 490218334Speter These are elements encountered out of order 490318334Speter which belong at places we haven't reached yet in actually 490490075Sobrien writing the output. 490590075Sobrien Will never hold tree nodes across GC runs. */ 490650397Sobrienstatic struct init_node *constructor_pending_elts; 490718334Speter 490818334Speter/* The SPELLING_DEPTH of this constructor. */ 490918334Speterstatic int constructor_depth; 491018334Speter 491118334Speter/* DECL node for which an initializer is being read. 491218334Speter 0 means we are reading a constructor expression 491318334Speter such as (struct foo) {...}. */ 491418334Speterstatic tree constructor_decl; 491518334Speter 491618334Speter/* Nonzero if this is an initializer for a top-level decl. */ 491718334Speterstatic int constructor_top_level; 491818334Speter 491990075Sobrien/* Nonzero if there were any member designators in this initializer. */ 492090075Sobrienstatic int constructor_designated; 492190075Sobrien 492290075Sobrien/* Nesting depth of designator list. */ 492390075Sobrienstatic int designator_depth; 492490075Sobrien 492590075Sobrien/* Nonzero if there were diagnosed errors in this designator list. */ 4926169689Skanstatic int designator_erroneous; 492790075Sobrien 492818334Speter 492918334Speter/* This stack has a level for each implicit or explicit level of 493018334Speter structuring in the initializer, including the outermost one. It 493118334Speter saves the values of most of the variables above. */ 493218334Speter 493390075Sobrienstruct constructor_range_stack; 493490075Sobrien 493518334Speterstruct constructor_stack 493618334Speter{ 493718334Speter struct constructor_stack *next; 493818334Speter tree type; 493918334Speter tree fields; 494018334Speter tree index; 494118334Speter tree max_index; 494218334Speter tree unfilled_index; 494318334Speter tree unfilled_fields; 494418334Speter tree bit_index; 4945169689Skan VEC(constructor_elt,gc) *elements; 494690075Sobrien struct init_node *pending_elts; 494718334Speter int offset; 494818334Speter int depth; 4949169689Skan /* If value nonzero, this value should replace the entire 495018334Speter constructor at this level. */ 4951169689Skan struct c_expr replacement_value; 495290075Sobrien struct constructor_range_stack *range_stack; 495318334Speter char constant; 495418334Speter char simple; 495518334Speter char implicit; 495618334Speter char erroneous; 495718334Speter char outer; 495890075Sobrien char incremental; 495990075Sobrien char designated; 496018334Speter}; 496118334Speter 4962169689Skanstatic struct constructor_stack *constructor_stack; 496318334Speter 496490075Sobrien/* This stack represents designators from some range designator up to 496590075Sobrien the last designator in the list. */ 496690075Sobrien 496790075Sobrienstruct constructor_range_stack 496890075Sobrien{ 496990075Sobrien struct constructor_range_stack *next, *prev; 497090075Sobrien struct constructor_stack *stack; 497190075Sobrien tree range_start; 497290075Sobrien tree index; 497390075Sobrien tree range_end; 497490075Sobrien tree fields; 497590075Sobrien}; 497690075Sobrien 4977169689Skanstatic struct constructor_range_stack *constructor_range_stack; 497890075Sobrien 497918334Speter/* This stack records separate initializers that are nested. 498018334Speter Nested initializers can't happen in ANSI C, but GNU C allows them 498118334Speter in cases like { ... (struct foo) { ... } ... }. */ 498218334Speter 498318334Speterstruct initializer_stack 498418334Speter{ 498518334Speter struct initializer_stack *next; 498618334Speter tree decl; 498718334Speter struct constructor_stack *constructor_stack; 498890075Sobrien struct constructor_range_stack *constructor_range_stack; 4989169689Skan VEC(constructor_elt,gc) *elements; 499018334Speter struct spelling *spelling; 499118334Speter struct spelling *spelling_base; 499218334Speter int spelling_size; 499318334Speter char top_level; 499418334Speter char require_constant_value; 499518334Speter char require_constant_elements; 499618334Speter}; 499718334Speter 4998169689Skanstatic struct initializer_stack *initializer_stack; 499918334Speter 500018334Speter/* Prepare to parse and output the initializer for variable DECL. */ 500118334Speter 500218334Spetervoid 5003169689Skanstart_init (tree decl, tree asmspec_tree ATTRIBUTE_UNUSED, int top_level) 500418334Speter{ 500552284Sobrien const char *locus; 5006169689Skan struct initializer_stack *p = XNEW (struct initializer_stack); 500718334Speter 500818334Speter p->decl = constructor_decl; 500918334Speter p->require_constant_value = require_constant_value; 501018334Speter p->require_constant_elements = require_constant_elements; 501118334Speter p->constructor_stack = constructor_stack; 501290075Sobrien p->constructor_range_stack = constructor_range_stack; 501318334Speter p->elements = constructor_elements; 501418334Speter p->spelling = spelling; 501518334Speter p->spelling_base = spelling_base; 501618334Speter p->spelling_size = spelling_size; 501718334Speter p->top_level = constructor_top_level; 501818334Speter p->next = initializer_stack; 501918334Speter initializer_stack = p; 502018334Speter 502118334Speter constructor_decl = decl; 502290075Sobrien constructor_designated = 0; 502318334Speter constructor_top_level = top_level; 502418334Speter 5025169689Skan if (decl != 0 && decl != error_mark_node) 502618334Speter { 502718334Speter require_constant_value = TREE_STATIC (decl); 502818334Speter require_constant_elements 502990075Sobrien = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99)) 503018334Speter /* For a scalar, you can always use any value to initialize, 503118334Speter even within braces. */ 503218334Speter && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE 503318334Speter || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE 503418334Speter || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE 503518334Speter || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE)); 503618334Speter locus = IDENTIFIER_POINTER (DECL_NAME (decl)); 503718334Speter } 503818334Speter else 503918334Speter { 504018334Speter require_constant_value = 0; 504118334Speter require_constant_elements = 0; 504218334Speter locus = "(anonymous)"; 504318334Speter } 504418334Speter 504518334Speter constructor_stack = 0; 504690075Sobrien constructor_range_stack = 0; 504718334Speter 504818334Speter missing_braces_mentioned = 0; 504918334Speter 505018334Speter spelling_base = 0; 505118334Speter spelling_size = 0; 505218334Speter RESTORE_SPELLING_DEPTH (0); 505318334Speter 505418334Speter if (locus) 505518334Speter push_string (locus); 505618334Speter} 505718334Speter 505818334Spetervoid 5059132718Skanfinish_init (void) 506018334Speter{ 506118334Speter struct initializer_stack *p = initializer_stack; 506218334Speter 506318334Speter /* Free the whole constructor stack of this initializer. */ 506418334Speter while (constructor_stack) 506518334Speter { 506618334Speter struct constructor_stack *q = constructor_stack; 506718334Speter constructor_stack = q->next; 506818334Speter free (q); 506918334Speter } 507018334Speter 5071169689Skan gcc_assert (!constructor_range_stack); 507290075Sobrien 507318334Speter /* Pop back to the data of the outer initializer (if any). */ 5074132718Skan free (spelling_base); 5075132718Skan 507618334Speter constructor_decl = p->decl; 507718334Speter require_constant_value = p->require_constant_value; 507818334Speter require_constant_elements = p->require_constant_elements; 507918334Speter constructor_stack = p->constructor_stack; 508090075Sobrien constructor_range_stack = p->constructor_range_stack; 508118334Speter constructor_elements = p->elements; 508218334Speter spelling = p->spelling; 508318334Speter spelling_base = p->spelling_base; 508418334Speter spelling_size = p->spelling_size; 508518334Speter constructor_top_level = p->top_level; 508618334Speter initializer_stack = p->next; 508718334Speter free (p); 508818334Speter} 508918334Speter 509018334Speter/* Call here when we see the initializer is surrounded by braces. 509118334Speter This is instead of a call to push_init_level; 509218334Speter it is matched by a call to pop_init_level. 509318334Speter 509418334Speter TYPE is the type to initialize, for a constructor expression. 509518334Speter For an initializer for a decl, TYPE is zero. */ 509618334Speter 509718334Spetervoid 5098132718Skanreally_start_incremental_init (tree type) 509918334Speter{ 5100169689Skan struct constructor_stack *p = XNEW (struct constructor_stack); 510118334Speter 510218334Speter if (type == 0) 510318334Speter type = TREE_TYPE (constructor_decl); 510418334Speter 5105169689Skan if (targetm.vector_opaque_p (type)) 5106132718Skan error ("opaque vector types cannot be initialized"); 5107132718Skan 510818334Speter p->type = constructor_type; 510918334Speter p->fields = constructor_fields; 511018334Speter p->index = constructor_index; 511118334Speter p->max_index = constructor_max_index; 511218334Speter p->unfilled_index = constructor_unfilled_index; 511318334Speter p->unfilled_fields = constructor_unfilled_fields; 511418334Speter p->bit_index = constructor_bit_index; 511518334Speter p->elements = constructor_elements; 511618334Speter p->constant = constructor_constant; 511718334Speter p->simple = constructor_simple; 511818334Speter p->erroneous = constructor_erroneous; 511918334Speter p->pending_elts = constructor_pending_elts; 512018334Speter p->depth = constructor_depth; 5121169689Skan p->replacement_value.value = 0; 5122169689Skan p->replacement_value.original_code = ERROR_MARK; 512318334Speter p->implicit = 0; 512490075Sobrien p->range_stack = 0; 512590075Sobrien p->outer = 0; 512618334Speter p->incremental = constructor_incremental; 512790075Sobrien p->designated = constructor_designated; 512818334Speter p->next = 0; 512918334Speter constructor_stack = p; 513018334Speter 513118334Speter constructor_constant = 1; 513218334Speter constructor_simple = 1; 513318334Speter constructor_depth = SPELLING_DEPTH (); 513418334Speter constructor_elements = 0; 513518334Speter constructor_pending_elts = 0; 513618334Speter constructor_type = type; 513790075Sobrien constructor_incremental = 1; 513890075Sobrien constructor_designated = 0; 513990075Sobrien designator_depth = 0; 5140169689Skan designator_erroneous = 0; 514118334Speter 514218334Speter if (TREE_CODE (constructor_type) == RECORD_TYPE 514318334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 514418334Speter { 514518334Speter constructor_fields = TYPE_FIELDS (constructor_type); 514618334Speter /* Skip any nameless bit fields at the beginning. */ 514750397Sobrien while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields) 514818334Speter && DECL_NAME (constructor_fields) == 0) 514918334Speter constructor_fields = TREE_CHAIN (constructor_fields); 515090075Sobrien 515118334Speter constructor_unfilled_fields = constructor_fields; 515290075Sobrien constructor_bit_index = bitsize_zero_node; 515318334Speter } 515418334Speter else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 515518334Speter { 515618334Speter if (TYPE_DOMAIN (constructor_type)) 515718334Speter { 515818334Speter constructor_max_index 515918334Speter = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)); 516090075Sobrien 516190075Sobrien /* Detect non-empty initializations of zero-length arrays. */ 516290075Sobrien if (constructor_max_index == NULL_TREE 516390075Sobrien && TYPE_SIZE (constructor_type)) 5164169689Skan constructor_max_index = build_int_cst (NULL_TREE, -1); 516590075Sobrien 516690075Sobrien /* constructor_max_index needs to be an INTEGER_CST. Attempts 5167117395Skan to initialize VLAs will cause a proper error; avoid tree 516890075Sobrien checking errors as well by setting a safe value. */ 516990075Sobrien if (constructor_max_index 517090075Sobrien && TREE_CODE (constructor_max_index) != INTEGER_CST) 5171169689Skan constructor_max_index = build_int_cst (NULL_TREE, -1); 517290075Sobrien 517318334Speter constructor_index 517490075Sobrien = convert (bitsizetype, 517590075Sobrien TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type))); 517618334Speter } 517718334Speter else 5178169689Skan { 5179169689Skan constructor_index = bitsize_zero_node; 5180169689Skan constructor_max_index = NULL_TREE; 5181169689Skan } 518290075Sobrien 518390075Sobrien constructor_unfilled_index = constructor_index; 518418334Speter } 518596263Sobrien else if (TREE_CODE (constructor_type) == VECTOR_TYPE) 518696263Sobrien { 518796263Sobrien /* Vectors are like simple fixed-size arrays. */ 518896263Sobrien constructor_max_index = 5189169689Skan build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1); 5190169689Skan constructor_index = bitsize_zero_node; 519196263Sobrien constructor_unfilled_index = constructor_index; 519296263Sobrien } 519318334Speter else 519418334Speter { 519518334Speter /* Handle the case of int x = {5}; */ 519618334Speter constructor_fields = constructor_type; 519718334Speter constructor_unfilled_fields = constructor_type; 519818334Speter } 519918334Speter} 520018334Speter 520118334Speter/* Push down into a subobject, for initialization. 520218334Speter If this is for an explicit set of braces, IMPLICIT is 0. 520318334Speter If it is because the next element belongs at a lower level, 520490075Sobrien IMPLICIT is 1 (or 2 if the push is because of designator list). */ 520518334Speter 520618334Spetervoid 5207132718Skanpush_init_level (int implicit) 520818334Speter{ 520918334Speter struct constructor_stack *p; 521090075Sobrien tree value = NULL_TREE; 521118334Speter 521218334Speter /* If we've exhausted any levels that didn't have braces, 5213161651Skan pop them now. If implicit == 1, this will have been done in 5214161651Skan process_init_element; do not repeat it here because in the case 5215161651Skan of excess initializers for an empty aggregate this leads to an 5216161651Skan infinite cycle of popping a level and immediately recreating 5217161651Skan it. */ 5218161651Skan if (implicit != 1) 521918334Speter { 5220161651Skan while (constructor_stack->implicit) 5221161651Skan { 5222161651Skan if ((TREE_CODE (constructor_type) == RECORD_TYPE 5223161651Skan || TREE_CODE (constructor_type) == UNION_TYPE) 5224161651Skan && constructor_fields == 0) 5225161651Skan process_init_element (pop_init_level (1)); 5226161651Skan else if (TREE_CODE (constructor_type) == ARRAY_TYPE 5227161651Skan && constructor_max_index 5228161651Skan && tree_int_cst_lt (constructor_max_index, 5229161651Skan constructor_index)) 5230161651Skan process_init_element (pop_init_level (1)); 5231161651Skan else 5232161651Skan break; 5233161651Skan } 523418334Speter } 523518334Speter 523690075Sobrien /* Unless this is an explicit brace, we need to preserve previous 523790075Sobrien content if any. */ 523890075Sobrien if (implicit) 523918334Speter { 524090075Sobrien if ((TREE_CODE (constructor_type) == RECORD_TYPE 524190075Sobrien || TREE_CODE (constructor_type) == UNION_TYPE) 524290075Sobrien && constructor_fields) 524390075Sobrien value = find_init_member (constructor_fields); 524490075Sobrien else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 524590075Sobrien value = find_init_member (constructor_index); 524618334Speter } 524718334Speter 5248169689Skan p = XNEW (struct constructor_stack); 524918334Speter p->type = constructor_type; 525018334Speter p->fields = constructor_fields; 525118334Speter p->index = constructor_index; 525218334Speter p->max_index = constructor_max_index; 525318334Speter p->unfilled_index = constructor_unfilled_index; 525418334Speter p->unfilled_fields = constructor_unfilled_fields; 525518334Speter p->bit_index = constructor_bit_index; 525618334Speter p->elements = constructor_elements; 525718334Speter p->constant = constructor_constant; 525818334Speter p->simple = constructor_simple; 525918334Speter p->erroneous = constructor_erroneous; 526018334Speter p->pending_elts = constructor_pending_elts; 526118334Speter p->depth = constructor_depth; 5262169689Skan p->replacement_value.value = 0; 5263169689Skan p->replacement_value.original_code = ERROR_MARK; 526418334Speter p->implicit = implicit; 526590075Sobrien p->outer = 0; 526618334Speter p->incremental = constructor_incremental; 526790075Sobrien p->designated = constructor_designated; 526818334Speter p->next = constructor_stack; 526990075Sobrien p->range_stack = 0; 527018334Speter constructor_stack = p; 527118334Speter 527218334Speter constructor_constant = 1; 527318334Speter constructor_simple = 1; 527418334Speter constructor_depth = SPELLING_DEPTH (); 527518334Speter constructor_elements = 0; 527690075Sobrien constructor_incremental = 1; 527790075Sobrien constructor_designated = 0; 527818334Speter constructor_pending_elts = 0; 527990075Sobrien if (!implicit) 528090075Sobrien { 528190075Sobrien p->range_stack = constructor_range_stack; 528290075Sobrien constructor_range_stack = 0; 528390075Sobrien designator_depth = 0; 5284169689Skan designator_erroneous = 0; 528590075Sobrien } 528618334Speter 528718334Speter /* Don't die if an entire brace-pair level is superfluous 528818334Speter in the containing level. */ 528918334Speter if (constructor_type == 0) 529018334Speter ; 529118334Speter else if (TREE_CODE (constructor_type) == RECORD_TYPE 529218334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 529318334Speter { 529418334Speter /* Don't die if there are extra init elts at the end. */ 529518334Speter if (constructor_fields == 0) 529618334Speter constructor_type = 0; 529718334Speter else 529818334Speter { 529918334Speter constructor_type = TREE_TYPE (constructor_fields); 530018334Speter push_member_name (constructor_fields); 530118334Speter constructor_depth++; 530218334Speter } 530318334Speter } 530418334Speter else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 530518334Speter { 530618334Speter constructor_type = TREE_TYPE (constructor_type); 5307169689Skan push_array_bounds (tree_low_cst (constructor_index, 1)); 530818334Speter constructor_depth++; 530918334Speter } 531018334Speter 531118334Speter if (constructor_type == 0) 531218334Speter { 531352284Sobrien error_init ("extra brace group at end of initializer"); 531418334Speter constructor_fields = 0; 531518334Speter constructor_unfilled_fields = 0; 531618334Speter return; 531718334Speter } 531818334Speter 531990075Sobrien if (value && TREE_CODE (value) == CONSTRUCTOR) 532090075Sobrien { 532190075Sobrien constructor_constant = TREE_CONSTANT (value); 532290075Sobrien constructor_simple = TREE_STATIC (value); 5323132718Skan constructor_elements = CONSTRUCTOR_ELTS (value); 5324169689Skan if (!VEC_empty (constructor_elt, constructor_elements) 532590075Sobrien && (TREE_CODE (constructor_type) == RECORD_TYPE 532690075Sobrien || TREE_CODE (constructor_type) == ARRAY_TYPE)) 532790075Sobrien set_nonincremental_init (); 532890075Sobrien } 532918334Speter 533090075Sobrien if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned) 533118334Speter { 533218334Speter missing_braces_mentioned = 1; 533352284Sobrien warning_init ("missing braces around initializer"); 533418334Speter } 533518334Speter 533618334Speter if (TREE_CODE (constructor_type) == RECORD_TYPE 533718334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 533818334Speter { 533918334Speter constructor_fields = TYPE_FIELDS (constructor_type); 534018334Speter /* Skip any nameless bit fields at the beginning. */ 534150397Sobrien while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields) 534218334Speter && DECL_NAME (constructor_fields) == 0) 534318334Speter constructor_fields = TREE_CHAIN (constructor_fields); 534490075Sobrien 534518334Speter constructor_unfilled_fields = constructor_fields; 534690075Sobrien constructor_bit_index = bitsize_zero_node; 534718334Speter } 534896263Sobrien else if (TREE_CODE (constructor_type) == VECTOR_TYPE) 534996263Sobrien { 535096263Sobrien /* Vectors are like simple fixed-size arrays. */ 535196263Sobrien constructor_max_index = 5352169689Skan build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1); 535396263Sobrien constructor_index = convert (bitsizetype, integer_zero_node); 535496263Sobrien constructor_unfilled_index = constructor_index; 535596263Sobrien } 535618334Speter else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 535718334Speter { 535818334Speter if (TYPE_DOMAIN (constructor_type)) 535918334Speter { 536018334Speter constructor_max_index 536118334Speter = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)); 536290075Sobrien 536390075Sobrien /* Detect non-empty initializations of zero-length arrays. */ 536490075Sobrien if (constructor_max_index == NULL_TREE 536590075Sobrien && TYPE_SIZE (constructor_type)) 5366169689Skan constructor_max_index = build_int_cst (NULL_TREE, -1); 536790075Sobrien 536890075Sobrien /* constructor_max_index needs to be an INTEGER_CST. Attempts 5369117395Skan to initialize VLAs will cause a proper error; avoid tree 537090075Sobrien checking errors as well by setting a safe value. */ 537190075Sobrien if (constructor_max_index 537290075Sobrien && TREE_CODE (constructor_max_index) != INTEGER_CST) 5373169689Skan constructor_max_index = build_int_cst (NULL_TREE, -1); 537490075Sobrien 537518334Speter constructor_index 5376132718Skan = convert (bitsizetype, 537790075Sobrien TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type))); 537818334Speter } 537918334Speter else 538090075Sobrien constructor_index = bitsize_zero_node; 538190075Sobrien 538290075Sobrien constructor_unfilled_index = constructor_index; 538390075Sobrien if (value && TREE_CODE (value) == STRING_CST) 538490075Sobrien { 538590075Sobrien /* We need to split the char/wchar array into individual 538690075Sobrien characters, so that we don't have to special case it 538790075Sobrien everywhere. */ 538890075Sobrien set_nonincremental_init_from_string (value); 538990075Sobrien } 539018334Speter } 539118334Speter else 539218334Speter { 5393169689Skan if (constructor_type != error_mark_node) 5394169689Skan warning_init ("braces around scalar initializer"); 539518334Speter constructor_fields = constructor_type; 539618334Speter constructor_unfilled_fields = constructor_type; 539718334Speter } 539818334Speter} 539918334Speter 5400132718Skan/* At the end of an implicit or explicit brace level, 5401169689Skan finish up that level of constructor. If a single expression 5402169689Skan with redundant braces initialized that level, return the 5403169689Skan c_expr structure for that expression. Otherwise, the original_code 5404169689Skan element is set to ERROR_MARK. 5405169689Skan If we were outputting the elements as they are read, return 0 as the value 540618334Speter from inner levels (process_init_element ignores that), 5407169689Skan but return error_mark_node as the value from the outermost level 540818334Speter (that's what we want to put in DECL_INITIAL). 5409169689Skan Otherwise, return a CONSTRUCTOR expression as the value. */ 541018334Speter 5411169689Skanstruct c_expr 5412132718Skanpop_init_level (int implicit) 541318334Speter{ 541418334Speter struct constructor_stack *p; 5415169689Skan struct c_expr ret; 5416169689Skan ret.value = 0; 5417169689Skan ret.original_code = ERROR_MARK; 541818334Speter 541918334Speter if (implicit == 0) 542018334Speter { 542118334Speter /* When we come to an explicit close brace, 542218334Speter pop any inner levels that didn't have explicit braces. */ 542318334Speter while (constructor_stack->implicit) 542418334Speter process_init_element (pop_init_level (1)); 542590075Sobrien 5426169689Skan gcc_assert (!constructor_range_stack); 542718334Speter } 542818334Speter 5429132718Skan /* Now output all pending elements. */ 5430132718Skan constructor_incremental = 1; 5431132718Skan output_pending_init_elements (1); 5432132718Skan 543318334Speter p = constructor_stack; 543418334Speter 543590075Sobrien /* Error for initializing a flexible array member, or a zero-length 543690075Sobrien array member in an inappropriate context. */ 543790075Sobrien if (constructor_type && constructor_fields 543890075Sobrien && TREE_CODE (constructor_type) == ARRAY_TYPE 543990075Sobrien && TYPE_DOMAIN (constructor_type) 5440169689Skan && !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type))) 544190075Sobrien { 544290075Sobrien /* Silently discard empty initializations. The parser will 544390075Sobrien already have pedwarned for empty brackets. */ 544490075Sobrien if (integer_zerop (constructor_unfilled_index)) 544590075Sobrien constructor_type = NULL_TREE; 5446169689Skan else 544790075Sobrien { 5448169689Skan gcc_assert (!TYPE_SIZE (constructor_type)); 5449169689Skan 545090075Sobrien if (constructor_depth > 2) 545190075Sobrien error_init ("initialization of flexible array member in a nested context"); 545290075Sobrien else if (pedantic) 545390075Sobrien pedwarn_init ("initialization of a flexible array member"); 545418334Speter 545590075Sobrien /* We have already issued an error message for the existence 545690075Sobrien of a flexible array member not at the end of the structure. 5457169689Skan Discard the initializer so that we do not die later. */ 545890075Sobrien if (TREE_CHAIN (constructor_fields) != NULL_TREE) 545990075Sobrien constructor_type = NULL_TREE; 546090075Sobrien } 546190075Sobrien } 546290075Sobrien 546350397Sobrien /* Warn when some struct elements are implicitly initialized to zero. */ 5464169689Skan if (warn_missing_field_initializers 546550397Sobrien && constructor_type 546650397Sobrien && TREE_CODE (constructor_type) == RECORD_TYPE 546750397Sobrien && constructor_unfilled_fields) 546850397Sobrien { 546990075Sobrien /* Do not warn for flexible array members or zero-length arrays. */ 547090075Sobrien while (constructor_unfilled_fields 5471169689Skan && (!DECL_SIZE (constructor_unfilled_fields) 547290075Sobrien || integer_zerop (DECL_SIZE (constructor_unfilled_fields)))) 547390075Sobrien constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields); 547490075Sobrien 547590075Sobrien /* Do not warn if this level of the initializer uses member 547690075Sobrien designators; it is likely to be deliberate. */ 547790075Sobrien if (constructor_unfilled_fields && !constructor_designated) 547890075Sobrien { 547990075Sobrien push_member_name (constructor_unfilled_fields); 548090075Sobrien warning_init ("missing initializer"); 548190075Sobrien RESTORE_SPELLING_DEPTH (constructor_depth); 548290075Sobrien } 548350397Sobrien } 548450397Sobrien 548518334Speter /* Pad out the end of the structure. */ 5486169689Skan if (p->replacement_value.value) 548790075Sobrien /* If this closes a superfluous brace pair, 548890075Sobrien just pass out the element between them. */ 5489169689Skan ret = p->replacement_value; 549018334Speter else if (constructor_type == 0) 549118334Speter ; 549218334Speter else if (TREE_CODE (constructor_type) != RECORD_TYPE 549318334Speter && TREE_CODE (constructor_type) != UNION_TYPE 549496263Sobrien && TREE_CODE (constructor_type) != ARRAY_TYPE 549596263Sobrien && TREE_CODE (constructor_type) != VECTOR_TYPE) 549618334Speter { 549718334Speter /* A nonincremental scalar initializer--just return 549818334Speter the element, after verifying there is just one. */ 5499169689Skan if (VEC_empty (constructor_elt,constructor_elements)) 550018334Speter { 550190075Sobrien if (!constructor_erroneous) 550290075Sobrien error_init ("empty scalar initializer"); 5503169689Skan ret.value = error_mark_node; 550418334Speter } 5505169689Skan else if (VEC_length (constructor_elt,constructor_elements) != 1) 550618334Speter { 550752284Sobrien error_init ("extra elements in scalar initializer"); 5508169689Skan ret.value = VEC_index (constructor_elt,constructor_elements,0)->value; 550918334Speter } 551018334Speter else 5511169689Skan ret.value = VEC_index (constructor_elt,constructor_elements,0)->value; 551218334Speter } 551390075Sobrien else 551418334Speter { 551518334Speter if (constructor_erroneous) 5516169689Skan ret.value = error_mark_node; 551718334Speter else 551818334Speter { 5519169689Skan ret.value = build_constructor (constructor_type, 5520169689Skan constructor_elements); 552118334Speter if (constructor_constant) 5522169689Skan TREE_CONSTANT (ret.value) = TREE_INVARIANT (ret.value) = 1; 552318334Speter if (constructor_constant && constructor_simple) 5524169689Skan TREE_STATIC (ret.value) = 1; 552518334Speter } 552618334Speter } 552718334Speter 552818334Speter constructor_type = p->type; 552918334Speter constructor_fields = p->fields; 553018334Speter constructor_index = p->index; 553118334Speter constructor_max_index = p->max_index; 553218334Speter constructor_unfilled_index = p->unfilled_index; 553318334Speter constructor_unfilled_fields = p->unfilled_fields; 553418334Speter constructor_bit_index = p->bit_index; 553518334Speter constructor_elements = p->elements; 553618334Speter constructor_constant = p->constant; 553718334Speter constructor_simple = p->simple; 553818334Speter constructor_erroneous = p->erroneous; 553990075Sobrien constructor_incremental = p->incremental; 554090075Sobrien constructor_designated = p->designated; 554118334Speter constructor_pending_elts = p->pending_elts; 554218334Speter constructor_depth = p->depth; 554390075Sobrien if (!p->implicit) 554490075Sobrien constructor_range_stack = p->range_stack; 554518334Speter RESTORE_SPELLING_DEPTH (constructor_depth); 554618334Speter 554718334Speter constructor_stack = p->next; 554818334Speter free (p); 554918334Speter 5550169689Skan if (ret.value == 0 && constructor_stack == 0) 5551169689Skan ret.value = error_mark_node; 5552169689Skan return ret; 555318334Speter} 555418334Speter 555590075Sobrien/* Common handling for both array range and field name designators. 5556117395Skan ARRAY argument is nonzero for array ranges. Returns zero for success. */ 555790075Sobrien 555890075Sobrienstatic int 5559132718Skanset_designator (int array) 556090075Sobrien{ 556190075Sobrien tree subtype; 556290075Sobrien enum tree_code subcode; 556390075Sobrien 556490075Sobrien /* Don't die if an entire brace-pair level is superfluous 556590075Sobrien in the containing level. */ 556690075Sobrien if (constructor_type == 0) 556790075Sobrien return 1; 556890075Sobrien 5569169689Skan /* If there were errors in this designator list already, bail out 5570169689Skan silently. */ 5571169689Skan if (designator_erroneous) 557290075Sobrien return 1; 557390075Sobrien 557490075Sobrien if (!designator_depth) 557590075Sobrien { 5576169689Skan gcc_assert (!constructor_range_stack); 557790075Sobrien 557890075Sobrien /* Designator list starts at the level of closest explicit 557990075Sobrien braces. */ 558090075Sobrien while (constructor_stack->implicit) 558190075Sobrien process_init_element (pop_init_level (1)); 558290075Sobrien constructor_designated = 1; 558390075Sobrien return 0; 558490075Sobrien } 558590075Sobrien 5586169689Skan switch (TREE_CODE (constructor_type)) 558790075Sobrien { 5588169689Skan case RECORD_TYPE: 5589169689Skan case UNION_TYPE: 559090075Sobrien subtype = TREE_TYPE (constructor_fields); 559190075Sobrien if (subtype != error_mark_node) 559290075Sobrien subtype = TYPE_MAIN_VARIANT (subtype); 5593169689Skan break; 5594169689Skan case ARRAY_TYPE: 559590075Sobrien subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type)); 5596169689Skan break; 5597169689Skan default: 5598169689Skan gcc_unreachable (); 559990075Sobrien } 560090075Sobrien 560190075Sobrien subcode = TREE_CODE (subtype); 560290075Sobrien if (array && subcode != ARRAY_TYPE) 560390075Sobrien { 560490075Sobrien error_init ("array index in non-array initializer"); 560590075Sobrien return 1; 560690075Sobrien } 560790075Sobrien else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE) 560890075Sobrien { 560990075Sobrien error_init ("field name not in record or union initializer"); 561090075Sobrien return 1; 561190075Sobrien } 561290075Sobrien 561390075Sobrien constructor_designated = 1; 561490075Sobrien push_init_level (2); 561590075Sobrien return 0; 561690075Sobrien} 561790075Sobrien 561890075Sobrien/* If there are range designators in designator list, push a new designator 561990075Sobrien to constructor_range_stack. RANGE_END is end of such stack range or 562090075Sobrien NULL_TREE if there is no range designator at this level. */ 562190075Sobrien 562290075Sobrienstatic void 5623132718Skanpush_range_stack (tree range_end) 562490075Sobrien{ 562590075Sobrien struct constructor_range_stack *p; 562690075Sobrien 5627169689Skan p = GGC_NEW (struct constructor_range_stack); 562890075Sobrien p->prev = constructor_range_stack; 562990075Sobrien p->next = 0; 563090075Sobrien p->fields = constructor_fields; 563190075Sobrien p->range_start = constructor_index; 563290075Sobrien p->index = constructor_index; 563390075Sobrien p->stack = constructor_stack; 563490075Sobrien p->range_end = range_end; 563590075Sobrien if (constructor_range_stack) 563690075Sobrien constructor_range_stack->next = p; 563790075Sobrien constructor_range_stack = p; 563890075Sobrien} 563990075Sobrien 564018334Speter/* Within an array initializer, specify the next index to be initialized. 564118334Speter FIRST is that index. If LAST is nonzero, then initialize a range 564218334Speter of indices, running from FIRST through LAST. */ 564318334Speter 564418334Spetervoid 5645132718Skanset_init_index (tree first, tree last) 564618334Speter{ 564790075Sobrien if (set_designator (1)) 564890075Sobrien return; 564990075Sobrien 5650169689Skan designator_erroneous = 1; 565190075Sobrien 5652169689Skan if (!INTEGRAL_TYPE_P (TREE_TYPE (first)) 5653169689Skan || (last && !INTEGRAL_TYPE_P (TREE_TYPE (last)))) 5654169689Skan { 5655169689Skan error_init ("array index in initializer not of integer type"); 5656169689Skan return; 5657169689Skan } 565890075Sobrien 565918334Speter if (TREE_CODE (first) != INTEGER_CST) 566052284Sobrien error_init ("nonconstant array index in initializer"); 566118334Speter else if (last != 0 && TREE_CODE (last) != INTEGER_CST) 566252284Sobrien error_init ("nonconstant array index in initializer"); 566390075Sobrien else if (TREE_CODE (constructor_type) != ARRAY_TYPE) 566452284Sobrien error_init ("array index in non-array initializer"); 5665122180Skan else if (tree_int_cst_sgn (first) == -1) 5666122180Skan error_init ("array index in initializer exceeds array bounds"); 566790075Sobrien else if (constructor_max_index 566890075Sobrien && tree_int_cst_lt (constructor_max_index, first)) 566990075Sobrien error_init ("array index in initializer exceeds array bounds"); 567018334Speter else 567118334Speter { 567290075Sobrien constructor_index = convert (bitsizetype, first); 567318334Speter 567490075Sobrien if (last) 567518334Speter { 567690075Sobrien if (tree_int_cst_equal (first, last)) 567790075Sobrien last = 0; 567890075Sobrien else if (tree_int_cst_lt (last, first)) 567990075Sobrien { 568090075Sobrien error_init ("empty index range in initializer"); 568190075Sobrien last = 0; 568290075Sobrien } 568390075Sobrien else 568490075Sobrien { 568590075Sobrien last = convert (bitsizetype, last); 568690075Sobrien if (constructor_max_index != 0 568790075Sobrien && tree_int_cst_lt (constructor_max_index, last)) 568890075Sobrien { 568990075Sobrien error_init ("array index range in initializer exceeds array bounds"); 569090075Sobrien last = 0; 569190075Sobrien } 569290075Sobrien } 569318334Speter } 569490075Sobrien 569590075Sobrien designator_depth++; 5696169689Skan designator_erroneous = 0; 569790075Sobrien if (constructor_range_stack || last) 569890075Sobrien push_range_stack (last); 569918334Speter } 570018334Speter} 570118334Speter 570218334Speter/* Within a struct initializer, specify the next field to be initialized. */ 570318334Speter 570418334Spetervoid 5705132718Skanset_init_label (tree fieldname) 570618334Speter{ 570718334Speter tree tail; 570818334Speter 570990075Sobrien if (set_designator (0)) 571018334Speter return; 571118334Speter 5712169689Skan designator_erroneous = 1; 571390075Sobrien 571490075Sobrien if (TREE_CODE (constructor_type) != RECORD_TYPE 571590075Sobrien && TREE_CODE (constructor_type) != UNION_TYPE) 571690075Sobrien { 571790075Sobrien error_init ("field name not in record or union initializer"); 571890075Sobrien return; 571990075Sobrien } 5720132718Skan 572118334Speter for (tail = TYPE_FIELDS (constructor_type); tail; 572218334Speter tail = TREE_CHAIN (tail)) 572318334Speter { 572418334Speter if (DECL_NAME (tail) == fieldname) 572518334Speter break; 572618334Speter } 572718334Speter 572818334Speter if (tail == 0) 5729169689Skan error ("unknown field %qE specified in initializer", fieldname); 573018334Speter else 573118334Speter { 573218334Speter constructor_fields = tail; 573390075Sobrien designator_depth++; 5734169689Skan designator_erroneous = 0; 573590075Sobrien if (constructor_range_stack) 573690075Sobrien push_range_stack (NULL_TREE); 573718334Speter } 573818334Speter} 573918334Speter 574050397Sobrien/* Add a new initializer to the tree of pending initializers. PURPOSE 5741132718Skan identifies the initializer, either array index or field in a structure. 574250397Sobrien VALUE is the value of that index or field. */ 574350397Sobrien 574450397Sobrienstatic void 5745132718Skanadd_pending_init (tree purpose, tree value) 574650397Sobrien{ 574750397Sobrien struct init_node *p, **q, *r; 574850397Sobrien 574950397Sobrien q = &constructor_pending_elts; 575050397Sobrien p = 0; 575150397Sobrien 575250397Sobrien if (TREE_CODE (constructor_type) == ARRAY_TYPE) 575350397Sobrien { 575450397Sobrien while (*q != 0) 575550397Sobrien { 575650397Sobrien p = *q; 575750397Sobrien if (tree_int_cst_lt (purpose, p->purpose)) 575850397Sobrien q = &p->left; 575990075Sobrien else if (tree_int_cst_lt (p->purpose, purpose)) 576050397Sobrien q = &p->right; 576150397Sobrien else 576290075Sobrien { 576390075Sobrien if (TREE_SIDE_EFFECTS (p->value)) 576490075Sobrien warning_init ("initialized field with side-effects overwritten"); 5765169689Skan else if (warn_override_init) 5766169689Skan warning_init ("initialized field overwritten"); 576790075Sobrien p->value = value; 576890075Sobrien return; 576990075Sobrien } 577050397Sobrien } 577150397Sobrien } 577250397Sobrien else 577350397Sobrien { 577490075Sobrien tree bitpos; 577590075Sobrien 577690075Sobrien bitpos = bit_position (purpose); 577750397Sobrien while (*q != NULL) 577850397Sobrien { 577950397Sobrien p = *q; 578090075Sobrien if (tree_int_cst_lt (bitpos, bit_position (p->purpose))) 578150397Sobrien q = &p->left; 578260967Sobrien else if (p->purpose != purpose) 578350397Sobrien q = &p->right; 578450397Sobrien else 578590075Sobrien { 578690075Sobrien if (TREE_SIDE_EFFECTS (p->value)) 578790075Sobrien warning_init ("initialized field with side-effects overwritten"); 5788169689Skan else if (warn_override_init) 5789169689Skan warning_init ("initialized field overwritten"); 579090075Sobrien p->value = value; 579190075Sobrien return; 579290075Sobrien } 579350397Sobrien } 579450397Sobrien } 579550397Sobrien 5796169689Skan r = GGC_NEW (struct init_node); 579750397Sobrien r->purpose = purpose; 579850397Sobrien r->value = value; 579950397Sobrien 580050397Sobrien *q = r; 580150397Sobrien r->parent = p; 580250397Sobrien r->left = 0; 580350397Sobrien r->right = 0; 580450397Sobrien r->balance = 0; 580550397Sobrien 580650397Sobrien while (p) 580750397Sobrien { 580850397Sobrien struct init_node *s; 580950397Sobrien 581050397Sobrien if (r == p->left) 581150397Sobrien { 581250397Sobrien if (p->balance == 0) 581350397Sobrien p->balance = -1; 581450397Sobrien else if (p->balance < 0) 581550397Sobrien { 581650397Sobrien if (r->balance < 0) 581750397Sobrien { 581890075Sobrien /* L rotation. */ 581950397Sobrien p->left = r->right; 582050397Sobrien if (p->left) 582150397Sobrien p->left->parent = p; 582250397Sobrien r->right = p; 582350397Sobrien 582450397Sobrien p->balance = 0; 582550397Sobrien r->balance = 0; 582650397Sobrien 582750397Sobrien s = p->parent; 582850397Sobrien p->parent = r; 582950397Sobrien r->parent = s; 583050397Sobrien if (s) 583150397Sobrien { 583250397Sobrien if (s->left == p) 583350397Sobrien s->left = r; 583450397Sobrien else 583550397Sobrien s->right = r; 583650397Sobrien } 583750397Sobrien else 583850397Sobrien constructor_pending_elts = r; 583950397Sobrien } 584050397Sobrien else 584150397Sobrien { 584290075Sobrien /* LR rotation. */ 584350397Sobrien struct init_node *t = r->right; 584450397Sobrien 584550397Sobrien r->right = t->left; 584650397Sobrien if (r->right) 584750397Sobrien r->right->parent = r; 584850397Sobrien t->left = r; 584950397Sobrien 585050397Sobrien p->left = t->right; 585150397Sobrien if (p->left) 585250397Sobrien p->left->parent = p; 585350397Sobrien t->right = p; 585450397Sobrien 585550397Sobrien p->balance = t->balance < 0; 585650397Sobrien r->balance = -(t->balance > 0); 585750397Sobrien t->balance = 0; 585850397Sobrien 585950397Sobrien s = p->parent; 586050397Sobrien p->parent = t; 586150397Sobrien r->parent = t; 586250397Sobrien t->parent = s; 586350397Sobrien if (s) 586450397Sobrien { 586550397Sobrien if (s->left == p) 586650397Sobrien s->left = t; 586750397Sobrien else 586850397Sobrien s->right = t; 586950397Sobrien } 587050397Sobrien else 587150397Sobrien constructor_pending_elts = t; 587250397Sobrien } 587350397Sobrien break; 587450397Sobrien } 587550397Sobrien else 587650397Sobrien { 587750397Sobrien /* p->balance == +1; growth of left side balances the node. */ 587850397Sobrien p->balance = 0; 587950397Sobrien break; 588050397Sobrien } 588150397Sobrien } 588250397Sobrien else /* r == p->right */ 588350397Sobrien { 588450397Sobrien if (p->balance == 0) 588550397Sobrien /* Growth propagation from right side. */ 588650397Sobrien p->balance++; 588750397Sobrien else if (p->balance > 0) 588850397Sobrien { 588950397Sobrien if (r->balance > 0) 589050397Sobrien { 589190075Sobrien /* R rotation. */ 589250397Sobrien p->right = r->left; 589350397Sobrien if (p->right) 589450397Sobrien p->right->parent = p; 589550397Sobrien r->left = p; 589650397Sobrien 589750397Sobrien p->balance = 0; 589850397Sobrien r->balance = 0; 589950397Sobrien 590050397Sobrien s = p->parent; 590150397Sobrien p->parent = r; 590250397Sobrien r->parent = s; 590350397Sobrien if (s) 590450397Sobrien { 590550397Sobrien if (s->left == p) 590650397Sobrien s->left = r; 590750397Sobrien else 590850397Sobrien s->right = r; 590950397Sobrien } 591050397Sobrien else 591150397Sobrien constructor_pending_elts = r; 591250397Sobrien } 591350397Sobrien else /* r->balance == -1 */ 591450397Sobrien { 591550397Sobrien /* RL rotation */ 591650397Sobrien struct init_node *t = r->left; 591750397Sobrien 591850397Sobrien r->left = t->right; 591950397Sobrien if (r->left) 592050397Sobrien r->left->parent = r; 592150397Sobrien t->right = r; 592250397Sobrien 592350397Sobrien p->right = t->left; 592450397Sobrien if (p->right) 592550397Sobrien p->right->parent = p; 592650397Sobrien t->left = p; 592750397Sobrien 592850397Sobrien r->balance = (t->balance < 0); 592950397Sobrien p->balance = -(t->balance > 0); 593050397Sobrien t->balance = 0; 593150397Sobrien 593250397Sobrien s = p->parent; 593350397Sobrien p->parent = t; 593450397Sobrien r->parent = t; 593550397Sobrien t->parent = s; 593650397Sobrien if (s) 593750397Sobrien { 593850397Sobrien if (s->left == p) 593950397Sobrien s->left = t; 594050397Sobrien else 594150397Sobrien s->right = t; 594250397Sobrien } 594350397Sobrien else 594450397Sobrien constructor_pending_elts = t; 594550397Sobrien } 594650397Sobrien break; 594750397Sobrien } 594850397Sobrien else 594950397Sobrien { 595090075Sobrien /* p->balance == -1; growth of right side balances the node. */ 595150397Sobrien p->balance = 0; 595250397Sobrien break; 595350397Sobrien } 595450397Sobrien } 595550397Sobrien 595650397Sobrien r = p; 595750397Sobrien p = p->parent; 595850397Sobrien } 595950397Sobrien} 596050397Sobrien 596190075Sobrien/* Build AVL tree from a sorted chain. */ 596250397Sobrien 596390075Sobrienstatic void 5964132718Skanset_nonincremental_init (void) 596590075Sobrien{ 5966169689Skan unsigned HOST_WIDE_INT ix; 5967169689Skan tree index, value; 596890075Sobrien 596990075Sobrien if (TREE_CODE (constructor_type) != RECORD_TYPE 597090075Sobrien && TREE_CODE (constructor_type) != ARRAY_TYPE) 597190075Sobrien return; 597290075Sobrien 5973169689Skan FOR_EACH_CONSTRUCTOR_ELT (constructor_elements, ix, index, value) 5974169689Skan add_pending_init (index, value); 597590075Sobrien constructor_elements = 0; 597690075Sobrien if (TREE_CODE (constructor_type) == RECORD_TYPE) 597790075Sobrien { 597890075Sobrien constructor_unfilled_fields = TYPE_FIELDS (constructor_type); 597990075Sobrien /* Skip any nameless bit fields at the beginning. */ 598090075Sobrien while (constructor_unfilled_fields != 0 598190075Sobrien && DECL_C_BIT_FIELD (constructor_unfilled_fields) 598290075Sobrien && DECL_NAME (constructor_unfilled_fields) == 0) 598390075Sobrien constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields); 5984132718Skan 598590075Sobrien } 598690075Sobrien else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 598790075Sobrien { 598890075Sobrien if (TYPE_DOMAIN (constructor_type)) 598990075Sobrien constructor_unfilled_index 599090075Sobrien = convert (bitsizetype, 599190075Sobrien TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type))); 599290075Sobrien else 599390075Sobrien constructor_unfilled_index = bitsize_zero_node; 599490075Sobrien } 599590075Sobrien constructor_incremental = 0; 599690075Sobrien} 599790075Sobrien 599890075Sobrien/* Build AVL tree from a string constant. */ 599990075Sobrien 600090075Sobrienstatic void 6001132718Skanset_nonincremental_init_from_string (tree str) 600290075Sobrien{ 600390075Sobrien tree value, purpose, type; 600490075Sobrien HOST_WIDE_INT val[2]; 600590075Sobrien const char *p, *end; 600690075Sobrien int byte, wchar_bytes, charwidth, bitpos; 600790075Sobrien 6008169689Skan gcc_assert (TREE_CODE (constructor_type) == ARRAY_TYPE); 600990075Sobrien 601090075Sobrien if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str))) 601190075Sobrien == TYPE_PRECISION (char_type_node)) 601290075Sobrien wchar_bytes = 1; 601390075Sobrien else 6014169689Skan { 6015169689Skan gcc_assert (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str))) 6016169689Skan == TYPE_PRECISION (wchar_type_node)); 6017169689Skan wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT; 6018169689Skan } 601990075Sobrien charwidth = TYPE_PRECISION (char_type_node); 602090075Sobrien type = TREE_TYPE (constructor_type); 602190075Sobrien p = TREE_STRING_POINTER (str); 602290075Sobrien end = p + TREE_STRING_LENGTH (str); 602390075Sobrien 602490075Sobrien for (purpose = bitsize_zero_node; 602590075Sobrien p < end && !tree_int_cst_lt (constructor_max_index, purpose); 602690075Sobrien purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node)) 602790075Sobrien { 602890075Sobrien if (wchar_bytes == 1) 602990075Sobrien { 603090075Sobrien val[1] = (unsigned char) *p++; 603190075Sobrien val[0] = 0; 603290075Sobrien } 603390075Sobrien else 603490075Sobrien { 603590075Sobrien val[0] = 0; 603690075Sobrien val[1] = 0; 603790075Sobrien for (byte = 0; byte < wchar_bytes; byte++) 603890075Sobrien { 603990075Sobrien if (BYTES_BIG_ENDIAN) 604090075Sobrien bitpos = (wchar_bytes - byte - 1) * charwidth; 604190075Sobrien else 604290075Sobrien bitpos = byte * charwidth; 604390075Sobrien val[bitpos < HOST_BITS_PER_WIDE_INT] 604490075Sobrien |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++)) 604590075Sobrien << (bitpos % HOST_BITS_PER_WIDE_INT); 604690075Sobrien } 604790075Sobrien } 604890075Sobrien 6049169689Skan if (!TYPE_UNSIGNED (type)) 605090075Sobrien { 605190075Sobrien bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR; 605290075Sobrien if (bitpos < HOST_BITS_PER_WIDE_INT) 605390075Sobrien { 605490075Sobrien if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1))) 605590075Sobrien { 605690075Sobrien val[1] |= ((HOST_WIDE_INT) -1) << bitpos; 605790075Sobrien val[0] = -1; 605890075Sobrien } 605990075Sobrien } 606090075Sobrien else if (bitpos == HOST_BITS_PER_WIDE_INT) 606190075Sobrien { 606290075Sobrien if (val[1] < 0) 6063169689Skan val[0] = -1; 606490075Sobrien } 606590075Sobrien else if (val[0] & (((HOST_WIDE_INT) 1) 606690075Sobrien << (bitpos - 1 - HOST_BITS_PER_WIDE_INT))) 606790075Sobrien val[0] |= ((HOST_WIDE_INT) -1) 606890075Sobrien << (bitpos - HOST_BITS_PER_WIDE_INT); 606990075Sobrien } 607090075Sobrien 6071169689Skan value = build_int_cst_wide (type, val[1], val[0]); 607290075Sobrien add_pending_init (purpose, value); 607390075Sobrien } 607490075Sobrien 607590075Sobrien constructor_incremental = 0; 607690075Sobrien} 607790075Sobrien 607890075Sobrien/* Return value of FIELD in pending initializer or zero if the field was 607990075Sobrien not initialized yet. */ 608090075Sobrien 608190075Sobrienstatic tree 6082132718Skanfind_init_member (tree field) 608350397Sobrien{ 608450397Sobrien struct init_node *p; 608550397Sobrien 608650397Sobrien if (TREE_CODE (constructor_type) == ARRAY_TYPE) 608750397Sobrien { 608890075Sobrien if (constructor_incremental 608990075Sobrien && tree_int_cst_lt (field, constructor_unfilled_index)) 609090075Sobrien set_nonincremental_init (); 609190075Sobrien 609290075Sobrien p = constructor_pending_elts; 609350397Sobrien while (p) 609450397Sobrien { 609590075Sobrien if (tree_int_cst_lt (field, p->purpose)) 609650397Sobrien p = p->left; 609790075Sobrien else if (tree_int_cst_lt (p->purpose, field)) 609890075Sobrien p = p->right; 609950397Sobrien else 610090075Sobrien return p->value; 610150397Sobrien } 610250397Sobrien } 610390075Sobrien else if (TREE_CODE (constructor_type) == RECORD_TYPE) 610450397Sobrien { 610590075Sobrien tree bitpos = bit_position (field); 610690075Sobrien 610790075Sobrien if (constructor_incremental 610890075Sobrien && (!constructor_unfilled_fields 610990075Sobrien || tree_int_cst_lt (bitpos, 611090075Sobrien bit_position (constructor_unfilled_fields)))) 611190075Sobrien set_nonincremental_init (); 611290075Sobrien 611390075Sobrien p = constructor_pending_elts; 611450397Sobrien while (p) 611550397Sobrien { 611650397Sobrien if (field == p->purpose) 611790075Sobrien return p->value; 611890075Sobrien else if (tree_int_cst_lt (bitpos, bit_position (p->purpose))) 611950397Sobrien p = p->left; 612050397Sobrien else 612150397Sobrien p = p->right; 612250397Sobrien } 612350397Sobrien } 612490075Sobrien else if (TREE_CODE (constructor_type) == UNION_TYPE) 612590075Sobrien { 6126169689Skan if (!VEC_empty (constructor_elt, constructor_elements) 6127169689Skan && (VEC_last (constructor_elt, constructor_elements)->index 6128169689Skan == field)) 6129169689Skan return VEC_last (constructor_elt, constructor_elements)->value; 613090075Sobrien } 613150397Sobrien return 0; 613250397Sobrien} 613350397Sobrien 613418334Speter/* "Output" the next constructor element. 613518334Speter At top level, really output it to assembler code now. 613618334Speter Otherwise, collect it in a list from which we will make a CONSTRUCTOR. 613718334Speter TYPE is the data type that the containing data type wants here. 613818334Speter FIELD is the field (a FIELD_DECL) or the index that this element fills. 6139169689Skan If VALUE is a string constant, STRICT_STRING is true if it is 6140169689Skan unparenthesized or we should not warn here for it being parenthesized. 6141169689Skan For other types of VALUE, STRICT_STRING is not used. 614218334Speter 614318334Speter PENDING if non-nil means output pending elements that belong 614418334Speter right after this element. (PENDING is normally 1; 614518334Speter it is 0 while outputting pending elements, to avoid recursion.) */ 614618334Speter 614718334Speterstatic void 6148169689Skanoutput_init_element (tree value, bool strict_string, tree type, tree field, 6149169689Skan int pending) 615018334Speter{ 6151169689Skan constructor_elt *celt; 6152169689Skan 6153169689Skan if (type == error_mark_node || value == error_mark_node) 6154132718Skan { 6155132718Skan constructor_erroneous = 1; 6156132718Skan return; 6157132718Skan } 6158169689Skan if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE 6159169689Skan && (TREE_CODE (value) == STRING_CST 6160169689Skan || TREE_CODE (value) == COMPOUND_LITERAL_EXPR) 6161169689Skan && !(TREE_CODE (value) == STRING_CST 6162169689Skan && TREE_CODE (type) == ARRAY_TYPE 6163169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (type))) 6164169689Skan && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)), 6165169689Skan TYPE_MAIN_VARIANT (type))) 6166169689Skan value = array_to_pointer_conversion (value); 616718334Speter 616890075Sobrien if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR 616990075Sobrien && require_constant_value && !flag_isoc99 && pending) 617090075Sobrien { 617190075Sobrien /* As an extension, allow initializing objects with static storage 617290075Sobrien duration with compound literals (which are then treated just as 617390075Sobrien the brace enclosed list they contain). */ 617490075Sobrien tree decl = COMPOUND_LITERAL_EXPR_DECL (value); 617590075Sobrien value = DECL_INITIAL (decl); 617690075Sobrien } 617790075Sobrien 617818334Speter if (value == error_mark_node) 617918334Speter constructor_erroneous = 1; 618018334Speter else if (!TREE_CONSTANT (value)) 618118334Speter constructor_constant = 0; 6182169689Skan else if (!initializer_constant_valid_p (value, TREE_TYPE (value)) 618318334Speter || ((TREE_CODE (constructor_type) == RECORD_TYPE 618418334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 618550397Sobrien && DECL_C_BIT_FIELD (field) 618650397Sobrien && TREE_CODE (value) != INTEGER_CST)) 618718334Speter constructor_simple = 0; 618818334Speter 6189169689Skan if (!initializer_constant_valid_p (value, TREE_TYPE (value))) 619018334Speter { 6191169689Skan if (require_constant_value) 6192169689Skan { 6193169689Skan error_init ("initializer element is not constant"); 6194169689Skan value = error_mark_node; 6195169689Skan } 6196169689Skan else if (require_constant_elements) 6197169689Skan pedwarn ("initializer element is not computable at load time"); 619818334Speter } 619918334Speter 620090075Sobrien /* If this field is empty (and not at the end of structure), 620190075Sobrien don't do anything other than checking the initializer. */ 620290075Sobrien if (field 620390075Sobrien && (TREE_TYPE (field) == error_mark_node 620490075Sobrien || (COMPLETE_TYPE_P (TREE_TYPE (field)) 620590075Sobrien && integer_zerop (TYPE_SIZE (TREE_TYPE (field))) 620690075Sobrien && (TREE_CODE (constructor_type) == ARRAY_TYPE 620790075Sobrien || TREE_CHAIN (field))))) 620890075Sobrien return; 620990075Sobrien 6210169689Skan value = digest_init (type, value, strict_string, require_constant_value); 621190075Sobrien if (value == error_mark_node) 621218334Speter { 621390075Sobrien constructor_erroneous = 1; 621490075Sobrien return; 621518334Speter } 621618334Speter 621718334Speter /* If this element doesn't come next in sequence, 621818334Speter put it on constructor_pending_elts. */ 621918334Speter if (TREE_CODE (constructor_type) == ARRAY_TYPE 622090075Sobrien && (!constructor_incremental 622190075Sobrien || !tree_int_cst_equal (field, constructor_unfilled_index))) 622218334Speter { 622390075Sobrien if (constructor_incremental 622490075Sobrien && tree_int_cst_lt (field, constructor_unfilled_index)) 622590075Sobrien set_nonincremental_init (); 622690075Sobrien 622790075Sobrien add_pending_init (field, value); 622890075Sobrien return; 622918334Speter } 623018334Speter else if (TREE_CODE (constructor_type) == RECORD_TYPE 623190075Sobrien && (!constructor_incremental 623290075Sobrien || field != constructor_unfilled_fields)) 623318334Speter { 623418334Speter /* We do this for records but not for unions. In a union, 623518334Speter no matter which field is specified, it can be initialized 623618334Speter right away since it starts at the beginning of the union. */ 623790075Sobrien if (constructor_incremental) 623818334Speter { 623990075Sobrien if (!constructor_unfilled_fields) 624090075Sobrien set_nonincremental_init (); 624118334Speter else 624218334Speter { 624390075Sobrien tree bitpos, unfillpos; 624418334Speter 624590075Sobrien bitpos = bit_position (field); 624690075Sobrien unfillpos = bit_position (constructor_unfilled_fields); 624718334Speter 624890075Sobrien if (tree_int_cst_lt (bitpos, unfillpos)) 624990075Sobrien set_nonincremental_init (); 625018334Speter } 625118334Speter } 625218334Speter 625390075Sobrien add_pending_init (field, value); 625490075Sobrien return; 625590075Sobrien } 625690075Sobrien else if (TREE_CODE (constructor_type) == UNION_TYPE 6257169689Skan && !VEC_empty (constructor_elt, constructor_elements)) 625890075Sobrien { 6259169689Skan if (TREE_SIDE_EFFECTS (VEC_last (constructor_elt, 6260169689Skan constructor_elements)->value)) 626190075Sobrien warning_init ("initialized field with side-effects overwritten"); 6262169689Skan else if (warn_override_init) 6263169689Skan warning_init ("initialized field overwritten"); 626418334Speter 626590075Sobrien /* We can have just one union field set. */ 626690075Sobrien constructor_elements = 0; 626718334Speter } 626890075Sobrien 626990075Sobrien /* Otherwise, output this element either to 627090075Sobrien constructor_elements or to the assembler file. */ 627190075Sobrien 6272169689Skan celt = VEC_safe_push (constructor_elt, gc, constructor_elements, NULL); 6273169689Skan celt->index = field; 6274169689Skan celt->value = value; 627590075Sobrien 627690075Sobrien /* Advance the variable that indicates sequential elements output. */ 627790075Sobrien if (TREE_CODE (constructor_type) == ARRAY_TYPE) 627890075Sobrien constructor_unfilled_index 627990075Sobrien = size_binop (PLUS_EXPR, constructor_unfilled_index, 628090075Sobrien bitsize_one_node); 628190075Sobrien else if (TREE_CODE (constructor_type) == RECORD_TYPE) 628290075Sobrien { 628390075Sobrien constructor_unfilled_fields 628490075Sobrien = TREE_CHAIN (constructor_unfilled_fields); 628590075Sobrien 628690075Sobrien /* Skip any nameless bit fields. */ 628790075Sobrien while (constructor_unfilled_fields != 0 628890075Sobrien && DECL_C_BIT_FIELD (constructor_unfilled_fields) 628990075Sobrien && DECL_NAME (constructor_unfilled_fields) == 0) 629090075Sobrien constructor_unfilled_fields = 629190075Sobrien TREE_CHAIN (constructor_unfilled_fields); 629290075Sobrien } 629390075Sobrien else if (TREE_CODE (constructor_type) == UNION_TYPE) 629490075Sobrien constructor_unfilled_fields = 0; 629590075Sobrien 629690075Sobrien /* Now output any pending elements which have become next. */ 629790075Sobrien if (pending) 629890075Sobrien output_pending_init_elements (0); 629918334Speter} 630018334Speter 630118334Speter/* Output any pending elements which have become next. 630218334Speter As we output elements, constructor_unfilled_{fields,index} 630318334Speter advances, which may cause other elements to become next; 630418334Speter if so, they too are output. 630518334Speter 630618334Speter If ALL is 0, we return when there are 630718334Speter no more pending elements to output now. 630818334Speter 630918334Speter If ALL is 1, we output space as necessary so that 631018334Speter we can output all the pending elements. */ 631118334Speter 631218334Speterstatic void 6313132718Skanoutput_pending_init_elements (int all) 631418334Speter{ 631550397Sobrien struct init_node *elt = constructor_pending_elts; 631618334Speter tree next; 631718334Speter 631818334Speter retry: 631918334Speter 6320132718Skan /* Look through the whole pending tree. 632118334Speter If we find an element that should be output now, 632218334Speter output it. Otherwise, set NEXT to the element 632318334Speter that comes first among those still pending. */ 6324132718Skan 632518334Speter next = 0; 632650397Sobrien while (elt) 632718334Speter { 632818334Speter if (TREE_CODE (constructor_type) == ARRAY_TYPE) 632918334Speter { 633050397Sobrien if (tree_int_cst_equal (elt->purpose, 633118334Speter constructor_unfilled_index)) 6332169689Skan output_init_element (elt->value, true, 633350397Sobrien TREE_TYPE (constructor_type), 633450397Sobrien constructor_unfilled_index, 0); 633550397Sobrien else if (tree_int_cst_lt (constructor_unfilled_index, 633650397Sobrien elt->purpose)) 633718334Speter { 633850397Sobrien /* Advance to the next smaller node. */ 633950397Sobrien if (elt->left) 634050397Sobrien elt = elt->left; 634150397Sobrien else 634250397Sobrien { 634350397Sobrien /* We have reached the smallest node bigger than the 634450397Sobrien current unfilled index. Fill the space first. */ 634550397Sobrien next = elt->purpose; 634650397Sobrien break; 634750397Sobrien } 634818334Speter } 634950397Sobrien else 635050397Sobrien { 635150397Sobrien /* Advance to the next bigger node. */ 635250397Sobrien if (elt->right) 635350397Sobrien elt = elt->right; 635450397Sobrien else 635550397Sobrien { 635650397Sobrien /* We have reached the biggest node in a subtree. Find 635750397Sobrien the parent of it, which is the next bigger node. */ 635850397Sobrien while (elt->parent && elt->parent->right == elt) 635950397Sobrien elt = elt->parent; 636050397Sobrien elt = elt->parent; 636150397Sobrien if (elt && tree_int_cst_lt (constructor_unfilled_index, 636250397Sobrien elt->purpose)) 636350397Sobrien { 636450397Sobrien next = elt->purpose; 636550397Sobrien break; 636650397Sobrien } 636750397Sobrien } 636850397Sobrien } 636918334Speter } 637018334Speter else if (TREE_CODE (constructor_type) == RECORD_TYPE 637118334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 637218334Speter { 637390075Sobrien tree ctor_unfilled_bitpos, elt_bitpos; 637490075Sobrien 637550397Sobrien /* If the current record is complete we are done. */ 637650397Sobrien if (constructor_unfilled_fields == 0) 637750397Sobrien break; 637890075Sobrien 637990075Sobrien ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields); 638090075Sobrien elt_bitpos = bit_position (elt->purpose); 638190075Sobrien /* We can't compare fields here because there might be empty 638290075Sobrien fields in between. */ 638390075Sobrien if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos)) 638418334Speter { 638590075Sobrien constructor_unfilled_fields = elt->purpose; 6386169689Skan output_init_element (elt->value, true, TREE_TYPE (elt->purpose), 638790075Sobrien elt->purpose, 0); 638818334Speter } 638990075Sobrien else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos)) 639050397Sobrien { 639150397Sobrien /* Advance to the next smaller node. */ 639250397Sobrien if (elt->left) 639350397Sobrien elt = elt->left; 639450397Sobrien else 639550397Sobrien { 639650397Sobrien /* We have reached the smallest node bigger than the 639750397Sobrien current unfilled field. Fill the space first. */ 639850397Sobrien next = elt->purpose; 639950397Sobrien break; 640050397Sobrien } 640150397Sobrien } 640250397Sobrien else 640350397Sobrien { 640450397Sobrien /* Advance to the next bigger node. */ 640550397Sobrien if (elt->right) 640650397Sobrien elt = elt->right; 640750397Sobrien else 640850397Sobrien { 640950397Sobrien /* We have reached the biggest node in a subtree. Find 641050397Sobrien the parent of it, which is the next bigger node. */ 641150397Sobrien while (elt->parent && elt->parent->right == elt) 641250397Sobrien elt = elt->parent; 641350397Sobrien elt = elt->parent; 641450397Sobrien if (elt 641590075Sobrien && (tree_int_cst_lt (ctor_unfilled_bitpos, 641690075Sobrien bit_position (elt->purpose)))) 641750397Sobrien { 641850397Sobrien next = elt->purpose; 641950397Sobrien break; 642050397Sobrien } 642150397Sobrien } 642250397Sobrien } 642318334Speter } 642418334Speter } 642518334Speter 642618334Speter /* Ordinarily return, but not if we want to output all 642718334Speter and there are elements left. */ 6428169689Skan if (!(all && next != 0)) 642918334Speter return; 643018334Speter 643190075Sobrien /* If it's not incremental, just skip over the gap, so that after 643290075Sobrien jumping to retry we will output the next successive element. */ 643390075Sobrien if (TREE_CODE (constructor_type) == RECORD_TYPE 643490075Sobrien || TREE_CODE (constructor_type) == UNION_TYPE) 643590075Sobrien constructor_unfilled_fields = next; 643690075Sobrien else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 643790075Sobrien constructor_unfilled_index = next; 643818334Speter 643950397Sobrien /* ELT now points to the node in the pending tree with the next 644050397Sobrien initializer to output. */ 644118334Speter goto retry; 644218334Speter} 644318334Speter 644418334Speter/* Add one non-braced element to the current constructor level. 644518334Speter This adjusts the current position within the constructor's type. 644618334Speter This may also start or terminate implicit levels 644718334Speter to handle a partly-braced initializer. 644818334Speter 644918334Speter Once this has found the correct level for the new element, 645090075Sobrien it calls output_init_element. */ 645118334Speter 645218334Spetervoid 6453169689Skanprocess_init_element (struct c_expr value) 645418334Speter{ 6455169689Skan tree orig_value = value.value; 6456169689Skan int string_flag = orig_value != 0 && TREE_CODE (orig_value) == STRING_CST; 6457169689Skan bool strict_string = value.original_code == STRING_CST; 645818334Speter 645990075Sobrien designator_depth = 0; 6460169689Skan designator_erroneous = 0; 646190075Sobrien 646218334Speter /* Handle superfluous braces around string cst as in 646318334Speter char x[] = {"foo"}; */ 646418334Speter if (string_flag 646518334Speter && constructor_type 646618334Speter && TREE_CODE (constructor_type) == ARRAY_TYPE 6467169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type)) 646818334Speter && integer_zerop (constructor_unfilled_index)) 646918334Speter { 6470169689Skan if (constructor_stack->replacement_value.value) 6471169689Skan error_init ("excess elements in char array initializer"); 647218334Speter constructor_stack->replacement_value = value; 647318334Speter return; 647418334Speter } 647518334Speter 6476169689Skan if (constructor_stack->replacement_value.value != 0) 647718334Speter { 647852284Sobrien error_init ("excess elements in struct initializer"); 647918334Speter return; 648018334Speter } 648118334Speter 648218334Speter /* Ignore elements of a brace group if it is entirely superfluous 648318334Speter and has already been diagnosed. */ 648418334Speter if (constructor_type == 0) 648518334Speter return; 648618334Speter 648718334Speter /* If we've exhausted any levels that didn't have braces, 648818334Speter pop them now. */ 648918334Speter while (constructor_stack->implicit) 649018334Speter { 649118334Speter if ((TREE_CODE (constructor_type) == RECORD_TYPE 649218334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 649318334Speter && constructor_fields == 0) 649418334Speter process_init_element (pop_init_level (1)); 649518334Speter else if (TREE_CODE (constructor_type) == ARRAY_TYPE 649650397Sobrien && (constructor_max_index == 0 649750397Sobrien || tree_int_cst_lt (constructor_max_index, 649850397Sobrien constructor_index))) 649918334Speter process_init_element (pop_init_level (1)); 650018334Speter else 650118334Speter break; 650218334Speter } 650318334Speter 650490075Sobrien /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */ 650590075Sobrien if (constructor_range_stack) 650690075Sobrien { 650790075Sobrien /* If value is a compound literal and we'll be just using its 650890075Sobrien content, don't put it into a SAVE_EXPR. */ 6509169689Skan if (TREE_CODE (value.value) != COMPOUND_LITERAL_EXPR 651090075Sobrien || !require_constant_value 651190075Sobrien || flag_isoc99) 6512169689Skan value.value = save_expr (value.value); 651390075Sobrien } 651490075Sobrien 651518334Speter while (1) 651618334Speter { 651718334Speter if (TREE_CODE (constructor_type) == RECORD_TYPE) 651818334Speter { 651918334Speter tree fieldtype; 652018334Speter enum tree_code fieldcode; 652118334Speter 652218334Speter if (constructor_fields == 0) 652318334Speter { 652452284Sobrien pedwarn_init ("excess elements in struct initializer"); 652518334Speter break; 652618334Speter } 652718334Speter 652818334Speter fieldtype = TREE_TYPE (constructor_fields); 652918334Speter if (fieldtype != error_mark_node) 653018334Speter fieldtype = TYPE_MAIN_VARIANT (fieldtype); 653118334Speter fieldcode = TREE_CODE (fieldtype); 653218334Speter 653396263Sobrien /* Error for non-static initialization of a flexible array member. */ 653496263Sobrien if (fieldcode == ARRAY_TYPE 653596263Sobrien && !require_constant_value 653696263Sobrien && TYPE_SIZE (fieldtype) == NULL_TREE 653796263Sobrien && TREE_CHAIN (constructor_fields) == NULL_TREE) 653896263Sobrien { 653996263Sobrien error_init ("non-static initialization of a flexible array member"); 654096263Sobrien break; 654196263Sobrien } 654296263Sobrien 654318334Speter /* Accept a string constant to initialize a subarray. */ 6544169689Skan if (value.value != 0 654518334Speter && fieldcode == ARRAY_TYPE 6546169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype)) 654718334Speter && string_flag) 6548169689Skan value.value = orig_value; 654918334Speter /* Otherwise, if we have come to a subaggregate, 655018334Speter and we don't have an element of its type, push into it. */ 6551169689Skan else if (value.value != 0 6552169689Skan && value.value != error_mark_node 6553169689Skan && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype 655418334Speter && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE 655518334Speter || fieldcode == UNION_TYPE)) 655618334Speter { 655718334Speter push_init_level (1); 655818334Speter continue; 655918334Speter } 656018334Speter 6561169689Skan if (value.value) 656218334Speter { 656318334Speter push_member_name (constructor_fields); 6564169689Skan output_init_element (value.value, strict_string, 6565169689Skan fieldtype, constructor_fields, 1); 656618334Speter RESTORE_SPELLING_DEPTH (constructor_depth); 656718334Speter } 656818334Speter else 656918334Speter /* Do the bookkeeping for an element that was 657018334Speter directly output as a constructor. */ 657118334Speter { 657218334Speter /* For a record, keep track of end position of last field. */ 657390075Sobrien if (DECL_SIZE (constructor_fields)) 6574169689Skan constructor_bit_index 657590075Sobrien = size_binop (PLUS_EXPR, 6576169689Skan bit_position (constructor_fields), 6577169689Skan DECL_SIZE (constructor_fields)); 657818334Speter 6579110611Skan /* If the current field was the first one not yet written out, 6580110611Skan it isn't now, so update. */ 6581110611Skan if (constructor_unfilled_fields == constructor_fields) 6582110611Skan { 6583110611Skan constructor_unfilled_fields = TREE_CHAIN (constructor_fields); 6584110611Skan /* Skip any nameless bit fields. */ 6585110611Skan while (constructor_unfilled_fields != 0 6586110611Skan && DECL_C_BIT_FIELD (constructor_unfilled_fields) 6587110611Skan && DECL_NAME (constructor_unfilled_fields) == 0) 6588110611Skan constructor_unfilled_fields = 6589110611Skan TREE_CHAIN (constructor_unfilled_fields); 6590110611Skan } 659118334Speter } 659218334Speter 659318334Speter constructor_fields = TREE_CHAIN (constructor_fields); 659418334Speter /* Skip any nameless bit fields at the beginning. */ 659550397Sobrien while (constructor_fields != 0 659650397Sobrien && DECL_C_BIT_FIELD (constructor_fields) 659718334Speter && DECL_NAME (constructor_fields) == 0) 659818334Speter constructor_fields = TREE_CHAIN (constructor_fields); 659918334Speter } 660090075Sobrien else if (TREE_CODE (constructor_type) == UNION_TYPE) 660118334Speter { 660218334Speter tree fieldtype; 660318334Speter enum tree_code fieldcode; 660418334Speter 660518334Speter if (constructor_fields == 0) 660618334Speter { 660752284Sobrien pedwarn_init ("excess elements in union initializer"); 660818334Speter break; 660918334Speter } 661018334Speter 661118334Speter fieldtype = TREE_TYPE (constructor_fields); 661218334Speter if (fieldtype != error_mark_node) 661318334Speter fieldtype = TYPE_MAIN_VARIANT (fieldtype); 661418334Speter fieldcode = TREE_CODE (fieldtype); 661518334Speter 661690075Sobrien /* Warn that traditional C rejects initialization of unions. 661790075Sobrien We skip the warning if the value is zero. This is done 661890075Sobrien under the assumption that the zero initializer in user 661990075Sobrien code appears conditioned on e.g. __STDC__ to avoid 662090075Sobrien "missing initializer" warnings and relies on default 662190075Sobrien initialization to zero in the traditional C case. 662290075Sobrien We also skip the warning if the initializer is designated, 662390075Sobrien again on the assumption that this must be conditional on 662490075Sobrien __STDC__ anyway (and we've already complained about the 662590075Sobrien member-designator already). */ 6626169689Skan if (!in_system_header && !constructor_designated 6627169689Skan && !(value.value && (integer_zerop (value.value) 6628169689Skan || real_zerop (value.value)))) 6629169689Skan warning (OPT_Wtraditional, "traditional C rejects initialization " 6630169689Skan "of unions"); 663190075Sobrien 663218334Speter /* Accept a string constant to initialize a subarray. */ 6633169689Skan if (value.value != 0 663418334Speter && fieldcode == ARRAY_TYPE 6635169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype)) 663618334Speter && string_flag) 6637169689Skan value.value = orig_value; 663818334Speter /* Otherwise, if we have come to a subaggregate, 663918334Speter and we don't have an element of its type, push into it. */ 6640169689Skan else if (value.value != 0 6641169689Skan && value.value != error_mark_node 6642169689Skan && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype 664318334Speter && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE 664418334Speter || fieldcode == UNION_TYPE)) 664518334Speter { 664618334Speter push_init_level (1); 664718334Speter continue; 664818334Speter } 664918334Speter 6650169689Skan if (value.value) 665118334Speter { 665218334Speter push_member_name (constructor_fields); 6653169689Skan output_init_element (value.value, strict_string, 6654169689Skan fieldtype, constructor_fields, 1); 665518334Speter RESTORE_SPELLING_DEPTH (constructor_depth); 665618334Speter } 665718334Speter else 665818334Speter /* Do the bookkeeping for an element that was 665918334Speter directly output as a constructor. */ 666018334Speter { 666190075Sobrien constructor_bit_index = DECL_SIZE (constructor_fields); 666218334Speter constructor_unfilled_fields = TREE_CHAIN (constructor_fields); 666318334Speter } 666418334Speter 666518334Speter constructor_fields = 0; 666618334Speter } 666790075Sobrien else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 666818334Speter { 666918334Speter tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type)); 667018334Speter enum tree_code eltcode = TREE_CODE (elttype); 667118334Speter 667218334Speter /* Accept a string constant to initialize a subarray. */ 6673169689Skan if (value.value != 0 667418334Speter && eltcode == ARRAY_TYPE 6675169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (elttype)) 667618334Speter && string_flag) 6677169689Skan value.value = orig_value; 667818334Speter /* Otherwise, if we have come to a subaggregate, 667918334Speter and we don't have an element of its type, push into it. */ 6680169689Skan else if (value.value != 0 6681169689Skan && value.value != error_mark_node 6682169689Skan && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != elttype 668318334Speter && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE 668418334Speter || eltcode == UNION_TYPE)) 668518334Speter { 668618334Speter push_init_level (1); 668718334Speter continue; 668818334Speter } 668918334Speter 669018334Speter if (constructor_max_index != 0 669190075Sobrien && (tree_int_cst_lt (constructor_max_index, constructor_index) 669290075Sobrien || integer_all_onesp (constructor_max_index))) 669318334Speter { 669452284Sobrien pedwarn_init ("excess elements in array initializer"); 669518334Speter break; 669618334Speter } 669718334Speter 669890075Sobrien /* Now output the actual element. */ 6699169689Skan if (value.value) 670050397Sobrien { 6701169689Skan push_array_bounds (tree_low_cst (constructor_index, 1)); 6702169689Skan output_init_element (value.value, strict_string, 6703169689Skan elttype, constructor_index, 1); 670490075Sobrien RESTORE_SPELLING_DEPTH (constructor_depth); 670550397Sobrien } 670650397Sobrien 670790075Sobrien constructor_index 670890075Sobrien = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node); 670918334Speter 6710169689Skan if (!value.value) 671190075Sobrien /* If we are doing the bookkeeping for an element that was 671290075Sobrien directly output as a constructor, we must update 671390075Sobrien constructor_unfilled_index. */ 671490075Sobrien constructor_unfilled_index = constructor_index; 671518334Speter } 671696263Sobrien else if (TREE_CODE (constructor_type) == VECTOR_TYPE) 671796263Sobrien { 671896263Sobrien tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type)); 671918334Speter 6720169689Skan /* Do a basic check of initializer size. Note that vectors 6721169689Skan always have a fixed size derived from their type. */ 672296263Sobrien if (tree_int_cst_lt (constructor_max_index, constructor_index)) 672396263Sobrien { 672496263Sobrien pedwarn_init ("excess elements in vector initializer"); 672596263Sobrien break; 672696263Sobrien } 672796263Sobrien 672896263Sobrien /* Now output the actual element. */ 6729169689Skan if (value.value) 6730169689Skan output_init_element (value.value, strict_string, 6731169689Skan elttype, constructor_index, 1); 673296263Sobrien 673396263Sobrien constructor_index 673496263Sobrien = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node); 673596263Sobrien 6736169689Skan if (!value.value) 673796263Sobrien /* If we are doing the bookkeeping for an element that was 673896263Sobrien directly output as a constructor, we must update 673996263Sobrien constructor_unfilled_index. */ 674096263Sobrien constructor_unfilled_index = constructor_index; 674196263Sobrien } 674296263Sobrien 674318334Speter /* Handle the sole element allowed in a braced initializer 674418334Speter for a scalar variable. */ 6745169689Skan else if (constructor_type != error_mark_node 6746169689Skan && constructor_fields == 0) 674718334Speter { 674852284Sobrien pedwarn_init ("excess elements in scalar initializer"); 674918334Speter break; 675018334Speter } 675190075Sobrien else 675290075Sobrien { 6753169689Skan if (value.value) 6754169689Skan output_init_element (value.value, strict_string, 6755169689Skan constructor_type, NULL_TREE, 1); 675690075Sobrien constructor_fields = 0; 675790075Sobrien } 675818334Speter 675990075Sobrien /* Handle range initializers either at this level or anywhere higher 676090075Sobrien in the designator stack. */ 676190075Sobrien if (constructor_range_stack) 676290075Sobrien { 676390075Sobrien struct constructor_range_stack *p, *range_stack; 676490075Sobrien int finish = 0; 676590075Sobrien 676690075Sobrien range_stack = constructor_range_stack; 676790075Sobrien constructor_range_stack = 0; 676890075Sobrien while (constructor_stack != range_stack->stack) 676990075Sobrien { 6770169689Skan gcc_assert (constructor_stack->implicit); 677190075Sobrien process_init_element (pop_init_level (1)); 677290075Sobrien } 677390075Sobrien for (p = range_stack; 677490075Sobrien !p->range_end || tree_int_cst_equal (p->index, p->range_end); 677590075Sobrien p = p->prev) 677690075Sobrien { 6777169689Skan gcc_assert (constructor_stack->implicit); 677890075Sobrien process_init_element (pop_init_level (1)); 677990075Sobrien } 678090075Sobrien 678190075Sobrien p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node); 678290075Sobrien if (tree_int_cst_equal (p->index, p->range_end) && !p->prev) 678390075Sobrien finish = 1; 678490075Sobrien 678590075Sobrien while (1) 678690075Sobrien { 678790075Sobrien constructor_index = p->index; 678890075Sobrien constructor_fields = p->fields; 678990075Sobrien if (finish && p->range_end && p->index == p->range_start) 679090075Sobrien { 679190075Sobrien finish = 0; 679290075Sobrien p->prev = 0; 679390075Sobrien } 679490075Sobrien p = p->next; 679590075Sobrien if (!p) 679690075Sobrien break; 679790075Sobrien push_init_level (2); 679890075Sobrien p->stack = constructor_stack; 679990075Sobrien if (p->range_end && tree_int_cst_equal (p->index, p->range_end)) 680090075Sobrien p->index = p->range_start; 680190075Sobrien } 680290075Sobrien 680390075Sobrien if (!finish) 680490075Sobrien constructor_range_stack = range_stack; 680590075Sobrien continue; 680690075Sobrien } 680790075Sobrien 680818334Speter break; 680918334Speter } 681018334Speter 681190075Sobrien constructor_range_stack = 0; 681218334Speter} 681318334Speter 6814169689Skan/* Build a complete asm-statement, whose components are a CV_QUALIFIER 6815169689Skan (guaranteed to be 'volatile' or null) and ARGS (represented using 6816169689Skan an ASM_EXPR node). */ 681790075Sobrientree 6818169689Skanbuild_asm_stmt (tree cv_qualifier, tree args) 681990075Sobrien{ 6820169689Skan if (!ASM_VOLATILE_P (args) && cv_qualifier) 6821169689Skan ASM_VOLATILE_P (args) = 1; 6822169689Skan return add_stmt (args); 682390075Sobrien} 682490075Sobrien 6825169689Skan/* Build an asm-expr, whose components are a STRING, some OUTPUTS, 6826169689Skan some INPUTS, and some CLOBBERS. The latter three may be NULL. 6827169689Skan SIMPLE indicates whether there was anything at all after the 6828169689Skan string in the asm expression -- asm("blah") and asm("blah" : ) 6829169689Skan are subtly different. We use a ASM_EXPR node to represent this. */ 683090075Sobrientree 6831169689Skanbuild_asm_expr (tree string, tree outputs, tree inputs, tree clobbers, 6832169689Skan bool simple) 683390075Sobrien{ 683490075Sobrien tree tail; 6835169689Skan tree args; 6836169689Skan int i; 6837169689Skan const char *constraint; 6838169689Skan const char **oconstraints; 6839169689Skan bool allows_mem, allows_reg, is_inout; 6840169689Skan int ninputs, noutputs; 684190075Sobrien 6842169689Skan ninputs = list_length (inputs); 6843169689Skan noutputs = list_length (outputs); 6844169689Skan oconstraints = (const char **) alloca (noutputs * sizeof (const char *)); 684590075Sobrien 6846169689Skan string = resolve_asm_operand_names (string, outputs, inputs); 684790075Sobrien 6848169689Skan /* Remove output conversions that change the type but not the mode. */ 6849169689Skan for (i = 0, tail = outputs; tail; ++i, tail = TREE_CHAIN (tail)) 685090075Sobrien { 685190075Sobrien tree output = TREE_VALUE (tail); 685290075Sobrien 6853169689Skan /* ??? Really, this should not be here. Users should be using a 6854169689Skan proper lvalue, dammit. But there's a long history of using casts 6855169689Skan in the output operands. In cases like longlong.h, this becomes a 6856169689Skan primitive form of typechecking -- if the cast can be removed, then 6857169689Skan the output operand had a type of the proper width; otherwise we'll 6858169689Skan get an error. Gross, but ... */ 685990075Sobrien STRIP_NOPS (output); 686090075Sobrien 6861169689Skan if (!lvalue_or_else (output, lv_asm)) 6862169689Skan output = error_mark_node; 686390075Sobrien 6864169689Skan if (output != error_mark_node 6865169689Skan && (TREE_READONLY (output) 6866169689Skan || TYPE_READONLY (TREE_TYPE (output)) 6867169689Skan || ((TREE_CODE (TREE_TYPE (output)) == RECORD_TYPE 6868169689Skan || TREE_CODE (TREE_TYPE (output)) == UNION_TYPE) 6869169689Skan && C_TYPE_FIELDS_READONLY (TREE_TYPE (output))))) 6870169689Skan readonly_error (output, lv_asm); 6871169689Skan 6872169689Skan constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail))); 6873169689Skan oconstraints[i] = constraint; 6874169689Skan 6875169689Skan if (parse_output_constraint (&constraint, i, ninputs, noutputs, 6876169689Skan &allows_mem, &allows_reg, &is_inout)) 6877169689Skan { 6878169689Skan /* If the operand is going to end up in memory, 6879169689Skan mark it addressable. */ 6880169689Skan if (!allows_reg && !c_mark_addressable (output)) 6881169689Skan output = error_mark_node; 6882169689Skan } 6883169689Skan else 6884169689Skan output = error_mark_node; 6885169689Skan 6886169689Skan TREE_VALUE (tail) = output; 688790075Sobrien } 688890075Sobrien 6889169689Skan for (i = 0, tail = inputs; tail; ++i, tail = TREE_CHAIN (tail)) 689090075Sobrien { 6891169689Skan tree input; 6892169689Skan 6893169689Skan constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail))); 6894169689Skan input = TREE_VALUE (tail); 6895169689Skan 6896169689Skan if (parse_input_constraint (&constraint, i, ninputs, noutputs, 0, 6897169689Skan oconstraints, &allows_mem, &allows_reg)) 6898169689Skan { 6899169689Skan /* If the operand is going to end up in memory, 6900169689Skan mark it addressable. */ 6901169689Skan if (!allows_reg && allows_mem) 6902169689Skan { 6903169689Skan /* Strip the nops as we allow this case. FIXME, this really 6904169689Skan should be rejected or made deprecated. */ 6905169689Skan STRIP_NOPS (input); 6906169689Skan if (!c_mark_addressable (input)) 6907169689Skan input = error_mark_node; 6908169689Skan } 6909169689Skan } 6910169689Skan else 6911169689Skan input = error_mark_node; 6912169689Skan 6913169689Skan TREE_VALUE (tail) = input; 691490075Sobrien } 691590075Sobrien 6916169689Skan args = build_stmt (ASM_EXPR, string, outputs, inputs, clobbers); 691790075Sobrien 6918169689Skan /* asm statements without outputs, including simple ones, are treated 6919169689Skan as volatile. */ 6920169689Skan ASM_INPUT_P (args) = simple; 6921169689Skan ASM_VOLATILE_P (args) = (noutputs == 0); 6922169689Skan 6923169689Skan return args; 692490075Sobrien} 6925169689Skan 6926169689Skan/* Generate a goto statement to LABEL. */ 692790075Sobrien 6928169689Skantree 6929169689Skanc_finish_goto_label (tree label) 693018334Speter{ 6931169689Skan tree decl = lookup_label (label); 6932169689Skan if (!decl) 6933169689Skan return NULL_TREE; 693418334Speter 6935169689Skan if (C_DECL_UNJUMPABLE_STMT_EXPR (decl)) 6936117395Skan { 6937169689Skan error ("jump into statement expression"); 6938169689Skan return NULL_TREE; 6939117395Skan } 694018334Speter 6941169689Skan if (C_DECL_UNJUMPABLE_VM (decl)) 6942169689Skan { 6943169689Skan error ("jump into scope of identifier with variably modified type"); 6944169689Skan return NULL_TREE; 6945169689Skan } 694618334Speter 6947169689Skan if (!C_DECL_UNDEFINABLE_STMT_EXPR (decl)) 694818334Speter { 6949169689Skan /* No jump from outside this statement expression context, so 6950169689Skan record that there is a jump from within this context. */ 6951169689Skan struct c_label_list *nlist; 6952169689Skan nlist = XOBNEW (&parser_obstack, struct c_label_list); 6953169689Skan nlist->next = label_context_stack_se->labels_used; 6954169689Skan nlist->label = decl; 6955169689Skan label_context_stack_se->labels_used = nlist; 6956169689Skan } 695790075Sobrien 6958169689Skan if (!C_DECL_UNDEFINABLE_VM (decl)) 6959169689Skan { 6960169689Skan /* No jump from outside this context context of identifiers with 6961169689Skan variably modified type, so record that there is a jump from 6962169689Skan within this context. */ 6963169689Skan struct c_label_list *nlist; 6964169689Skan nlist = XOBNEW (&parser_obstack, struct c_label_list); 6965169689Skan nlist->next = label_context_stack_vm->labels_used; 6966169689Skan nlist->label = decl; 6967169689Skan label_context_stack_vm->labels_used = nlist; 696818334Speter } 696918334Speter 6970169689Skan TREE_USED (decl) = 1; 6971169689Skan return add_stmt (build1 (GOTO_EXPR, void_type_node, decl)); 697218334Speter} 697318334Speter 6974169689Skan/* Generate a computed goto statement to EXPR. */ 6975169689Skan 697690075Sobrientree 6977169689Skanc_finish_goto_ptr (tree expr) 697818334Speter{ 6979169689Skan if (pedantic) 6980169689Skan pedwarn ("ISO C forbids %<goto *expr;%>"); 6981169689Skan expr = convert (ptr_type_node, expr); 6982169689Skan return add_stmt (build1 (GOTO_EXPR, void_type_node, expr)); 6983169689Skan} 698418334Speter 6985169689Skan/* Generate a C `return' statement. RETVAL is the expression for what 6986169689Skan to return, or a null pointer for `return;' with no value. */ 6987169689Skan 6988169689Skantree 6989169689Skanc_finish_return (tree retval) 6990169689Skan{ 6991169689Skan tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl)), ret_stmt; 6992169689Skan bool no_warning = false; 6993169689Skan 699418334Speter if (TREE_THIS_VOLATILE (current_function_decl)) 6995169689Skan warning (0, "function declared %<noreturn%> has a %<return%> statement"); 699618334Speter 699718334Speter if (!retval) 699818334Speter { 699918334Speter current_function_returns_null = 1; 700090075Sobrien if ((warn_return_type || flag_isoc99) 700190075Sobrien && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE) 7002169689Skan { 7003169689Skan pedwarn_c99 ("%<return%> with no value, in " 7004169689Skan "function returning non-void"); 7005169689Skan no_warning = true; 7006169689Skan } 700718334Speter } 700818334Speter else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE) 700918334Speter { 701018334Speter current_function_returns_null = 1; 701118334Speter if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE) 7012169689Skan pedwarn ("%<return%> with a value, in function returning void"); 701318334Speter } 701418334Speter else 701518334Speter { 7016169689Skan tree t = convert_for_assignment (valtype, retval, ic_return, 701718334Speter NULL_TREE, NULL_TREE, 0); 701818334Speter tree res = DECL_RESULT (current_function_decl); 701918334Speter tree inner; 702018334Speter 702196263Sobrien current_function_returns_value = 1; 702218334Speter if (t == error_mark_node) 702390075Sobrien return NULL_TREE; 702418334Speter 702518334Speter inner = t = convert (TREE_TYPE (res), t); 702618334Speter 702718334Speter /* Strip any conversions, additions, and subtractions, and see if 702818334Speter we are returning the address of a local variable. Warn if so. */ 702918334Speter while (1) 703018334Speter { 703118334Speter switch (TREE_CODE (inner)) 703218334Speter { 703318334Speter case NOP_EXPR: case NON_LVALUE_EXPR: case CONVERT_EXPR: 703418334Speter case PLUS_EXPR: 703518334Speter inner = TREE_OPERAND (inner, 0); 703618334Speter continue; 703718334Speter 703818334Speter case MINUS_EXPR: 703918334Speter /* If the second operand of the MINUS_EXPR has a pointer 704018334Speter type (or is converted from it), this may be valid, so 704118334Speter don't give a warning. */ 704218334Speter { 704318334Speter tree op1 = TREE_OPERAND (inner, 1); 704418334Speter 7045169689Skan while (!POINTER_TYPE_P (TREE_TYPE (op1)) 704618334Speter && (TREE_CODE (op1) == NOP_EXPR 704718334Speter || TREE_CODE (op1) == NON_LVALUE_EXPR 704818334Speter || TREE_CODE (op1) == CONVERT_EXPR)) 704918334Speter op1 = TREE_OPERAND (op1, 0); 705018334Speter 705118334Speter if (POINTER_TYPE_P (TREE_TYPE (op1))) 705218334Speter break; 705318334Speter 705418334Speter inner = TREE_OPERAND (inner, 0); 705518334Speter continue; 705618334Speter } 7057132718Skan 705818334Speter case ADDR_EXPR: 705918334Speter inner = TREE_OPERAND (inner, 0); 706018334Speter 7061169689Skan while (REFERENCE_CLASS_P (inner) 7062169689Skan && TREE_CODE (inner) != INDIRECT_REF) 706318334Speter inner = TREE_OPERAND (inner, 0); 706418334Speter 7065169689Skan if (DECL_P (inner) 7066169689Skan && !DECL_EXTERNAL (inner) 7067169689Skan && !TREE_STATIC (inner) 706818334Speter && DECL_CONTEXT (inner) == current_function_decl) 7069169689Skan warning (0, "function returns address of local variable"); 707018334Speter break; 707150397Sobrien 707250397Sobrien default: 707350397Sobrien break; 707418334Speter } 707518334Speter 707618334Speter break; 707718334Speter } 707818334Speter 7079169689Skan retval = build2 (MODIFY_EXPR, TREE_TYPE (res), res, t); 708018334Speter } 708190075Sobrien 7082169689Skan ret_stmt = build_stmt (RETURN_EXPR, retval); 7083169689Skan TREE_NO_WARNING (ret_stmt) |= no_warning; 7084169689Skan return add_stmt (ret_stmt); 708518334Speter} 708618334Speter 708790075Sobrienstruct c_switch { 7088169689Skan /* The SWITCH_EXPR being built. */ 7089169689Skan tree switch_expr; 7090169689Skan 7091169689Skan /* The original type of the testing expression, i.e. before the 7092169689Skan default conversion is applied. */ 7093169689Skan tree orig_type; 7094169689Skan 709590075Sobrien /* A splay-tree mapping the low element of a case range to the high 709690075Sobrien element, or NULL_TREE if there is no high element. Used to 709790075Sobrien determine whether or not a new case label duplicates an old case 709890075Sobrien label. We need a tree, rather than simply a hash table, because 709990075Sobrien of the GNU case range extension. */ 710090075Sobrien splay_tree cases; 7101169689Skan 7102169689Skan /* Number of nested statement expressions within this switch 7103169689Skan statement; if nonzero, case and default labels may not 7104169689Skan appear. */ 7105169689Skan unsigned int blocked_stmt_expr; 7106169689Skan 7107169689Skan /* Scope of outermost declarations of identifiers with variably 7108169689Skan modified type within this switch statement; if nonzero, case and 7109169689Skan default labels may not appear. */ 7110169689Skan unsigned int blocked_vm; 7111169689Skan 711290075Sobrien /* The next node on the stack. */ 711390075Sobrien struct c_switch *next; 711490075Sobrien}; 711518334Speter 711690075Sobrien/* A stack of the currently active switch statements. The innermost 711790075Sobrien switch statement is on the top of the stack. There is no need to 711890075Sobrien mark the stack for garbage collection because it is only active 711990075Sobrien during the processing of the body of a function, and we never 712090075Sobrien collect at that point. */ 712190075Sobrien 7122169689Skanstruct c_switch *c_switch_stack; 712390075Sobrien 712490075Sobrien/* Start a C switch statement, testing expression EXP. Return the new 7125169689Skan SWITCH_EXPR. */ 712690075Sobrien 712718334Spetertree 7128132718Skanc_start_case (tree exp) 712918334Speter{ 7130169689Skan tree orig_type = error_mark_node; 713190075Sobrien struct c_switch *cs; 713218334Speter 713390075Sobrien if (exp != error_mark_node) 713418334Speter { 713596263Sobrien orig_type = TREE_TYPE (exp); 713690075Sobrien 7137169689Skan if (!INTEGRAL_TYPE_P (orig_type)) 713890075Sobrien { 7139169689Skan if (orig_type != error_mark_node) 7140169689Skan { 7141169689Skan error ("switch quantity not an integer"); 7142169689Skan orig_type = error_mark_node; 7143169689Skan } 714490075Sobrien exp = integer_zero_node; 714590075Sobrien } 714690075Sobrien else 714790075Sobrien { 7148169689Skan tree type = TYPE_MAIN_VARIANT (orig_type); 714990075Sobrien 7150169689Skan if (!in_system_header 715190075Sobrien && (type == long_integer_type_node 715290075Sobrien || type == long_unsigned_type_node)) 7153169689Skan warning (OPT_Wtraditional, "%<long%> switch expression not " 7154169689Skan "converted to %<int%> in ISO C"); 715590075Sobrien 715690075Sobrien exp = default_conversion (exp); 715790075Sobrien } 715818334Speter } 715918334Speter 7160169689Skan /* Add this new SWITCH_EXPR to the stack. */ 7161169689Skan cs = XNEW (struct c_switch); 7162169689Skan cs->switch_expr = build3 (SWITCH_EXPR, orig_type, exp, NULL_TREE, NULL_TREE); 7163169689Skan cs->orig_type = orig_type; 716490075Sobrien cs->cases = splay_tree_new (case_compare, NULL, NULL); 7165169689Skan cs->blocked_stmt_expr = 0; 7166169689Skan cs->blocked_vm = 0; 7167169689Skan cs->next = c_switch_stack; 7168169689Skan c_switch_stack = cs; 716918334Speter 7170169689Skan return add_stmt (cs->switch_expr); 717190075Sobrien} 717290075Sobrien 717390075Sobrien/* Process a case label. */ 717490075Sobrien 717590075Sobrientree 7176132718Skando_case (tree low_value, tree high_value) 717790075Sobrien{ 717890075Sobrien tree label = NULL_TREE; 717990075Sobrien 7180169689Skan if (c_switch_stack && !c_switch_stack->blocked_stmt_expr 7181169689Skan && !c_switch_stack->blocked_vm) 718290075Sobrien { 7183169689Skan label = c_add_case_label (c_switch_stack->cases, 7184169689Skan SWITCH_COND (c_switch_stack->switch_expr), 7185169689Skan c_switch_stack->orig_type, 718690075Sobrien low_value, high_value); 718790075Sobrien if (label == error_mark_node) 718890075Sobrien label = NULL_TREE; 718918334Speter } 7190169689Skan else if (c_switch_stack && c_switch_stack->blocked_stmt_expr) 7191169689Skan { 7192169689Skan if (low_value) 7193169689Skan error ("case label in statement expression not containing " 7194169689Skan "enclosing switch statement"); 7195169689Skan else 7196169689Skan error ("%<default%> label in statement expression not containing " 7197169689Skan "enclosing switch statement"); 7198169689Skan } 7199169689Skan else if (c_switch_stack && c_switch_stack->blocked_vm) 7200169689Skan { 7201169689Skan if (low_value) 7202169689Skan error ("case label in scope of identifier with variably modified " 7203169689Skan "type not containing enclosing switch statement"); 7204169689Skan else 7205169689Skan error ("%<default%> label in scope of identifier with variably " 7206169689Skan "modified type not containing enclosing switch statement"); 7207169689Skan } 720890075Sobrien else if (low_value) 720990075Sobrien error ("case label not within a switch statement"); 721090075Sobrien else 7211169689Skan error ("%<default%> label not within a switch statement"); 721218334Speter 721390075Sobrien return label; 721490075Sobrien} 721518334Speter 721690075Sobrien/* Finish the switch statement. */ 721790075Sobrien 721890075Sobrienvoid 7219169689Skanc_finish_case (tree body) 722090075Sobrien{ 7221169689Skan struct c_switch *cs = c_switch_stack; 7222169689Skan location_t switch_location; 722390075Sobrien 7224169689Skan SWITCH_BODY (cs->switch_expr) = body; 7225146895Skan 7226169689Skan /* We must not be within a statement expression nested in the switch 7227169689Skan at this point; we might, however, be within the scope of an 7228169689Skan identifier with variably modified type nested in the switch. */ 7229169689Skan gcc_assert (!cs->blocked_stmt_expr); 723090075Sobrien 7231169689Skan /* Emit warnings as needed. */ 7232169689Skan if (EXPR_HAS_LOCATION (cs->switch_expr)) 7233169689Skan switch_location = EXPR_LOCATION (cs->switch_expr); 7234169689Skan else 7235169689Skan switch_location = input_location; 7236169689Skan c_do_switch_warnings (cs->cases, switch_location, 7237169689Skan TREE_TYPE (cs->switch_expr), 7238169689Skan SWITCH_COND (cs->switch_expr)); 7239169689Skan 724090075Sobrien /* Pop the stack. */ 7241169689Skan c_switch_stack = cs->next; 724290075Sobrien splay_tree_delete (cs->cases); 7243169689Skan XDELETE (cs); 724418334Speter} 7245169689Skan 7246169689Skan/* Emit an if statement. IF_LOCUS is the location of the 'if'. COND, 7247169689Skan THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK 7248169689Skan may be null. NESTED_IF is true if THEN_BLOCK contains another IF 7249169689Skan statement, and was not surrounded with parenthesis. */ 7250132718Skan 7251169689Skanvoid 7252169689Skanc_finish_if_stmt (location_t if_locus, tree cond, tree then_block, 7253169689Skan tree else_block, bool nested_if) 7254169689Skan{ 7255169689Skan tree stmt; 7256169689Skan 7257169689Skan /* Diagnose an ambiguous else if if-then-else is nested inside if-then. */ 7258169689Skan if (warn_parentheses && nested_if && else_block == NULL) 7259169689Skan { 7260169689Skan tree inner_if = then_block; 7261169689Skan 7262169689Skan /* We know from the grammar productions that there is an IF nested 7263169689Skan within THEN_BLOCK. Due to labels and c99 conditional declarations, 7264169689Skan it might not be exactly THEN_BLOCK, but should be the last 7265169689Skan non-container statement within. */ 7266169689Skan while (1) 7267169689Skan switch (TREE_CODE (inner_if)) 7268169689Skan { 7269169689Skan case COND_EXPR: 7270169689Skan goto found; 7271169689Skan case BIND_EXPR: 7272169689Skan inner_if = BIND_EXPR_BODY (inner_if); 7273169689Skan break; 7274169689Skan case STATEMENT_LIST: 7275169689Skan inner_if = expr_last (then_block); 7276169689Skan break; 7277169689Skan case TRY_FINALLY_EXPR: 7278169689Skan case TRY_CATCH_EXPR: 7279169689Skan inner_if = TREE_OPERAND (inner_if, 0); 7280169689Skan break; 7281169689Skan default: 7282169689Skan gcc_unreachable (); 7283169689Skan } 7284169689Skan found: 7285169689Skan 7286169689Skan if (COND_EXPR_ELSE (inner_if)) 7287169689Skan warning (OPT_Wparentheses, 7288169689Skan "%Hsuggest explicit braces to avoid ambiguous %<else%>", 7289169689Skan &if_locus); 7290169689Skan } 7291169689Skan 7292169689Skan empty_body_warning (then_block, else_block); 7293169689Skan 7294169689Skan stmt = build3 (COND_EXPR, void_type_node, cond, then_block, else_block); 7295169689Skan SET_EXPR_LOCATION (stmt, if_locus); 7296169689Skan add_stmt (stmt); 7297169689Skan} 7298169689Skan 7299169689Skan/* Emit a general-purpose loop construct. START_LOCUS is the location of 7300169689Skan the beginning of the loop. COND is the loop condition. COND_IS_FIRST 7301169689Skan is false for DO loops. INCR is the FOR increment expression. BODY is 7302169689Skan the statement controlled by the loop. BLAB is the break label. CLAB is 7303169689Skan the continue label. Everything is allowed to be NULL. */ 7304169689Skan 7305169689Skanvoid 7306169689Skanc_finish_loop (location_t start_locus, tree cond, tree incr, tree body, 7307169689Skan tree blab, tree clab, bool cond_is_first) 7308169689Skan{ 7309169689Skan tree entry = NULL, exit = NULL, t; 7310169689Skan 7311169689Skan /* If the condition is zero don't generate a loop construct. */ 7312169689Skan if (cond && integer_zerop (cond)) 7313169689Skan { 7314169689Skan if (cond_is_first) 7315169689Skan { 7316169689Skan t = build_and_jump (&blab); 7317169689Skan SET_EXPR_LOCATION (t, start_locus); 7318169689Skan add_stmt (t); 7319169689Skan } 7320169689Skan } 7321169689Skan else 7322169689Skan { 7323169689Skan tree top = build1 (LABEL_EXPR, void_type_node, NULL_TREE); 7324169689Skan 7325169689Skan /* If we have an exit condition, then we build an IF with gotos either 7326169689Skan out of the loop, or to the top of it. If there's no exit condition, 7327169689Skan then we just build a jump back to the top. */ 7328169689Skan exit = build_and_jump (&LABEL_EXPR_LABEL (top)); 7329169689Skan 7330169689Skan if (cond && !integer_nonzerop (cond)) 7331169689Skan { 7332169689Skan /* Canonicalize the loop condition to the end. This means 7333169689Skan generating a branch to the loop condition. Reuse the 7334169689Skan continue label, if possible. */ 7335169689Skan if (cond_is_first) 7336169689Skan { 7337169689Skan if (incr || !clab) 7338169689Skan { 7339169689Skan entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE); 7340169689Skan t = build_and_jump (&LABEL_EXPR_LABEL (entry)); 7341169689Skan } 7342169689Skan else 7343169689Skan t = build1 (GOTO_EXPR, void_type_node, clab); 7344169689Skan SET_EXPR_LOCATION (t, start_locus); 7345169689Skan add_stmt (t); 7346169689Skan } 7347169689Skan 7348169689Skan t = build_and_jump (&blab); 7349169689Skan exit = fold_build3 (COND_EXPR, void_type_node, cond, exit, t); 7350169689Skan if (cond_is_first) 7351169689Skan SET_EXPR_LOCATION (exit, start_locus); 7352169689Skan else 7353169689Skan SET_EXPR_LOCATION (exit, input_location); 7354169689Skan } 7355169689Skan 7356169689Skan add_stmt (top); 7357169689Skan } 7358169689Skan 7359169689Skan if (body) 7360169689Skan add_stmt (body); 7361169689Skan if (clab) 7362169689Skan add_stmt (build1 (LABEL_EXPR, void_type_node, clab)); 7363169689Skan if (incr) 7364169689Skan add_stmt (incr); 7365169689Skan if (entry) 7366169689Skan add_stmt (entry); 7367169689Skan if (exit) 7368169689Skan add_stmt (exit); 7369169689Skan if (blab) 7370169689Skan add_stmt (build1 (LABEL_EXPR, void_type_node, blab)); 7371169689Skan} 7372169689Skan 7373169689Skantree 7374169689Skanc_finish_bc_stmt (tree *label_p, bool is_break) 7375169689Skan{ 7376169689Skan bool skip; 7377169689Skan tree label = *label_p; 7378169689Skan 7379169689Skan /* In switch statements break is sometimes stylistically used after 7380169689Skan a return statement. This can lead to spurious warnings about 7381169689Skan control reaching the end of a non-void function when it is 7382169689Skan inlined. Note that we are calling block_may_fallthru with 7383169689Skan language specific tree nodes; this works because 7384169689Skan block_may_fallthru returns true when given something it does not 7385169689Skan understand. */ 7386169689Skan skip = !block_may_fallthru (cur_stmt_list); 7387169689Skan 7388169689Skan if (!label) 7389169689Skan { 7390169689Skan if (!skip) 7391169689Skan *label_p = label = create_artificial_label (); 7392169689Skan } 7393169689Skan else if (TREE_CODE (label) == LABEL_DECL) 7394169689Skan ; 7395169689Skan else switch (TREE_INT_CST_LOW (label)) 7396169689Skan { 7397169689Skan case 0: 7398169689Skan if (is_break) 7399169689Skan error ("break statement not within loop or switch"); 7400169689Skan else 7401169689Skan error ("continue statement not within a loop"); 7402169689Skan return NULL_TREE; 7403169689Skan 7404169689Skan case 1: 7405169689Skan gcc_assert (is_break); 7406169689Skan error ("break statement used with OpenMP for loop"); 7407169689Skan return NULL_TREE; 7408169689Skan 7409169689Skan default: 7410169689Skan gcc_unreachable (); 7411169689Skan } 7412169689Skan 7413169689Skan if (skip) 7414169689Skan return NULL_TREE; 7415169689Skan 7416169689Skan return add_stmt (build1 (GOTO_EXPR, void_type_node, label)); 7417169689Skan} 7418169689Skan 7419169689Skan/* A helper routine for c_process_expr_stmt and c_finish_stmt_expr. */ 7420169689Skan 7421169689Skanstatic void 7422169689Skanemit_side_effect_warnings (tree expr) 7423169689Skan{ 7424169689Skan if (expr == error_mark_node) 7425169689Skan ; 7426169689Skan else if (!TREE_SIDE_EFFECTS (expr)) 7427169689Skan { 7428169689Skan if (!VOID_TYPE_P (TREE_TYPE (expr)) && !TREE_NO_WARNING (expr)) 7429169689Skan warning (0, "%Hstatement with no effect", 7430169689Skan EXPR_HAS_LOCATION (expr) ? EXPR_LOCUS (expr) : &input_location); 7431169689Skan } 7432169689Skan else if (warn_unused_value) 7433169689Skan warn_if_unused_value (expr, input_location); 7434169689Skan} 7435169689Skan 7436169689Skan/* Process an expression as if it were a complete statement. Emit 7437169689Skan diagnostics, but do not call ADD_STMT. */ 7438169689Skan 7439169689Skantree 7440169689Skanc_process_expr_stmt (tree expr) 7441169689Skan{ 7442169689Skan if (!expr) 7443169689Skan return NULL_TREE; 7444169689Skan 7445169689Skan if (warn_sequence_point) 7446169689Skan verify_sequence_points (expr); 7447169689Skan 7448169689Skan if (TREE_TYPE (expr) != error_mark_node 7449169689Skan && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr)) 7450169689Skan && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE) 7451169689Skan error ("expression statement has incomplete type"); 7452169689Skan 7453169689Skan /* If we're not processing a statement expression, warn about unused values. 7454169689Skan Warnings for statement expressions will be emitted later, once we figure 7455169689Skan out which is the result. */ 7456169689Skan if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list) 7457169689Skan && (extra_warnings || warn_unused_value)) 7458169689Skan emit_side_effect_warnings (expr); 7459169689Skan 7460169689Skan /* If the expression is not of a type to which we cannot assign a line 7461169689Skan number, wrap the thing in a no-op NOP_EXPR. */ 7462169689Skan if (DECL_P (expr) || CONSTANT_CLASS_P (expr)) 7463169689Skan expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr); 7464169689Skan 7465169689Skan if (EXPR_P (expr)) 7466169689Skan SET_EXPR_LOCATION (expr, input_location); 7467169689Skan 7468169689Skan return expr; 7469169689Skan} 7470169689Skan 7471169689Skan/* Emit an expression as a statement. */ 7472169689Skan 7473169689Skantree 7474169689Skanc_finish_expr_stmt (tree expr) 7475169689Skan{ 7476169689Skan if (expr) 7477169689Skan return add_stmt (c_process_expr_stmt (expr)); 7478169689Skan else 7479169689Skan return NULL; 7480169689Skan} 7481169689Skan 7482169689Skan/* Do the opposite and emit a statement as an expression. To begin, 7483169689Skan create a new binding level and return it. */ 7484169689Skan 7485169689Skantree 7486169689Skanc_begin_stmt_expr (void) 7487169689Skan{ 7488169689Skan tree ret; 7489169689Skan struct c_label_context_se *nstack; 7490169689Skan struct c_label_list *glist; 7491169689Skan 7492169689Skan /* We must force a BLOCK for this level so that, if it is not expanded 7493169689Skan later, there is a way to turn off the entire subtree of blocks that 7494169689Skan are contained in it. */ 7495169689Skan keep_next_level (); 7496169689Skan ret = c_begin_compound_stmt (true); 7497169689Skan if (c_switch_stack) 7498169689Skan { 7499169689Skan c_switch_stack->blocked_stmt_expr++; 7500169689Skan gcc_assert (c_switch_stack->blocked_stmt_expr != 0); 7501169689Skan } 7502169689Skan for (glist = label_context_stack_se->labels_used; 7503169689Skan glist != NULL; 7504169689Skan glist = glist->next) 7505169689Skan { 7506169689Skan C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 1; 7507169689Skan } 7508169689Skan nstack = XOBNEW (&parser_obstack, struct c_label_context_se); 7509169689Skan nstack->labels_def = NULL; 7510169689Skan nstack->labels_used = NULL; 7511169689Skan nstack->next = label_context_stack_se; 7512169689Skan label_context_stack_se = nstack; 7513169689Skan 7514169689Skan /* Mark the current statement list as belonging to a statement list. */ 7515169689Skan STATEMENT_LIST_STMT_EXPR (ret) = 1; 7516169689Skan 7517169689Skan return ret; 7518169689Skan} 7519169689Skan 7520169689Skantree 7521169689Skanc_finish_stmt_expr (tree body) 7522169689Skan{ 7523169689Skan tree last, type, tmp, val; 7524169689Skan tree *last_p; 7525169689Skan struct c_label_list *dlist, *glist, *glist_prev = NULL; 7526169689Skan 7527169689Skan body = c_end_compound_stmt (body, true); 7528169689Skan if (c_switch_stack) 7529169689Skan { 7530169689Skan gcc_assert (c_switch_stack->blocked_stmt_expr != 0); 7531169689Skan c_switch_stack->blocked_stmt_expr--; 7532169689Skan } 7533169689Skan /* It is no longer possible to jump to labels defined within this 7534169689Skan statement expression. */ 7535169689Skan for (dlist = label_context_stack_se->labels_def; 7536169689Skan dlist != NULL; 7537169689Skan dlist = dlist->next) 7538169689Skan { 7539169689Skan C_DECL_UNJUMPABLE_STMT_EXPR (dlist->label) = 1; 7540169689Skan } 7541169689Skan /* It is again possible to define labels with a goto just outside 7542169689Skan this statement expression. */ 7543169689Skan for (glist = label_context_stack_se->next->labels_used; 7544169689Skan glist != NULL; 7545169689Skan glist = glist->next) 7546169689Skan { 7547169689Skan C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 0; 7548169689Skan glist_prev = glist; 7549169689Skan } 7550169689Skan if (glist_prev != NULL) 7551169689Skan glist_prev->next = label_context_stack_se->labels_used; 7552169689Skan else 7553169689Skan label_context_stack_se->next->labels_used 7554169689Skan = label_context_stack_se->labels_used; 7555169689Skan label_context_stack_se = label_context_stack_se->next; 7556169689Skan 7557169689Skan /* Locate the last statement in BODY. See c_end_compound_stmt 7558169689Skan about always returning a BIND_EXPR. */ 7559169689Skan last_p = &BIND_EXPR_BODY (body); 7560169689Skan last = BIND_EXPR_BODY (body); 7561169689Skan 7562169689Skan continue_searching: 7563169689Skan if (TREE_CODE (last) == STATEMENT_LIST) 7564169689Skan { 7565169689Skan tree_stmt_iterator i; 7566169689Skan 7567169689Skan /* This can happen with degenerate cases like ({ }). No value. */ 7568169689Skan if (!TREE_SIDE_EFFECTS (last)) 7569169689Skan return body; 7570169689Skan 7571169689Skan /* If we're supposed to generate side effects warnings, process 7572169689Skan all of the statements except the last. */ 7573169689Skan if (extra_warnings || warn_unused_value) 7574169689Skan { 7575169689Skan for (i = tsi_start (last); !tsi_one_before_end_p (i); tsi_next (&i)) 7576169689Skan emit_side_effect_warnings (tsi_stmt (i)); 7577169689Skan } 7578169689Skan else 7579169689Skan i = tsi_last (last); 7580169689Skan last_p = tsi_stmt_ptr (i); 7581169689Skan last = *last_p; 7582169689Skan } 7583169689Skan 7584169689Skan /* If the end of the list is exception related, then the list was split 7585169689Skan by a call to push_cleanup. Continue searching. */ 7586169689Skan if (TREE_CODE (last) == TRY_FINALLY_EXPR 7587169689Skan || TREE_CODE (last) == TRY_CATCH_EXPR) 7588169689Skan { 7589169689Skan last_p = &TREE_OPERAND (last, 0); 7590169689Skan last = *last_p; 7591169689Skan goto continue_searching; 7592169689Skan } 7593169689Skan 7594169689Skan /* In the case that the BIND_EXPR is not necessary, return the 7595169689Skan expression out from inside it. */ 7596169689Skan if (last == error_mark_node 7597169689Skan || (last == BIND_EXPR_BODY (body) 7598169689Skan && BIND_EXPR_VARS (body) == NULL)) 7599169689Skan { 7600169689Skan /* Do not warn if the return value of a statement expression is 7601169689Skan unused. */ 7602169689Skan if (EXPR_P (last)) 7603169689Skan TREE_NO_WARNING (last) = 1; 7604169689Skan return last; 7605169689Skan } 7606169689Skan 7607169689Skan /* Extract the type of said expression. */ 7608169689Skan type = TREE_TYPE (last); 7609169689Skan 7610169689Skan /* If we're not returning a value at all, then the BIND_EXPR that 7611169689Skan we already have is a fine expression to return. */ 7612169689Skan if (!type || VOID_TYPE_P (type)) 7613169689Skan return body; 7614169689Skan 7615169689Skan /* Now that we've located the expression containing the value, it seems 7616169689Skan silly to make voidify_wrapper_expr repeat the process. Create a 7617169689Skan temporary of the appropriate type and stick it in a TARGET_EXPR. */ 7618169689Skan tmp = create_tmp_var_raw (type, NULL); 7619169689Skan 7620169689Skan /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt. This avoids 7621169689Skan tree_expr_nonnegative_p giving up immediately. */ 7622169689Skan val = last; 7623169689Skan if (TREE_CODE (val) == NOP_EXPR 7624169689Skan && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0))) 7625169689Skan val = TREE_OPERAND (val, 0); 7626169689Skan 7627169689Skan *last_p = build2 (MODIFY_EXPR, void_type_node, tmp, val); 7628169689Skan SET_EXPR_LOCUS (*last_p, EXPR_LOCUS (last)); 7629169689Skan 7630169689Skan return build4 (TARGET_EXPR, type, tmp, body, NULL_TREE, NULL_TREE); 7631169689Skan} 7632169689Skan 7633169689Skan/* Begin the scope of an identifier of variably modified type, scope 7634169689Skan number SCOPE. Jumping from outside this scope to inside it is not 7635169689Skan permitted. */ 7636169689Skan 7637169689Skanvoid 7638169689Skanc_begin_vm_scope (unsigned int scope) 7639169689Skan{ 7640169689Skan struct c_label_context_vm *nstack; 7641169689Skan struct c_label_list *glist; 7642169689Skan 7643169689Skan gcc_assert (scope > 0); 7644169689Skan 7645169689Skan /* At file_scope, we don't have to do any processing. */ 7646169689Skan if (label_context_stack_vm == NULL) 7647169689Skan return; 7648169689Skan 7649169689Skan if (c_switch_stack && !c_switch_stack->blocked_vm) 7650169689Skan c_switch_stack->blocked_vm = scope; 7651169689Skan for (glist = label_context_stack_vm->labels_used; 7652169689Skan glist != NULL; 7653169689Skan glist = glist->next) 7654169689Skan { 7655169689Skan C_DECL_UNDEFINABLE_VM (glist->label) = 1; 7656169689Skan } 7657169689Skan nstack = XOBNEW (&parser_obstack, struct c_label_context_vm); 7658169689Skan nstack->labels_def = NULL; 7659169689Skan nstack->labels_used = NULL; 7660169689Skan nstack->scope = scope; 7661169689Skan nstack->next = label_context_stack_vm; 7662169689Skan label_context_stack_vm = nstack; 7663169689Skan} 7664169689Skan 7665169689Skan/* End a scope which may contain identifiers of variably modified 7666169689Skan type, scope number SCOPE. */ 7667169689Skan 7668169689Skanvoid 7669169689Skanc_end_vm_scope (unsigned int scope) 7670169689Skan{ 7671169689Skan if (label_context_stack_vm == NULL) 7672169689Skan return; 7673169689Skan if (c_switch_stack && c_switch_stack->blocked_vm == scope) 7674169689Skan c_switch_stack->blocked_vm = 0; 7675169689Skan /* We may have a number of nested scopes of identifiers with 7676169689Skan variably modified type, all at this depth. Pop each in turn. */ 7677169689Skan while (label_context_stack_vm->scope == scope) 7678169689Skan { 7679169689Skan struct c_label_list *dlist, *glist, *glist_prev = NULL; 7680169689Skan 7681169689Skan /* It is no longer possible to jump to labels defined within this 7682169689Skan scope. */ 7683169689Skan for (dlist = label_context_stack_vm->labels_def; 7684169689Skan dlist != NULL; 7685169689Skan dlist = dlist->next) 7686169689Skan { 7687169689Skan C_DECL_UNJUMPABLE_VM (dlist->label) = 1; 7688169689Skan } 7689169689Skan /* It is again possible to define labels with a goto just outside 7690169689Skan this scope. */ 7691169689Skan for (glist = label_context_stack_vm->next->labels_used; 7692169689Skan glist != NULL; 7693169689Skan glist = glist->next) 7694169689Skan { 7695169689Skan C_DECL_UNDEFINABLE_VM (glist->label) = 0; 7696169689Skan glist_prev = glist; 7697169689Skan } 7698169689Skan if (glist_prev != NULL) 7699169689Skan glist_prev->next = label_context_stack_vm->labels_used; 7700169689Skan else 7701169689Skan label_context_stack_vm->next->labels_used 7702169689Skan = label_context_stack_vm->labels_used; 7703169689Skan label_context_stack_vm = label_context_stack_vm->next; 7704169689Skan } 7705169689Skan} 7706169689Skan 7707169689Skan/* Begin and end compound statements. This is as simple as pushing 7708169689Skan and popping new statement lists from the tree. */ 7709169689Skan 7710169689Skantree 7711169689Skanc_begin_compound_stmt (bool do_scope) 7712169689Skan{ 7713169689Skan tree stmt = push_stmt_list (); 7714169689Skan if (do_scope) 7715169689Skan push_scope (); 7716169689Skan return stmt; 7717169689Skan} 7718169689Skan 7719169689Skantree 7720169689Skanc_end_compound_stmt (tree stmt, bool do_scope) 7721169689Skan{ 7722169689Skan tree block = NULL; 7723169689Skan 7724169689Skan if (do_scope) 7725169689Skan { 7726169689Skan if (c_dialect_objc ()) 7727169689Skan objc_clear_super_receiver (); 7728169689Skan block = pop_scope (); 7729169689Skan } 7730169689Skan 7731169689Skan stmt = pop_stmt_list (stmt); 7732169689Skan stmt = c_build_bind_expr (block, stmt); 7733169689Skan 7734169689Skan /* If this compound statement is nested immediately inside a statement 7735169689Skan expression, then force a BIND_EXPR to be created. Otherwise we'll 7736169689Skan do the wrong thing for ({ { 1; } }) or ({ 1; { } }). In particular, 7737169689Skan STATEMENT_LISTs merge, and thus we can lose track of what statement 7738169689Skan was really last. */ 7739169689Skan if (cur_stmt_list 7740169689Skan && STATEMENT_LIST_STMT_EXPR (cur_stmt_list) 7741169689Skan && TREE_CODE (stmt) != BIND_EXPR) 7742169689Skan { 7743169689Skan stmt = build3 (BIND_EXPR, void_type_node, NULL, stmt, NULL); 7744169689Skan TREE_SIDE_EFFECTS (stmt) = 1; 7745169689Skan } 7746169689Skan 7747169689Skan return stmt; 7748169689Skan} 7749169689Skan 7750169689Skan/* Queue a cleanup. CLEANUP is an expression/statement to be executed 7751169689Skan when the current scope is exited. EH_ONLY is true when this is not 7752169689Skan meant to apply to normal control flow transfer. */ 7753169689Skan 7754169689Skanvoid 7755169689Skanpush_cleanup (tree ARG_UNUSED (decl), tree cleanup, bool eh_only) 7756169689Skan{ 7757169689Skan enum tree_code code; 7758169689Skan tree stmt, list; 7759169689Skan bool stmt_expr; 7760169689Skan 7761169689Skan code = eh_only ? TRY_CATCH_EXPR : TRY_FINALLY_EXPR; 7762169689Skan stmt = build_stmt (code, NULL, cleanup); 7763169689Skan add_stmt (stmt); 7764169689Skan stmt_expr = STATEMENT_LIST_STMT_EXPR (cur_stmt_list); 7765169689Skan list = push_stmt_list (); 7766169689Skan TREE_OPERAND (stmt, 0) = list; 7767169689Skan STATEMENT_LIST_STMT_EXPR (list) = stmt_expr; 7768169689Skan} 7769169689Skan 7770132718Skan/* Build a binary-operation expression without default conversions. 7771132718Skan CODE is the kind of expression to build. 7772132718Skan This function differs from `build' in several ways: 7773132718Skan the data type of the result is computed and recorded in it, 7774132718Skan warnings are generated if arg data types are invalid, 7775132718Skan special handling for addition and subtraction of pointers is known, 7776132718Skan and some optimization is done (operations on narrow ints 7777132718Skan are done in the narrower type when that gives the same result). 7778132718Skan Constant folding is also done before the result is returned. 7779132718Skan 7780132718Skan Note that the operands will never have enumeral types, or function 7781132718Skan or array types, because either they will have the default conversions 7782132718Skan performed or they have both just been converted to some other type in which 7783132718Skan the arithmetic is to be done. */ 7784132718Skan 7785132718Skantree 7786132718Skanbuild_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, 7787132718Skan int convert_p) 7788132718Skan{ 7789132718Skan tree type0, type1; 7790132718Skan enum tree_code code0, code1; 7791132718Skan tree op0, op1; 7792169689Skan const char *invalid_op_diag; 7793132718Skan 7794132718Skan /* Expression code to give to the expression when it is built. 7795132718Skan Normally this is CODE, which is what the caller asked for, 7796132718Skan but in some special cases we change it. */ 7797132718Skan enum tree_code resultcode = code; 7798132718Skan 7799132718Skan /* Data type in which the computation is to be performed. 7800132718Skan In the simplest cases this is the common type of the arguments. */ 7801132718Skan tree result_type = NULL; 7802132718Skan 7803132718Skan /* Nonzero means operands have already been type-converted 7804132718Skan in whatever way is necessary. 7805132718Skan Zero means they need to be converted to RESULT_TYPE. */ 7806132718Skan int converted = 0; 7807132718Skan 7808132718Skan /* Nonzero means create the expression with this type, rather than 7809132718Skan RESULT_TYPE. */ 7810132718Skan tree build_type = 0; 7811132718Skan 7812132718Skan /* Nonzero means after finally constructing the expression 7813132718Skan convert it to this type. */ 7814132718Skan tree final_type = 0; 7815132718Skan 7816132718Skan /* Nonzero if this is an operation like MIN or MAX which can 7817132718Skan safely be computed in short if both args are promoted shorts. 7818132718Skan Also implies COMMON. 7819132718Skan -1 indicates a bitwise operation; this makes a difference 7820132718Skan in the exact conditions for when it is safe to do the operation 7821132718Skan in a narrower mode. */ 7822132718Skan int shorten = 0; 7823132718Skan 7824132718Skan /* Nonzero if this is a comparison operation; 7825132718Skan if both args are promoted shorts, compare the original shorts. 7826132718Skan Also implies COMMON. */ 7827132718Skan int short_compare = 0; 7828132718Skan 7829132718Skan /* Nonzero if this is a right-shift operation, which can be computed on the 7830132718Skan original short and then promoted if the operand is a promoted short. */ 7831132718Skan int short_shift = 0; 7832132718Skan 7833132718Skan /* Nonzero means set RESULT_TYPE to the common type of the args. */ 7834132718Skan int common = 0; 7835132718Skan 7836169689Skan /* True means types are compatible as far as ObjC is concerned. */ 7837169689Skan bool objc_ok; 7838169689Skan 7839132718Skan if (convert_p) 7840132718Skan { 7841132718Skan op0 = default_conversion (orig_op0); 7842132718Skan op1 = default_conversion (orig_op1); 7843132718Skan } 7844132718Skan else 7845132718Skan { 7846132718Skan op0 = orig_op0; 7847132718Skan op1 = orig_op1; 7848132718Skan } 7849132718Skan 7850132718Skan type0 = TREE_TYPE (op0); 7851132718Skan type1 = TREE_TYPE (op1); 7852132718Skan 7853132718Skan /* The expression codes of the data types of the arguments tell us 7854132718Skan whether the arguments are integers, floating, pointers, etc. */ 7855132718Skan code0 = TREE_CODE (type0); 7856132718Skan code1 = TREE_CODE (type1); 7857132718Skan 7858132718Skan /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */ 7859132718Skan STRIP_TYPE_NOPS (op0); 7860132718Skan STRIP_TYPE_NOPS (op1); 7861132718Skan 7862132718Skan /* If an error was already reported for one of the arguments, 7863132718Skan avoid reporting another error. */ 7864132718Skan 7865132718Skan if (code0 == ERROR_MARK || code1 == ERROR_MARK) 7866132718Skan return error_mark_node; 7867132718Skan 7868169689Skan if ((invalid_op_diag 7869169689Skan = targetm.invalid_binary_op (code, type0, type1))) 7870169689Skan { 7871169689Skan error (invalid_op_diag); 7872169689Skan return error_mark_node; 7873169689Skan } 7874169689Skan 7875169689Skan objc_ok = objc_compare_types (type0, type1, -3, NULL_TREE); 7876169689Skan 7877132718Skan switch (code) 7878132718Skan { 7879132718Skan case PLUS_EXPR: 7880132718Skan /* Handle the pointer + int case. */ 7881132718Skan if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 7882132718Skan return pointer_int_sum (PLUS_EXPR, op0, op1); 7883132718Skan else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE) 7884132718Skan return pointer_int_sum (PLUS_EXPR, op1, op0); 7885132718Skan else 7886132718Skan common = 1; 7887132718Skan break; 7888132718Skan 7889132718Skan case MINUS_EXPR: 7890132718Skan /* Subtraction of two similar pointers. 7891132718Skan We must subtract them as integers, then divide by object size. */ 7892132718Skan if (code0 == POINTER_TYPE && code1 == POINTER_TYPE 7893169689Skan && comp_target_types (type0, type1)) 7894132718Skan return pointer_diff (op0, op1); 7895132718Skan /* Handle pointer minus int. Just like pointer plus int. */ 7896132718Skan else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 7897132718Skan return pointer_int_sum (MINUS_EXPR, op0, op1); 7898132718Skan else 7899132718Skan common = 1; 7900132718Skan break; 7901132718Skan 7902132718Skan case MULT_EXPR: 7903132718Skan common = 1; 7904132718Skan break; 7905132718Skan 7906132718Skan case TRUNC_DIV_EXPR: 7907132718Skan case CEIL_DIV_EXPR: 7908132718Skan case FLOOR_DIV_EXPR: 7909132718Skan case ROUND_DIV_EXPR: 7910132718Skan case EXACT_DIV_EXPR: 7911132718Skan /* Floating point division by zero is a legitimate way to obtain 7912132718Skan infinities and NaNs. */ 7913169689Skan if (skip_evaluation == 0 && integer_zerop (op1)) 7914169689Skan warning (OPT_Wdiv_by_zero, "division by zero"); 7915132718Skan 7916132718Skan if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE 7917132718Skan || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE) 7918132718Skan && (code1 == INTEGER_TYPE || code1 == REAL_TYPE 7919132718Skan || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)) 7920132718Skan { 7921169689Skan enum tree_code tcode0 = code0, tcode1 = code1; 7922169689Skan 7923169689Skan if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE) 7924169689Skan tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0))); 7925169689Skan if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE) 7926169689Skan tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1))); 7927169689Skan 7928169689Skan if (!(tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE)) 7929132718Skan resultcode = RDIV_EXPR; 7930132718Skan else 7931132718Skan /* Although it would be tempting to shorten always here, that 7932132718Skan loses on some targets, since the modulo instruction is 7933132718Skan undefined if the quotient can't be represented in the 7934132718Skan computation mode. We shorten only if unsigned or if 7935132718Skan dividing by something we know != -1. */ 7936169689Skan shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0)) 7937132718Skan || (TREE_CODE (op1) == INTEGER_CST 7938169689Skan && !integer_all_onesp (op1))); 7939132718Skan common = 1; 7940132718Skan } 7941132718Skan break; 7942132718Skan 7943132718Skan case BIT_AND_EXPR: 7944132718Skan case BIT_IOR_EXPR: 7945132718Skan case BIT_XOR_EXPR: 7946132718Skan if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 7947132718Skan shorten = -1; 7948132718Skan else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE) 7949132718Skan common = 1; 7950132718Skan break; 7951132718Skan 7952132718Skan case TRUNC_MOD_EXPR: 7953132718Skan case FLOOR_MOD_EXPR: 7954169689Skan if (skip_evaluation == 0 && integer_zerop (op1)) 7955169689Skan warning (OPT_Wdiv_by_zero, "division by zero"); 7956132718Skan 7957132718Skan if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 7958132718Skan { 7959132718Skan /* Although it would be tempting to shorten always here, that loses 7960132718Skan on some targets, since the modulo instruction is undefined if the 7961132718Skan quotient can't be represented in the computation mode. We shorten 7962132718Skan only if unsigned or if dividing by something we know != -1. */ 7963169689Skan shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0)) 7964132718Skan || (TREE_CODE (op1) == INTEGER_CST 7965169689Skan && !integer_all_onesp (op1))); 7966132718Skan common = 1; 7967132718Skan } 7968132718Skan break; 7969132718Skan 7970132718Skan case TRUTH_ANDIF_EXPR: 7971132718Skan case TRUTH_ORIF_EXPR: 7972132718Skan case TRUTH_AND_EXPR: 7973132718Skan case TRUTH_OR_EXPR: 7974132718Skan case TRUTH_XOR_EXPR: 7975132718Skan if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE 7976132718Skan || code0 == REAL_TYPE || code0 == COMPLEX_TYPE) 7977132718Skan && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE 7978132718Skan || code1 == REAL_TYPE || code1 == COMPLEX_TYPE)) 7979132718Skan { 7980132718Skan /* Result of these operations is always an int, 7981132718Skan but that does not mean the operands should be 7982132718Skan converted to ints! */ 7983132718Skan result_type = integer_type_node; 7984132718Skan op0 = c_common_truthvalue_conversion (op0); 7985132718Skan op1 = c_common_truthvalue_conversion (op1); 7986132718Skan converted = 1; 7987132718Skan } 7988132718Skan break; 7989132718Skan 7990132718Skan /* Shift operations: result has same type as first operand; 7991132718Skan always convert second operand to int. 7992132718Skan Also set SHORT_SHIFT if shifting rightward. */ 7993132718Skan 7994132718Skan case RSHIFT_EXPR: 7995132718Skan if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 7996132718Skan { 7997132718Skan if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0) 7998132718Skan { 7999132718Skan if (tree_int_cst_sgn (op1) < 0) 8000169689Skan warning (0, "right shift count is negative"); 8001132718Skan else 8002132718Skan { 8003169689Skan if (!integer_zerop (op1)) 8004132718Skan short_shift = 1; 8005132718Skan 8006132718Skan if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0) 8007169689Skan warning (0, "right shift count >= width of type"); 8008132718Skan } 8009132718Skan } 8010132718Skan 8011132718Skan /* Use the type of the value to be shifted. */ 8012132718Skan result_type = type0; 8013132718Skan /* Convert the shift-count to an integer, regardless of size 8014132718Skan of value being shifted. */ 8015132718Skan if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node) 8016132718Skan op1 = convert (integer_type_node, op1); 8017132718Skan /* Avoid converting op1 to result_type later. */ 8018132718Skan converted = 1; 8019132718Skan } 8020132718Skan break; 8021132718Skan 8022132718Skan case LSHIFT_EXPR: 8023132718Skan if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 8024132718Skan { 8025132718Skan if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0) 8026132718Skan { 8027132718Skan if (tree_int_cst_sgn (op1) < 0) 8028169689Skan warning (0, "left shift count is negative"); 8029132718Skan 8030132718Skan else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0) 8031169689Skan warning (0, "left shift count >= width of type"); 8032132718Skan } 8033132718Skan 8034132718Skan /* Use the type of the value to be shifted. */ 8035132718Skan result_type = type0; 8036132718Skan /* Convert the shift-count to an integer, regardless of size 8037132718Skan of value being shifted. */ 8038132718Skan if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node) 8039132718Skan op1 = convert (integer_type_node, op1); 8040132718Skan /* Avoid converting op1 to result_type later. */ 8041132718Skan converted = 1; 8042132718Skan } 8043132718Skan break; 8044132718Skan 8045132718Skan case EQ_EXPR: 8046132718Skan case NE_EXPR: 8047169689Skan if (code0 == REAL_TYPE || code1 == REAL_TYPE) 8048169689Skan warning (OPT_Wfloat_equal, 8049169689Skan "comparing floating point with == or != is unsafe"); 8050132718Skan /* Result of comparison is always int, 8051132718Skan but don't convert the args to int! */ 8052132718Skan build_type = integer_type_node; 8053132718Skan if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE 8054132718Skan || code0 == COMPLEX_TYPE) 8055132718Skan && (code1 == INTEGER_TYPE || code1 == REAL_TYPE 8056132718Skan || code1 == COMPLEX_TYPE)) 8057132718Skan short_compare = 1; 8058132718Skan else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE) 8059132718Skan { 8060132718Skan tree tt0 = TREE_TYPE (type0); 8061132718Skan tree tt1 = TREE_TYPE (type1); 8062132718Skan /* Anything compares with void *. void * compares with anything. 8063132718Skan Otherwise, the targets must be compatible 8064132718Skan and both must be object or both incomplete. */ 8065169689Skan if (comp_target_types (type0, type1)) 8066169689Skan result_type = common_pointer_type (type0, type1); 8067132718Skan else if (VOID_TYPE_P (tt0)) 8068132718Skan { 8069132718Skan /* op0 != orig_op0 detects the case of something 8070132718Skan whose value is 0 but which isn't a valid null ptr const. */ 8071169689Skan if (pedantic && !null_pointer_constant_p (orig_op0) 8072132718Skan && TREE_CODE (tt1) == FUNCTION_TYPE) 8073169689Skan pedwarn ("ISO C forbids comparison of %<void *%>" 8074169689Skan " with function pointer"); 8075132718Skan } 8076132718Skan else if (VOID_TYPE_P (tt1)) 8077132718Skan { 8078169689Skan if (pedantic && !null_pointer_constant_p (orig_op1) 8079132718Skan && TREE_CODE (tt0) == FUNCTION_TYPE) 8080169689Skan pedwarn ("ISO C forbids comparison of %<void *%>" 8081169689Skan " with function pointer"); 8082132718Skan } 8083132718Skan else 8084169689Skan /* Avoid warning about the volatile ObjC EH puts on decls. */ 8085169689Skan if (!objc_ok) 8086169689Skan pedwarn ("comparison of distinct pointer types lacks a cast"); 8087132718Skan 8088132718Skan if (result_type == NULL_TREE) 8089132718Skan result_type = ptr_type_node; 8090132718Skan } 8091169689Skan else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1)) 8092169689Skan { 8093169689Skan if (TREE_CODE (op0) == ADDR_EXPR 8094169689Skan && DECL_P (TREE_OPERAND (op0, 0)) 8095169689Skan && (TREE_CODE (TREE_OPERAND (op0, 0)) == PARM_DECL 8096169689Skan || TREE_CODE (TREE_OPERAND (op0, 0)) == LABEL_DECL 8097169689Skan || !DECL_WEAK (TREE_OPERAND (op0, 0)))) 8098169689Skan warning (OPT_Waddress, "the address of %qD will never be NULL", 8099169689Skan TREE_OPERAND (op0, 0)); 8100169689Skan result_type = type0; 8101169689Skan } 8102169689Skan else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0)) 8103169689Skan { 8104169689Skan if (TREE_CODE (op1) == ADDR_EXPR 8105169689Skan && DECL_P (TREE_OPERAND (op1, 0)) 8106169689Skan && (TREE_CODE (TREE_OPERAND (op1, 0)) == PARM_DECL 8107169689Skan || TREE_CODE (TREE_OPERAND (op1, 0)) == LABEL_DECL 8108169689Skan || !DECL_WEAK (TREE_OPERAND (op1, 0)))) 8109169689Skan warning (OPT_Waddress, "the address of %qD will never be NULL", 8110169689Skan TREE_OPERAND (op1, 0)); 8111169689Skan result_type = type1; 8112169689Skan } 8113132718Skan else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 8114132718Skan { 8115132718Skan result_type = type0; 8116132718Skan pedwarn ("comparison between pointer and integer"); 8117132718Skan } 8118132718Skan else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE) 8119132718Skan { 8120132718Skan result_type = type1; 8121132718Skan pedwarn ("comparison between pointer and integer"); 8122132718Skan } 8123132718Skan break; 8124132718Skan 8125132718Skan case LE_EXPR: 8126132718Skan case GE_EXPR: 8127132718Skan case LT_EXPR: 8128132718Skan case GT_EXPR: 8129132718Skan build_type = integer_type_node; 8130132718Skan if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE) 8131132718Skan && (code1 == INTEGER_TYPE || code1 == REAL_TYPE)) 8132132718Skan short_compare = 1; 8133132718Skan else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE) 8134132718Skan { 8135169689Skan if (comp_target_types (type0, type1)) 8136132718Skan { 8137169689Skan result_type = common_pointer_type (type0, type1); 8138132718Skan if (!COMPLETE_TYPE_P (TREE_TYPE (type0)) 8139132718Skan != !COMPLETE_TYPE_P (TREE_TYPE (type1))) 8140132718Skan pedwarn ("comparison of complete and incomplete pointers"); 8141132718Skan else if (pedantic 8142132718Skan && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE) 8143132718Skan pedwarn ("ISO C forbids ordered comparisons of pointers to functions"); 8144132718Skan } 8145132718Skan else 8146132718Skan { 8147132718Skan result_type = ptr_type_node; 8148132718Skan pedwarn ("comparison of distinct pointer types lacks a cast"); 8149132718Skan } 8150132718Skan } 8151169689Skan else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1)) 8152132718Skan { 8153132718Skan result_type = type0; 8154132718Skan if (pedantic || extra_warnings) 8155132718Skan pedwarn ("ordered comparison of pointer with integer zero"); 8156132718Skan } 8157169689Skan else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0)) 8158132718Skan { 8159132718Skan result_type = type1; 8160132718Skan if (pedantic) 8161132718Skan pedwarn ("ordered comparison of pointer with integer zero"); 8162132718Skan } 8163132718Skan else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 8164132718Skan { 8165132718Skan result_type = type0; 8166132718Skan pedwarn ("comparison between pointer and integer"); 8167132718Skan } 8168132718Skan else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE) 8169132718Skan { 8170132718Skan result_type = type1; 8171132718Skan pedwarn ("comparison between pointer and integer"); 8172132718Skan } 8173132718Skan break; 8174132718Skan 8175132718Skan default: 8176169689Skan gcc_unreachable (); 8177132718Skan } 8178132718Skan 8179169689Skan if (code0 == ERROR_MARK || code1 == ERROR_MARK) 8180169689Skan return error_mark_node; 8181169689Skan 8182169689Skan if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE 8183169689Skan && (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1)) 8184169689Skan || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0), 8185169689Skan TREE_TYPE (type1)))) 8186169689Skan { 8187169689Skan binary_op_error (code); 8188169689Skan return error_mark_node; 8189169689Skan } 8190169689Skan 8191132718Skan if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE 8192132718Skan || code0 == VECTOR_TYPE) 8193132718Skan && 8194132718Skan (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE 8195132718Skan || code1 == VECTOR_TYPE)) 8196132718Skan { 8197132718Skan int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE); 8198132718Skan 8199132718Skan if (shorten || common || short_compare) 8200169689Skan result_type = c_common_type (type0, type1); 8201132718Skan 8202132718Skan /* For certain operations (which identify themselves by shorten != 0) 8203132718Skan if both args were extended from the same smaller type, 8204132718Skan do the arithmetic in that type and then extend. 8205132718Skan 8206132718Skan shorten !=0 and !=1 indicates a bitwise operation. 8207132718Skan For them, this optimization is safe only if 8208132718Skan both args are zero-extended or both are sign-extended. 8209132718Skan Otherwise, we might change the result. 8210132718Skan Eg, (short)-1 | (unsigned short)-1 is (int)-1 8211132718Skan but calculated in (unsigned short) it would be (unsigned short)-1. */ 8212132718Skan 8213132718Skan if (shorten && none_complex) 8214132718Skan { 8215132718Skan int unsigned0, unsigned1; 8216169689Skan tree arg0, arg1; 8217169689Skan int uns; 8218132718Skan tree type; 8219132718Skan 8220169689Skan /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents 8221169689Skan excessive narrowing when we call get_narrower below. For 8222169689Skan example, suppose that OP0 is of unsigned int extended 8223169689Skan from signed char and that RESULT_TYPE is long long int. 8224169689Skan If we explicitly cast OP0 to RESULT_TYPE, OP0 would look 8225169689Skan like 8226169689Skan 8227169689Skan (long long int) (unsigned int) signed_char 8228169689Skan 8229169689Skan which get_narrower would narrow down to 8230169689Skan 8231169689Skan (unsigned int) signed char 8232169689Skan 8233169689Skan If we do not cast OP0 first, get_narrower would return 8234169689Skan signed_char, which is inconsistent with the case of the 8235169689Skan explicit cast. */ 8236169689Skan op0 = convert (result_type, op0); 8237169689Skan op1 = convert (result_type, op1); 8238169689Skan 8239169689Skan arg0 = get_narrower (op0, &unsigned0); 8240169689Skan arg1 = get_narrower (op1, &unsigned1); 8241169689Skan 8242169689Skan /* UNS is 1 if the operation to be done is an unsigned one. */ 8243169689Skan uns = TYPE_UNSIGNED (result_type); 8244169689Skan 8245132718Skan final_type = result_type; 8246132718Skan 8247132718Skan /* Handle the case that OP0 (or OP1) does not *contain* a conversion 8248132718Skan but it *requires* conversion to FINAL_TYPE. */ 8249132718Skan 8250132718Skan if ((TYPE_PRECISION (TREE_TYPE (op0)) 8251132718Skan == TYPE_PRECISION (TREE_TYPE (arg0))) 8252132718Skan && TREE_TYPE (op0) != final_type) 8253169689Skan unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0)); 8254132718Skan if ((TYPE_PRECISION (TREE_TYPE (op1)) 8255132718Skan == TYPE_PRECISION (TREE_TYPE (arg1))) 8256132718Skan && TREE_TYPE (op1) != final_type) 8257169689Skan unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1)); 8258132718Skan 8259132718Skan /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */ 8260132718Skan 8261132718Skan /* For bitwise operations, signedness of nominal type 8262132718Skan does not matter. Consider only how operands were extended. */ 8263132718Skan if (shorten == -1) 8264132718Skan uns = unsigned0; 8265132718Skan 8266132718Skan /* Note that in all three cases below we refrain from optimizing 8267132718Skan an unsigned operation on sign-extended args. 8268132718Skan That would not be valid. */ 8269132718Skan 8270132718Skan /* Both args variable: if both extended in same way 8271132718Skan from same width, do it in that width. 8272132718Skan Do it unsigned if args were zero-extended. */ 8273132718Skan if ((TYPE_PRECISION (TREE_TYPE (arg0)) 8274132718Skan < TYPE_PRECISION (result_type)) 8275132718Skan && (TYPE_PRECISION (TREE_TYPE (arg1)) 8276132718Skan == TYPE_PRECISION (TREE_TYPE (arg0))) 8277132718Skan && unsigned0 == unsigned1 8278132718Skan && (unsigned0 || !uns)) 8279132718Skan result_type 8280132718Skan = c_common_signed_or_unsigned_type 8281132718Skan (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1))); 8282132718Skan else if (TREE_CODE (arg0) == INTEGER_CST 8283132718Skan && (unsigned1 || !uns) 8284132718Skan && (TYPE_PRECISION (TREE_TYPE (arg1)) 8285132718Skan < TYPE_PRECISION (result_type)) 8286132718Skan && (type 8287132718Skan = c_common_signed_or_unsigned_type (unsigned1, 8288132718Skan TREE_TYPE (arg1)), 8289132718Skan int_fits_type_p (arg0, type))) 8290132718Skan result_type = type; 8291132718Skan else if (TREE_CODE (arg1) == INTEGER_CST 8292132718Skan && (unsigned0 || !uns) 8293132718Skan && (TYPE_PRECISION (TREE_TYPE (arg0)) 8294132718Skan < TYPE_PRECISION (result_type)) 8295132718Skan && (type 8296132718Skan = c_common_signed_or_unsigned_type (unsigned0, 8297132718Skan TREE_TYPE (arg0)), 8298132718Skan int_fits_type_p (arg1, type))) 8299132718Skan result_type = type; 8300132718Skan } 8301132718Skan 8302132718Skan /* Shifts can be shortened if shifting right. */ 8303132718Skan 8304132718Skan if (short_shift) 8305132718Skan { 8306132718Skan int unsigned_arg; 8307132718Skan tree arg0 = get_narrower (op0, &unsigned_arg); 8308132718Skan 8309132718Skan final_type = result_type; 8310132718Skan 8311132718Skan if (arg0 == op0 && final_type == TREE_TYPE (op0)) 8312169689Skan unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0)); 8313132718Skan 8314132718Skan if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type) 8315132718Skan /* We can shorten only if the shift count is less than the 8316132718Skan number of bits in the smaller type size. */ 8317132718Skan && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0 8318132718Skan /* We cannot drop an unsigned shift after sign-extension. */ 8319169689Skan && (!TYPE_UNSIGNED (final_type) || unsigned_arg)) 8320132718Skan { 8321132718Skan /* Do an unsigned shift if the operand was zero-extended. */ 8322132718Skan result_type 8323132718Skan = c_common_signed_or_unsigned_type (unsigned_arg, 8324132718Skan TREE_TYPE (arg0)); 8325132718Skan /* Convert value-to-be-shifted to that type. */ 8326132718Skan if (TREE_TYPE (op0) != result_type) 8327132718Skan op0 = convert (result_type, op0); 8328132718Skan converted = 1; 8329132718Skan } 8330132718Skan } 8331132718Skan 8332132718Skan /* Comparison operations are shortened too but differently. 8333132718Skan They identify themselves by setting short_compare = 1. */ 8334132718Skan 8335132718Skan if (short_compare) 8336132718Skan { 8337132718Skan /* Don't write &op0, etc., because that would prevent op0 8338132718Skan from being kept in a register. 8339132718Skan Instead, make copies of the our local variables and 8340132718Skan pass the copies by reference, then copy them back afterward. */ 8341132718Skan tree xop0 = op0, xop1 = op1, xresult_type = result_type; 8342132718Skan enum tree_code xresultcode = resultcode; 8343132718Skan tree val 8344132718Skan = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode); 8345132718Skan 8346132718Skan if (val != 0) 8347132718Skan return val; 8348132718Skan 8349132718Skan op0 = xop0, op1 = xop1; 8350132718Skan converted = 1; 8351132718Skan resultcode = xresultcode; 8352132718Skan 8353132718Skan if (warn_sign_compare && skip_evaluation == 0) 8354132718Skan { 8355169689Skan int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0)); 8356169689Skan int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1)); 8357132718Skan int unsignedp0, unsignedp1; 8358132718Skan tree primop0 = get_narrower (op0, &unsignedp0); 8359132718Skan tree primop1 = get_narrower (op1, &unsignedp1); 8360132718Skan 8361132718Skan xop0 = orig_op0; 8362132718Skan xop1 = orig_op1; 8363132718Skan STRIP_TYPE_NOPS (xop0); 8364132718Skan STRIP_TYPE_NOPS (xop1); 8365132718Skan 8366132718Skan /* Give warnings for comparisons between signed and unsigned 8367132718Skan quantities that may fail. 8368132718Skan 8369132718Skan Do the checking based on the original operand trees, so that 8370132718Skan casts will be considered, but default promotions won't be. 8371132718Skan 8372132718Skan Do not warn if the comparison is being done in a signed type, 8373132718Skan since the signed type will only be chosen if it can represent 8374132718Skan all the values of the unsigned type. */ 8375169689Skan if (!TYPE_UNSIGNED (result_type)) 8376132718Skan /* OK */; 8377169689Skan /* Do not warn if both operands are the same signedness. */ 8378169689Skan else if (op0_signed == op1_signed) 8379169689Skan /* OK */; 8380132718Skan else 8381132718Skan { 8382132718Skan tree sop, uop; 8383169689Skan bool ovf; 8384132718Skan 8385132718Skan if (op0_signed) 8386132718Skan sop = xop0, uop = xop1; 8387132718Skan else 8388132718Skan sop = xop1, uop = xop0; 8389132718Skan 8390132718Skan /* Do not warn if the signed quantity is an 8391132718Skan unsuffixed integer literal (or some static 8392132718Skan constant expression involving such literals or a 8393132718Skan conditional expression involving such literals) 8394132718Skan and it is non-negative. */ 8395169689Skan if (tree_expr_nonnegative_warnv_p (sop, &ovf)) 8396132718Skan /* OK */; 8397132718Skan /* Do not warn if the comparison is an equality operation, 8398132718Skan the unsigned quantity is an integral constant, and it 8399132718Skan would fit in the result if the result were signed. */ 8400132718Skan else if (TREE_CODE (uop) == INTEGER_CST 8401132718Skan && (resultcode == EQ_EXPR || resultcode == NE_EXPR) 8402132718Skan && int_fits_type_p 8403132718Skan (uop, c_common_signed_type (result_type))) 8404132718Skan /* OK */; 8405132718Skan /* Do not warn if the unsigned quantity is an enumeration 8406132718Skan constant and its maximum value would fit in the result 8407132718Skan if the result were signed. */ 8408132718Skan else if (TREE_CODE (uop) == INTEGER_CST 8409132718Skan && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE 8410132718Skan && int_fits_type_p 8411169689Skan (TYPE_MAX_VALUE (TREE_TYPE (uop)), 8412132718Skan c_common_signed_type (result_type))) 8413132718Skan /* OK */; 8414132718Skan else 8415169689Skan warning (0, "comparison between signed and unsigned"); 8416132718Skan } 8417132718Skan 8418132718Skan /* Warn if two unsigned values are being compared in a size 8419132718Skan larger than their original size, and one (and only one) is the 8420132718Skan result of a `~' operator. This comparison will always fail. 8421132718Skan 8422132718Skan Also warn if one operand is a constant, and the constant 8423132718Skan does not have all bits set that are set in the ~ operand 8424132718Skan when it is extended. */ 8425132718Skan 8426132718Skan if ((TREE_CODE (primop0) == BIT_NOT_EXPR) 8427132718Skan != (TREE_CODE (primop1) == BIT_NOT_EXPR)) 8428132718Skan { 8429132718Skan if (TREE_CODE (primop0) == BIT_NOT_EXPR) 8430132718Skan primop0 = get_narrower (TREE_OPERAND (primop0, 0), 8431132718Skan &unsignedp0); 8432132718Skan else 8433132718Skan primop1 = get_narrower (TREE_OPERAND (primop1, 0), 8434132718Skan &unsignedp1); 8435132718Skan 8436132718Skan if (host_integerp (primop0, 0) || host_integerp (primop1, 0)) 8437132718Skan { 8438132718Skan tree primop; 8439132718Skan HOST_WIDE_INT constant, mask; 8440132718Skan int unsignedp, bits; 8441132718Skan 8442132718Skan if (host_integerp (primop0, 0)) 8443132718Skan { 8444132718Skan primop = primop1; 8445132718Skan unsignedp = unsignedp1; 8446132718Skan constant = tree_low_cst (primop0, 0); 8447132718Skan } 8448132718Skan else 8449132718Skan { 8450132718Skan primop = primop0; 8451132718Skan unsignedp = unsignedp0; 8452132718Skan constant = tree_low_cst (primop1, 0); 8453132718Skan } 8454132718Skan 8455132718Skan bits = TYPE_PRECISION (TREE_TYPE (primop)); 8456132718Skan if (bits < TYPE_PRECISION (result_type) 8457132718Skan && bits < HOST_BITS_PER_WIDE_INT && unsignedp) 8458132718Skan { 8459169689Skan mask = (~(HOST_WIDE_INT) 0) << bits; 8460132718Skan if ((mask & constant) != mask) 8461169689Skan warning (0, "comparison of promoted ~unsigned with constant"); 8462132718Skan } 8463132718Skan } 8464132718Skan else if (unsignedp0 && unsignedp1 8465132718Skan && (TYPE_PRECISION (TREE_TYPE (primop0)) 8466132718Skan < TYPE_PRECISION (result_type)) 8467132718Skan && (TYPE_PRECISION (TREE_TYPE (primop1)) 8468132718Skan < TYPE_PRECISION (result_type))) 8469169689Skan warning (0, "comparison of promoted ~unsigned with unsigned"); 8470132718Skan } 8471132718Skan } 8472132718Skan } 8473132718Skan } 8474132718Skan 8475132718Skan /* At this point, RESULT_TYPE must be nonzero to avoid an error message. 8476132718Skan If CONVERTED is zero, both args will be converted to type RESULT_TYPE. 8477132718Skan Then the expression will be built. 8478132718Skan It will be given type FINAL_TYPE if that is nonzero; 8479132718Skan otherwise, it will be given type RESULT_TYPE. */ 8480132718Skan 8481132718Skan if (!result_type) 8482132718Skan { 8483132718Skan binary_op_error (code); 8484132718Skan return error_mark_node; 8485132718Skan } 8486132718Skan 8487169689Skan if (!converted) 8488132718Skan { 8489132718Skan if (TREE_TYPE (op0) != result_type) 8490169689Skan op0 = convert_and_check (result_type, op0); 8491132718Skan if (TREE_TYPE (op1) != result_type) 8492169689Skan op1 = convert_and_check (result_type, op1); 8493169689Skan 8494169689Skan /* This can happen if one operand has a vector type, and the other 8495169689Skan has a different type. */ 8496169689Skan if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK) 8497169689Skan return error_mark_node; 8498132718Skan } 8499132718Skan 8500132718Skan if (build_type == NULL_TREE) 8501132718Skan build_type = result_type; 8502132718Skan 8503132718Skan { 8504169689Skan /* Treat expressions in initializers specially as they can't trap. */ 8505169689Skan tree result = require_constant_value ? fold_build2_initializer (resultcode, 8506169689Skan build_type, 8507169689Skan op0, op1) 8508169689Skan : fold_build2 (resultcode, build_type, 8509169689Skan op0, op1); 8510132718Skan 8511132718Skan if (final_type != 0) 8512169689Skan result = convert (final_type, result); 8513169689Skan return result; 8514132718Skan } 8515132718Skan} 8516169689Skan 8517169689Skan 8518169689Skan/* Convert EXPR to be a truth-value, validating its type for this 8519169689Skan purpose. */ 8520169689Skan 8521169689Skantree 8522169689Skanc_objc_common_truthvalue_conversion (tree expr) 8523169689Skan{ 8524169689Skan switch (TREE_CODE (TREE_TYPE (expr))) 8525169689Skan { 8526169689Skan case ARRAY_TYPE: 8527169689Skan error ("used array that cannot be converted to pointer where scalar is required"); 8528169689Skan return error_mark_node; 8529169689Skan 8530169689Skan case RECORD_TYPE: 8531169689Skan error ("used struct type value where scalar is required"); 8532169689Skan return error_mark_node; 8533169689Skan 8534169689Skan case UNION_TYPE: 8535169689Skan error ("used union type value where scalar is required"); 8536169689Skan return error_mark_node; 8537169689Skan 8538169689Skan case FUNCTION_TYPE: 8539169689Skan gcc_unreachable (); 8540169689Skan 8541169689Skan default: 8542169689Skan break; 8543169689Skan } 8544169689Skan 8545169689Skan /* ??? Should we also give an error for void and vectors rather than 8546169689Skan leaving those to give errors later? */ 8547169689Skan return c_common_truthvalue_conversion (expr); 8548169689Skan} 8549169689Skan 8550169689Skan 8551169689Skan/* Convert EXPR to a contained DECL, updating *TC, *TI and *SE as 8552169689Skan required. */ 8553169689Skan 8554169689Skantree 8555169689Skanc_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, 8556169689Skan bool *ti ATTRIBUTE_UNUSED, bool *se) 8557169689Skan{ 8558169689Skan if (TREE_CODE (expr) == COMPOUND_LITERAL_EXPR) 8559169689Skan { 8560169689Skan tree decl = COMPOUND_LITERAL_EXPR_DECL (expr); 8561169689Skan /* Executing a compound literal inside a function reinitializes 8562169689Skan it. */ 8563169689Skan if (!TREE_STATIC (decl)) 8564169689Skan *se = true; 8565169689Skan return decl; 8566169689Skan } 8567169689Skan else 8568169689Skan return expr; 8569169689Skan} 8570169689Skan 8571169689Skan/* Like c_begin_compound_stmt, except force the retention of the BLOCK. */ 8572169689Skan 8573169689Skantree 8574169689Skanc_begin_omp_parallel (void) 8575169689Skan{ 8576169689Skan tree block; 8577169689Skan 8578169689Skan keep_next_level (); 8579169689Skan block = c_begin_compound_stmt (true); 8580169689Skan 8581169689Skan return block; 8582169689Skan} 8583169689Skan 8584169689Skantree 8585169689Skanc_finish_omp_parallel (tree clauses, tree block) 8586169689Skan{ 8587169689Skan tree stmt; 8588169689Skan 8589169689Skan block = c_end_compound_stmt (block, true); 8590169689Skan 8591169689Skan stmt = make_node (OMP_PARALLEL); 8592169689Skan TREE_TYPE (stmt) = void_type_node; 8593169689Skan OMP_PARALLEL_CLAUSES (stmt) = clauses; 8594169689Skan OMP_PARALLEL_BODY (stmt) = block; 8595169689Skan 8596169689Skan return add_stmt (stmt); 8597169689Skan} 8598169689Skan 8599169689Skan/* For all elements of CLAUSES, validate them vs OpenMP constraints. 8600169689Skan Remove any elements from the list that are invalid. */ 8601169689Skan 8602169689Skantree 8603169689Skanc_finish_omp_clauses (tree clauses) 8604169689Skan{ 8605169689Skan bitmap_head generic_head, firstprivate_head, lastprivate_head; 8606169689Skan tree c, t, *pc = &clauses; 8607169689Skan const char *name; 8608169689Skan 8609169689Skan bitmap_obstack_initialize (NULL); 8610169689Skan bitmap_initialize (&generic_head, &bitmap_default_obstack); 8611169689Skan bitmap_initialize (&firstprivate_head, &bitmap_default_obstack); 8612169689Skan bitmap_initialize (&lastprivate_head, &bitmap_default_obstack); 8613169689Skan 8614169689Skan for (pc = &clauses, c = clauses; c ; c = *pc) 8615169689Skan { 8616169689Skan bool remove = false; 8617169689Skan bool need_complete = false; 8618169689Skan bool need_implicitly_determined = false; 8619169689Skan 8620169689Skan switch (OMP_CLAUSE_CODE (c)) 8621169689Skan { 8622169689Skan case OMP_CLAUSE_SHARED: 8623169689Skan name = "shared"; 8624169689Skan need_implicitly_determined = true; 8625169689Skan goto check_dup_generic; 8626169689Skan 8627169689Skan case OMP_CLAUSE_PRIVATE: 8628169689Skan name = "private"; 8629169689Skan need_complete = true; 8630169689Skan need_implicitly_determined = true; 8631169689Skan goto check_dup_generic; 8632169689Skan 8633169689Skan case OMP_CLAUSE_REDUCTION: 8634169689Skan name = "reduction"; 8635169689Skan need_implicitly_determined = true; 8636169689Skan t = OMP_CLAUSE_DECL (c); 8637169689Skan if (AGGREGATE_TYPE_P (TREE_TYPE (t)) 8638169689Skan || POINTER_TYPE_P (TREE_TYPE (t))) 8639169689Skan { 8640169689Skan error ("%qE has invalid type for %<reduction%>", t); 8641169689Skan remove = true; 8642169689Skan } 8643169689Skan else if (FLOAT_TYPE_P (TREE_TYPE (t))) 8644169689Skan { 8645169689Skan enum tree_code r_code = OMP_CLAUSE_REDUCTION_CODE (c); 8646169689Skan const char *r_name = NULL; 8647169689Skan 8648169689Skan switch (r_code) 8649169689Skan { 8650169689Skan case PLUS_EXPR: 8651169689Skan case MULT_EXPR: 8652169689Skan case MINUS_EXPR: 8653169689Skan break; 8654169689Skan case BIT_AND_EXPR: 8655169689Skan r_name = "&"; 8656169689Skan break; 8657169689Skan case BIT_XOR_EXPR: 8658169689Skan r_name = "^"; 8659169689Skan break; 8660169689Skan case BIT_IOR_EXPR: 8661169689Skan r_name = "|"; 8662169689Skan break; 8663169689Skan case TRUTH_ANDIF_EXPR: 8664169689Skan r_name = "&&"; 8665169689Skan break; 8666169689Skan case TRUTH_ORIF_EXPR: 8667169689Skan r_name = "||"; 8668169689Skan break; 8669169689Skan default: 8670169689Skan gcc_unreachable (); 8671169689Skan } 8672169689Skan if (r_name) 8673169689Skan { 8674169689Skan error ("%qE has invalid type for %<reduction(%s)%>", 8675169689Skan t, r_name); 8676169689Skan remove = true; 8677169689Skan } 8678169689Skan } 8679169689Skan goto check_dup_generic; 8680169689Skan 8681169689Skan case OMP_CLAUSE_COPYPRIVATE: 8682169689Skan name = "copyprivate"; 8683169689Skan goto check_dup_generic; 8684169689Skan 8685169689Skan case OMP_CLAUSE_COPYIN: 8686169689Skan name = "copyin"; 8687169689Skan t = OMP_CLAUSE_DECL (c); 8688169689Skan if (TREE_CODE (t) != VAR_DECL || !DECL_THREAD_LOCAL_P (t)) 8689169689Skan { 8690169689Skan error ("%qE must be %<threadprivate%> for %<copyin%>", t); 8691169689Skan remove = true; 8692169689Skan } 8693169689Skan goto check_dup_generic; 8694169689Skan 8695169689Skan check_dup_generic: 8696169689Skan t = OMP_CLAUSE_DECL (c); 8697169689Skan if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL) 8698169689Skan { 8699169689Skan error ("%qE is not a variable in clause %qs", t, name); 8700169689Skan remove = true; 8701169689Skan } 8702169689Skan else if (bitmap_bit_p (&generic_head, DECL_UID (t)) 8703169689Skan || bitmap_bit_p (&firstprivate_head, DECL_UID (t)) 8704169689Skan || bitmap_bit_p (&lastprivate_head, DECL_UID (t))) 8705169689Skan { 8706169689Skan error ("%qE appears more than once in data clauses", t); 8707169689Skan remove = true; 8708169689Skan } 8709169689Skan else 8710169689Skan bitmap_set_bit (&generic_head, DECL_UID (t)); 8711169689Skan break; 8712169689Skan 8713169689Skan case OMP_CLAUSE_FIRSTPRIVATE: 8714169689Skan name = "firstprivate"; 8715169689Skan t = OMP_CLAUSE_DECL (c); 8716169689Skan need_complete = true; 8717169689Skan need_implicitly_determined = true; 8718169689Skan if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL) 8719169689Skan { 8720169689Skan error ("%qE is not a variable in clause %<firstprivate%>", t); 8721169689Skan remove = true; 8722169689Skan } 8723169689Skan else if (bitmap_bit_p (&generic_head, DECL_UID (t)) 8724169689Skan || bitmap_bit_p (&firstprivate_head, DECL_UID (t))) 8725169689Skan { 8726169689Skan error ("%qE appears more than once in data clauses", t); 8727169689Skan remove = true; 8728169689Skan } 8729169689Skan else 8730169689Skan bitmap_set_bit (&firstprivate_head, DECL_UID (t)); 8731169689Skan break; 8732169689Skan 8733169689Skan case OMP_CLAUSE_LASTPRIVATE: 8734169689Skan name = "lastprivate"; 8735169689Skan t = OMP_CLAUSE_DECL (c); 8736169689Skan need_complete = true; 8737169689Skan need_implicitly_determined = true; 8738169689Skan if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL) 8739169689Skan { 8740169689Skan error ("%qE is not a variable in clause %<lastprivate%>", t); 8741169689Skan remove = true; 8742169689Skan } 8743169689Skan else if (bitmap_bit_p (&generic_head, DECL_UID (t)) 8744169689Skan || bitmap_bit_p (&lastprivate_head, DECL_UID (t))) 8745169689Skan { 8746169689Skan error ("%qE appears more than once in data clauses", t); 8747169689Skan remove = true; 8748169689Skan } 8749169689Skan else 8750169689Skan bitmap_set_bit (&lastprivate_head, DECL_UID (t)); 8751169689Skan break; 8752169689Skan 8753169689Skan case OMP_CLAUSE_IF: 8754169689Skan case OMP_CLAUSE_NUM_THREADS: 8755169689Skan case OMP_CLAUSE_SCHEDULE: 8756169689Skan case OMP_CLAUSE_NOWAIT: 8757169689Skan case OMP_CLAUSE_ORDERED: 8758169689Skan case OMP_CLAUSE_DEFAULT: 8759169689Skan pc = &OMP_CLAUSE_CHAIN (c); 8760169689Skan continue; 8761169689Skan 8762169689Skan default: 8763169689Skan gcc_unreachable (); 8764169689Skan } 8765169689Skan 8766169689Skan if (!remove) 8767169689Skan { 8768169689Skan t = OMP_CLAUSE_DECL (c); 8769169689Skan 8770169689Skan if (need_complete) 8771169689Skan { 8772169689Skan t = require_complete_type (t); 8773169689Skan if (t == error_mark_node) 8774169689Skan remove = true; 8775169689Skan } 8776169689Skan 8777169689Skan if (need_implicitly_determined) 8778169689Skan { 8779169689Skan const char *share_name = NULL; 8780169689Skan 8781169689Skan if (TREE_CODE (t) == VAR_DECL && DECL_THREAD_LOCAL_P (t)) 8782169689Skan share_name = "threadprivate"; 8783169689Skan else switch (c_omp_predetermined_sharing (t)) 8784169689Skan { 8785169689Skan case OMP_CLAUSE_DEFAULT_UNSPECIFIED: 8786169689Skan break; 8787169689Skan case OMP_CLAUSE_DEFAULT_SHARED: 8788169689Skan share_name = "shared"; 8789169689Skan break; 8790169689Skan case OMP_CLAUSE_DEFAULT_PRIVATE: 8791169689Skan share_name = "private"; 8792169689Skan break; 8793169689Skan default: 8794169689Skan gcc_unreachable (); 8795169689Skan } 8796169689Skan if (share_name) 8797169689Skan { 8798169689Skan error ("%qE is predetermined %qs for %qs", 8799169689Skan t, share_name, name); 8800169689Skan remove = true; 8801169689Skan } 8802169689Skan } 8803169689Skan } 8804169689Skan 8805169689Skan if (remove) 8806169689Skan *pc = OMP_CLAUSE_CHAIN (c); 8807169689Skan else 8808169689Skan pc = &OMP_CLAUSE_CHAIN (c); 8809169689Skan } 8810169689Skan 8811169689Skan bitmap_obstack_release (NULL); 8812169689Skan return clauses; 8813169689Skan} 8814