c-typeck.c revision 259948
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 { 1879259406Spfg if (TREE_CODE (pointer) == CONVERT_EXPR 1880259406Spfg || TREE_CODE (pointer) == NOP_EXPR 1881259406Spfg || TREE_CODE (pointer) == VIEW_CONVERT_EXPR) 1882259406Spfg { 1883259406Spfg /* If a warning is issued, mark it to avoid duplicates from 1884259406Spfg the backend. This only needs to be done at 1885259406Spfg warn_strict_aliasing > 2. */ 1886259406Spfg if (warn_strict_aliasing > 2) 1887259406Spfg if (strict_aliasing_warning (TREE_TYPE (TREE_OPERAND (pointer, 0)), 1888259406Spfg type, TREE_OPERAND (pointer, 0))) 1889259406Spfg TREE_NO_WARNING (pointer) = 1; 1890259406Spfg } 1891259406Spfg 189218334Speter if (TREE_CODE (pointer) == ADDR_EXPR 189318334Speter && (TREE_TYPE (TREE_OPERAND (pointer, 0)) 189418334Speter == TREE_TYPE (type))) 189518334Speter return TREE_OPERAND (pointer, 0); 189618334Speter else 189718334Speter { 189818334Speter tree t = TREE_TYPE (type); 1899169689Skan tree ref; 190018334Speter 1901169689Skan ref = build1 (INDIRECT_REF, t, pointer); 1902169689Skan 190390075Sobrien if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE) 190418334Speter { 190518334Speter error ("dereferencing pointer to incomplete type"); 190618334Speter return error_mark_node; 190718334Speter } 190890075Sobrien if (VOID_TYPE_P (t) && skip_evaluation == 0) 1909169689Skan warning (0, "dereferencing %<void *%> pointer"); 191018334Speter 191118334Speter /* We *must* set TREE_READONLY when dereferencing a pointer to const, 191218334Speter so that we get the proper error message if the result is used 191318334Speter to assign to. Also, &* is supposed to be a no-op. 191418334Speter And ANSI C seems to specify that the type of the result 191518334Speter should be the const type. */ 191618334Speter /* A de-reference of a pointer to const is not a const. It is valid 191718334Speter to change it via some other pointer. */ 191818334Speter TREE_READONLY (ref) = TYPE_READONLY (t); 191918334Speter TREE_SIDE_EFFECTS (ref) 1920132718Skan = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer); 192118334Speter TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t); 192218334Speter return ref; 192318334Speter } 192418334Speter } 192518334Speter else if (TREE_CODE (pointer) != ERROR_MARK) 1926259948Spfg error ("invalid type argument of %qs (have %qT)", errorstring, type); 192718334Speter return error_mark_node; 192818334Speter} 192918334Speter 193018334Speter/* This handles expressions of the form "a[i]", which denotes 193118334Speter an array reference. 193218334Speter 193318334Speter This is logically equivalent in C to *(a+i), but we may do it differently. 193418334Speter If A is a variable or a member, we generate a primitive ARRAY_REF. 193518334Speter This avoids forcing the array out of registers, and can work on 193618334Speter arrays that are not lvalues (for example, members of structures returned 193718334Speter by functions). */ 193818334Speter 193918334Spetertree 1940132718Skanbuild_array_ref (tree array, tree index) 194118334Speter{ 1942169689Skan bool swapped = false; 194318334Speter if (TREE_TYPE (array) == error_mark_node 194418334Speter || TREE_TYPE (index) == error_mark_node) 194518334Speter return error_mark_node; 194618334Speter 1947169689Skan if (TREE_CODE (TREE_TYPE (array)) != ARRAY_TYPE 1948169689Skan && TREE_CODE (TREE_TYPE (array)) != POINTER_TYPE) 194918334Speter { 1950169689Skan tree temp; 1951169689Skan if (TREE_CODE (TREE_TYPE (index)) != ARRAY_TYPE 1952169689Skan && TREE_CODE (TREE_TYPE (index)) != POINTER_TYPE) 195318334Speter { 1954169689Skan error ("subscripted value is neither array nor pointer"); 195518334Speter return error_mark_node; 195618334Speter } 1957169689Skan temp = array; 1958169689Skan array = index; 1959169689Skan index = temp; 1960169689Skan swapped = true; 1961169689Skan } 196218334Speter 1963169689Skan if (!INTEGRAL_TYPE_P (TREE_TYPE (index))) 1964169689Skan { 1965169689Skan error ("array subscript is not an integer"); 1966169689Skan return error_mark_node; 1967169689Skan } 1968169689Skan 1969169689Skan if (TREE_CODE (TREE_TYPE (TREE_TYPE (array))) == FUNCTION_TYPE) 1970169689Skan { 1971169689Skan error ("subscripted value is pointer to function"); 1972169689Skan return error_mark_node; 1973169689Skan } 1974169689Skan 1975169689Skan /* ??? Existing practice has been to warn only when the char 1976169689Skan index is syntactically the index, not for char[array]. */ 1977169689Skan if (!swapped) 1978169689Skan warn_array_subscript_with_type_char (index); 1979169689Skan 1980169689Skan /* Apply default promotions *after* noticing character types. */ 1981169689Skan index = default_conversion (index); 1982169689Skan 1983169689Skan gcc_assert (TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE); 1984169689Skan 1985169689Skan if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE) 1986169689Skan { 1987169689Skan tree rval, type; 1988169689Skan 198918334Speter /* An array that is indexed by a non-constant 199018334Speter cannot be stored in a register; we must be able to do 199118334Speter address arithmetic on its address. 199218334Speter Likewise an array of elements of variable size. */ 199318334Speter if (TREE_CODE (index) != INTEGER_CST 199490075Sobrien || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array))) 199518334Speter && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST)) 199618334Speter { 1997117395Skan if (!c_mark_addressable (array)) 199818334Speter return error_mark_node; 199918334Speter } 200018334Speter /* An array that is indexed by a constant value which is not within 200118334Speter the array bounds cannot be stored in a register either; because we 200218334Speter would get a crash in store_bit_field/extract_bit_field when trying 200318334Speter to access a non-existent part of the register. */ 200418334Speter if (TREE_CODE (index) == INTEGER_CST 2005169689Skan && TYPE_DOMAIN (TREE_TYPE (array)) 2006169689Skan && !int_fits_type_p (index, TYPE_DOMAIN (TREE_TYPE (array)))) 200718334Speter { 2008117395Skan if (!c_mark_addressable (array)) 200918334Speter return error_mark_node; 201018334Speter } 201118334Speter 201218334Speter if (pedantic) 201318334Speter { 201418334Speter tree foo = array; 201518334Speter while (TREE_CODE (foo) == COMPONENT_REF) 201618334Speter foo = TREE_OPERAND (foo, 0); 2017169689Skan if (TREE_CODE (foo) == VAR_DECL && C_DECL_REGISTER (foo)) 2018169689Skan pedwarn ("ISO C forbids subscripting %<register%> array"); 2019169689Skan else if (!flag_isoc99 && !lvalue_p (foo)) 2020117395Skan pedwarn ("ISO C90 forbids subscripting non-lvalue array"); 202118334Speter } 202218334Speter 2023169689Skan type = TREE_TYPE (TREE_TYPE (array)); 2024169689Skan if (TREE_CODE (type) != ARRAY_TYPE) 2025169689Skan type = TYPE_MAIN_VARIANT (type); 2026169689Skan rval = build4 (ARRAY_REF, type, array, index, NULL_TREE, NULL_TREE); 202718334Speter /* Array ref is const/volatile if the array elements are 2028169689Skan or if the array is. */ 202918334Speter TREE_READONLY (rval) 203018334Speter |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array))) 203118334Speter | TREE_READONLY (array)); 203218334Speter TREE_SIDE_EFFECTS (rval) 203318334Speter |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array))) 203418334Speter | TREE_SIDE_EFFECTS (array)); 203518334Speter TREE_THIS_VOLATILE (rval) 203618334Speter |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array))) 203718334Speter /* This was added by rms on 16 Nov 91. 2038132718Skan It fixes vol struct foo *a; a->elts[1] 203918334Speter in an inline function. 204018334Speter Hope it doesn't break something else. */ 204118334Speter | TREE_THIS_VOLATILE (array)); 204218334Speter return require_complete_type (fold (rval)); 204318334Speter } 2044169689Skan else 2045169689Skan { 2046169689Skan tree ar = default_conversion (array); 204718334Speter 2048169689Skan if (ar == error_mark_node) 2049169689Skan return ar; 205018334Speter 2051169689Skan gcc_assert (TREE_CODE (TREE_TYPE (ar)) == POINTER_TYPE); 2052169689Skan gcc_assert (TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) != FUNCTION_TYPE); 205350397Sobrien 2054169689Skan return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, index, 0), 2055169689Skan "array indexing"); 2056169689Skan } 205718334Speter} 205818334Speter 205990075Sobrien/* Build an external reference to identifier ID. FUN indicates 2060169689Skan whether this will be used for a function call. LOC is the source 2061169689Skan location of the identifier. */ 206290075Sobrientree 2063169689Skanbuild_external_ref (tree id, int fun, location_t loc) 206490075Sobrien{ 206590075Sobrien tree ref; 206690075Sobrien tree decl = lookup_name (id); 206790075Sobrien 2068169689Skan /* In Objective-C, an instance variable (ivar) may be preferred to 2069169689Skan whatever lookup_name() found. */ 2070169689Skan decl = objc_lookup_ivar (decl, id); 2071169689Skan 2072132718Skan if (decl && decl != error_mark_node) 2073169689Skan ref = decl; 2074132718Skan else if (fun) 2075132718Skan /* Implicit function declaration. */ 2076132718Skan ref = implicitly_declare (id); 2077132718Skan else if (decl == error_mark_node) 2078132718Skan /* Don't complain about something that's already been 2079132718Skan complained about. */ 2080132718Skan return error_mark_node; 2081132718Skan else 2082132718Skan { 2083169689Skan undeclared_variable (id, loc); 2084132718Skan return error_mark_node; 2085132718Skan } 208690075Sobrien 208790075Sobrien if (TREE_TYPE (ref) == error_mark_node) 208890075Sobrien return error_mark_node; 208990075Sobrien 2090132718Skan if (TREE_DEPRECATED (ref)) 2091132718Skan warn_deprecated_use (ref); 2092132718Skan 2093103445Skan if (!skip_evaluation) 2094103445Skan assemble_external (ref); 209590075Sobrien TREE_USED (ref) = 1; 209690075Sobrien 2097169689Skan if (TREE_CODE (ref) == FUNCTION_DECL && !in_alignof) 2098169689Skan { 2099169689Skan if (!in_sizeof && !in_typeof) 2100169689Skan C_DECL_USED (ref) = 1; 2101169689Skan else if (DECL_INITIAL (ref) == 0 2102169689Skan && DECL_EXTERNAL (ref) 2103169689Skan && !TREE_PUBLIC (ref)) 2104169689Skan record_maybe_used_decl (ref); 2105169689Skan } 2106169689Skan 210790075Sobrien if (TREE_CODE (ref) == CONST_DECL) 210890075Sobrien { 2109169689Skan used_types_insert (TREE_TYPE (ref)); 211090075Sobrien ref = DECL_INITIAL (ref); 211190075Sobrien TREE_CONSTANT (ref) = 1; 2112169689Skan TREE_INVARIANT (ref) = 1; 211390075Sobrien } 2114117395Skan else if (current_function_decl != 0 2115132718Skan && !DECL_FILE_SCOPE_P (current_function_decl) 2116117395Skan && (TREE_CODE (ref) == VAR_DECL 2117117395Skan || TREE_CODE (ref) == PARM_DECL 2118117395Skan || TREE_CODE (ref) == FUNCTION_DECL)) 2119117395Skan { 2120117395Skan tree context = decl_function_context (ref); 2121132718Skan 2122117395Skan if (context != 0 && context != current_function_decl) 2123117395Skan DECL_NONLOCAL (ref) = 1; 2124117395Skan } 2125189824Sdas /* C99 6.7.4p3: An inline definition of a function with external 2126189824Sdas linkage ... shall not contain a reference to an identifier with 2127189824Sdas internal linkage. */ 2128189824Sdas else if (current_function_decl != 0 2129189824Sdas && DECL_DECLARED_INLINE_P (current_function_decl) 2130189824Sdas && DECL_EXTERNAL (current_function_decl) 2131189824Sdas && VAR_OR_FUNCTION_DECL_P (ref) 2132189824Sdas && DECL_FILE_SCOPE_P (ref) 2133189824Sdas && pedantic 2134189824Sdas && (TREE_CODE (ref) != VAR_DECL || TREE_STATIC (ref)) 2135189824Sdas && ! TREE_PUBLIC (ref)) 2136189824Sdas pedwarn ("%H%qD is static but used in inline function %qD " 2137189824Sdas "which is not static", &loc, ref, current_function_decl); 213890075Sobrien 213990075Sobrien return ref; 214090075Sobrien} 214190075Sobrien 2142169689Skan/* Record details of decls possibly used inside sizeof or typeof. */ 2143169689Skanstruct maybe_used_decl 2144169689Skan{ 2145169689Skan /* The decl. */ 2146169689Skan tree decl; 2147169689Skan /* The level seen at (in_sizeof + in_typeof). */ 2148169689Skan int level; 2149169689Skan /* The next one at this level or above, or NULL. */ 2150169689Skan struct maybe_used_decl *next; 2151169689Skan}; 2152169689Skan 2153169689Skanstatic struct maybe_used_decl *maybe_used_decls; 2154169689Skan 2155169689Skan/* Record that DECL, an undefined static function reference seen 2156169689Skan inside sizeof or typeof, might be used if the operand of sizeof is 2157169689Skan a VLA type or the operand of typeof is a variably modified 2158169689Skan type. */ 2159169689Skan 2160169689Skanstatic void 2161169689Skanrecord_maybe_used_decl (tree decl) 2162169689Skan{ 2163169689Skan struct maybe_used_decl *t = XOBNEW (&parser_obstack, struct maybe_used_decl); 2164169689Skan t->decl = decl; 2165169689Skan t->level = in_sizeof + in_typeof; 2166169689Skan t->next = maybe_used_decls; 2167169689Skan maybe_used_decls = t; 2168169689Skan} 2169169689Skan 2170169689Skan/* Pop the stack of decls possibly used inside sizeof or typeof. If 2171169689Skan USED is false, just discard them. If it is true, mark them used 2172169689Skan (if no longer inside sizeof or typeof) or move them to the next 2173169689Skan level up (if still inside sizeof or typeof). */ 2174169689Skan 2175169689Skanvoid 2176169689Skanpop_maybe_used (bool used) 2177169689Skan{ 2178169689Skan struct maybe_used_decl *p = maybe_used_decls; 2179169689Skan int cur_level = in_sizeof + in_typeof; 2180169689Skan while (p && p->level > cur_level) 2181169689Skan { 2182169689Skan if (used) 2183169689Skan { 2184169689Skan if (cur_level == 0) 2185169689Skan C_DECL_USED (p->decl) = 1; 2186169689Skan else 2187169689Skan p->level = cur_level; 2188169689Skan } 2189169689Skan p = p->next; 2190169689Skan } 2191169689Skan if (!used || cur_level == 0) 2192169689Skan maybe_used_decls = p; 2193169689Skan} 2194169689Skan 2195169689Skan/* Return the result of sizeof applied to EXPR. */ 2196169689Skan 2197169689Skanstruct c_expr 2198169689Skanc_expr_sizeof_expr (struct c_expr expr) 2199169689Skan{ 2200169689Skan struct c_expr ret; 2201169689Skan if (expr.value == error_mark_node) 2202169689Skan { 2203169689Skan ret.value = error_mark_node; 2204169689Skan ret.original_code = ERROR_MARK; 2205169689Skan pop_maybe_used (false); 2206169689Skan } 2207169689Skan else 2208169689Skan { 2209169689Skan ret.value = c_sizeof (TREE_TYPE (expr.value)); 2210169689Skan ret.original_code = ERROR_MARK; 2211169689Skan if (c_vla_type_p (TREE_TYPE (expr.value))) 2212169689Skan { 2213169689Skan /* sizeof is evaluated when given a vla (C99 6.5.3.4p2). */ 2214169689Skan ret.value = build2 (COMPOUND_EXPR, TREE_TYPE (ret.value), expr.value, ret.value); 2215169689Skan } 2216169689Skan pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (expr.value))); 2217169689Skan } 2218169689Skan return ret; 2219169689Skan} 2220169689Skan 2221169689Skan/* Return the result of sizeof applied to T, a structure for the type 2222169689Skan name passed to sizeof (rather than the type itself). */ 2223169689Skan 2224169689Skanstruct c_expr 2225169689Skanc_expr_sizeof_type (struct c_type_name *t) 2226169689Skan{ 2227169689Skan tree type; 2228169689Skan struct c_expr ret; 2229169689Skan type = groktypename (t); 2230169689Skan ret.value = c_sizeof (type); 2231169689Skan ret.original_code = ERROR_MARK; 2232169689Skan pop_maybe_used (type != error_mark_node 2233169689Skan ? C_TYPE_VARIABLE_SIZE (type) : false); 2234169689Skan return ret; 2235169689Skan} 2236169689Skan 223718334Speter/* Build a function call to function FUNCTION with parameters PARAMS. 223818334Speter PARAMS is a list--a chain of TREE_LIST nodes--in which the 223918334Speter TREE_VALUE of each node is a parameter-expression. 224018334Speter FUNCTION's data type may be a function type or a pointer-to-function. */ 224118334Speter 224218334Spetertree 2243132718Skanbuild_function_call (tree function, tree params) 224418334Speter{ 224590075Sobrien tree fntype, fundecl = 0; 224690075Sobrien tree coerced_params; 2247132718Skan tree name = NULL_TREE, result; 2248132718Skan tree tem; 224918334Speter 225018334Speter /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */ 225118334Speter STRIP_TYPE_NOPS (function); 225218334Speter 225318334Speter /* Convert anything with function type to a pointer-to-function. */ 225418334Speter if (TREE_CODE (function) == FUNCTION_DECL) 225518334Speter { 2256169689Skan /* Implement type-directed function overloading for builtins. 2257169689Skan resolve_overloaded_builtin and targetm.resolve_overloaded_builtin 2258169689Skan handle all the type checking. The result is a complete expression 2259169689Skan that implements this function call. */ 2260169689Skan tem = resolve_overloaded_builtin (function, params); 2261169689Skan if (tem) 2262169689Skan return tem; 2263169689Skan 226418334Speter name = DECL_NAME (function); 226518334Speter fundecl = function; 226618334Speter } 2267169689Skan if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE) 2268169689Skan function = function_to_pointer_conversion (function); 226918334Speter 2270169689Skan /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF 2271169689Skan expressions, like those used for ObjC messenger dispatches. */ 2272169689Skan function = objc_rewrite_function_call (function, params); 2273169689Skan 227418334Speter fntype = TREE_TYPE (function); 227518334Speter 227618334Speter if (TREE_CODE (fntype) == ERROR_MARK) 227718334Speter return error_mark_node; 227818334Speter 227918334Speter if (!(TREE_CODE (fntype) == POINTER_TYPE 228018334Speter && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE)) 228118334Speter { 2282169689Skan error ("called object %qE is not a function", function); 228318334Speter return error_mark_node; 228418334Speter } 228518334Speter 228696263Sobrien if (fundecl && TREE_THIS_VOLATILE (fundecl)) 228796263Sobrien current_function_returns_abnormally = 1; 228896263Sobrien 228918334Speter /* fntype now gets the type of function pointed to. */ 229018334Speter fntype = TREE_TYPE (fntype); 229118334Speter 2292132718Skan /* Check that the function is called through a compatible prototype. 2293132718Skan If it is not, replace the call by a trap, wrapped up in a compound 2294132718Skan expression if necessary. This has the nice side-effect to prevent 2295132718Skan the tree-inliner from generating invalid assignment trees which may 2296169689Skan blow up in the RTL expander later. */ 2297169689Skan if ((TREE_CODE (function) == NOP_EXPR 2298169689Skan || TREE_CODE (function) == CONVERT_EXPR) 2299132718Skan && TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR 2300132718Skan && TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL 2301169689Skan && !comptypes (fntype, TREE_TYPE (tem))) 2302132718Skan { 2303132718Skan tree return_type = TREE_TYPE (fntype); 2304132718Skan tree trap = build_function_call (built_in_decls[BUILT_IN_TRAP], 2305132718Skan NULL_TREE); 2306132718Skan 2307132718Skan /* This situation leads to run-time undefined behavior. We can't, 2308132718Skan therefore, simply error unless we can prove that all possible 2309132718Skan executions of the program must execute the code. */ 2310169689Skan warning (0, "function called through a non-compatible type"); 2311132718Skan 2312132718Skan /* We can, however, treat "undefined" any way we please. 2313132718Skan Call abort to encourage the user to fix the program. */ 2314132718Skan inform ("if this code is reached, the program will abort"); 2315132718Skan 2316132718Skan if (VOID_TYPE_P (return_type)) 2317132718Skan return trap; 2318132718Skan else 2319132718Skan { 2320132718Skan tree rhs; 2321132718Skan 2322132718Skan if (AGGREGATE_TYPE_P (return_type)) 2323132718Skan rhs = build_compound_literal (return_type, 2324169689Skan build_constructor (return_type, 0)); 2325132718Skan else 2326169689Skan rhs = fold_convert (return_type, integer_zero_node); 2327132718Skan 2328169689Skan return build2 (COMPOUND_EXPR, return_type, trap, rhs); 2329132718Skan } 2330132718Skan } 2331132718Skan 233218334Speter /* Convert the parameters to the types declared in the 233318334Speter function prototype, or apply default promotions. */ 233418334Speter 233518334Speter coerced_params 2336169689Skan = convert_arguments (TYPE_ARG_TYPES (fntype), params, function, fundecl); 233718334Speter 2338169689Skan if (coerced_params == error_mark_node) 2339169689Skan return error_mark_node; 2340169689Skan 2341117395Skan /* Check that the arguments to the function are valid. */ 234218334Speter 2343169689Skan check_function_arguments (TYPE_ATTRIBUTES (fntype), coerced_params, 2344169689Skan TYPE_ARG_TYPES (fntype)); 234518334Speter 2346132718Skan if (require_constant_value) 2347132718Skan { 2348169689Skan result = fold_build3_initializer (CALL_EXPR, TREE_TYPE (fntype), 2349169689Skan function, coerced_params, NULL_TREE); 2350132718Skan 2351132718Skan if (TREE_CONSTANT (result) 2352132718Skan && (name == NULL_TREE 2353132718Skan || strncmp (IDENTIFIER_POINTER (name), "__builtin_", 10) != 0)) 2354132718Skan pedwarn_init ("initializer element is not constant"); 2355132718Skan } 2356132718Skan else 2357169689Skan result = fold_build3 (CALL_EXPR, TREE_TYPE (fntype), 2358169689Skan function, coerced_params, NULL_TREE); 2359132718Skan 236090075Sobrien if (VOID_TYPE_P (TREE_TYPE (result))) 236190075Sobrien return result; 236290075Sobrien return require_complete_type (result); 236318334Speter} 236418334Speter 236518334Speter/* Convert the argument expressions in the list VALUES 236618334Speter to the types in the list TYPELIST. The result is a list of converted 2367169689Skan argument expressions, unless there are too few arguments in which 2368169689Skan case it is error_mark_node. 236918334Speter 237018334Speter If TYPELIST is exhausted, or when an element has NULL as its type, 237118334Speter perform the default conversions. 237218334Speter 237318334Speter PARMLIST is the chain of parm decls for the function being called. 237418334Speter It may be 0, if that info is not available. 237518334Speter It is used only for generating error messages. 237618334Speter 2377169689Skan FUNCTION is a tree for the called function. It is used only for 2378169689Skan error messages, where it is formatted with %qE. 237918334Speter 238018334Speter This is also where warnings about wrong number of args are generated. 238118334Speter 238218334Speter Both VALUES and the returned value are chains of TREE_LIST nodes 238318334Speter with the elements of the list in the TREE_VALUE slots of those nodes. */ 238418334Speter 238518334Speterstatic tree 2386169689Skanconvert_arguments (tree typelist, tree values, tree function, tree fundecl) 238718334Speter{ 238890075Sobrien tree typetail, valtail; 238990075Sobrien tree result = NULL; 239018334Speter int parmnum; 2391169689Skan tree selector; 239218334Speter 2393169689Skan /* Change pointer to function to the function itself for 2394169689Skan diagnostics. */ 2395169689Skan if (TREE_CODE (function) == ADDR_EXPR 2396169689Skan && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL) 2397169689Skan function = TREE_OPERAND (function, 0); 2398169689Skan 2399169689Skan /* Handle an ObjC selector specially for diagnostics. */ 2400169689Skan selector = objc_message_selector (); 2401169689Skan 240218334Speter /* Scan the given expressions and types, producing individual 240318334Speter converted arguments and pushing them on RESULT in reverse order. */ 240418334Speter 240518334Speter for (valtail = values, typetail = typelist, parmnum = 0; 240618334Speter valtail; 240718334Speter valtail = TREE_CHAIN (valtail), parmnum++) 240818334Speter { 240990075Sobrien tree type = typetail ? TREE_VALUE (typetail) : 0; 241090075Sobrien tree val = TREE_VALUE (valtail); 2411169689Skan tree rname = function; 2412169689Skan int argnum = parmnum + 1; 2413169689Skan const char *invalid_func_diag; 241418334Speter 241518334Speter if (type == void_type_node) 241618334Speter { 2417169689Skan error ("too many arguments to function %qE", function); 241818334Speter break; 241918334Speter } 242018334Speter 2421169689Skan if (selector && argnum > 2) 2422169689Skan { 2423169689Skan rname = selector; 2424169689Skan argnum -= 2; 2425169689Skan } 242618334Speter 2427169689Skan STRIP_TYPE_NOPS (val); 242818334Speter 242918334Speter val = require_complete_type (val); 243018334Speter 243118334Speter if (type != 0) 243218334Speter { 243318334Speter /* Formal parm type is specified by a function prototype. */ 243418334Speter tree parmval; 243518334Speter 2436169689Skan if (type == error_mark_node || !COMPLETE_TYPE_P (type)) 243718334Speter { 243818334Speter error ("type of formal parameter %d is incomplete", parmnum + 1); 243918334Speter parmval = val; 244018334Speter } 244118334Speter else 244218334Speter { 244318334Speter /* Optionally warn about conversions that 244418334Speter differ from the default conversions. */ 244590075Sobrien if (warn_conversion || warn_traditional) 244618334Speter { 2447169689Skan unsigned int formal_prec = TYPE_PRECISION (type); 244818334Speter 244918334Speter if (INTEGRAL_TYPE_P (type) 245018334Speter && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) 2451169689Skan warning (0, "passing argument %d of %qE as integer " 2452169689Skan "rather than floating due to prototype", 2453169689Skan argnum, rname); 245490075Sobrien if (INTEGRAL_TYPE_P (type) 245590075Sobrien && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE) 2456169689Skan warning (0, "passing argument %d of %qE as integer " 2457169689Skan "rather than complex due to prototype", 2458169689Skan argnum, rname); 245918334Speter else if (TREE_CODE (type) == COMPLEX_TYPE 246018334Speter && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) 2461169689Skan warning (0, "passing argument %d of %qE as complex " 2462169689Skan "rather than floating due to prototype", 2463169689Skan argnum, rname); 246418334Speter else if (TREE_CODE (type) == REAL_TYPE 246518334Speter && INTEGRAL_TYPE_P (TREE_TYPE (val))) 2466169689Skan warning (0, "passing argument %d of %qE as floating " 2467169689Skan "rather than integer due to prototype", 2468169689Skan argnum, rname); 246990075Sobrien else if (TREE_CODE (type) == COMPLEX_TYPE 247090075Sobrien && INTEGRAL_TYPE_P (TREE_TYPE (val))) 2471169689Skan warning (0, "passing argument %d of %qE as complex " 2472169689Skan "rather than integer due to prototype", 2473169689Skan argnum, rname); 247418334Speter else if (TREE_CODE (type) == REAL_TYPE 247518334Speter && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE) 2476169689Skan warning (0, "passing argument %d of %qE as floating " 2477169689Skan "rather than complex due to prototype", 2478169689Skan argnum, rname); 247918334Speter /* ??? At some point, messages should be written about 248018334Speter conversions between complex types, but that's too messy 248118334Speter to do now. */ 248218334Speter else if (TREE_CODE (type) == REAL_TYPE 248318334Speter && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) 248418334Speter { 248518334Speter /* Warn if any argument is passed as `float', 248618334Speter since without a prototype it would be `double'. */ 2487169689Skan if (formal_prec == TYPE_PRECISION (float_type_node) 2488169689Skan && type != dfloat32_type_node) 2489169689Skan warning (0, "passing argument %d of %qE as %<float%> " 2490169689Skan "rather than %<double%> due to prototype", 2491169689Skan argnum, rname); 2492169689Skan 2493169689Skan /* Warn if mismatch between argument and prototype 2494169689Skan for decimal float types. Warn of conversions with 2495169689Skan binary float types and of precision narrowing due to 2496169689Skan prototype. */ 2497169689Skan else if (type != TREE_TYPE (val) 2498169689Skan && (type == dfloat32_type_node 2499169689Skan || type == dfloat64_type_node 2500169689Skan || type == dfloat128_type_node 2501169689Skan || TREE_TYPE (val) == dfloat32_type_node 2502169689Skan || TREE_TYPE (val) == dfloat64_type_node 2503169689Skan || TREE_TYPE (val) == dfloat128_type_node) 2504169689Skan && (formal_prec 2505169689Skan <= TYPE_PRECISION (TREE_TYPE (val)) 2506169689Skan || (type == dfloat128_type_node 2507169689Skan && (TREE_TYPE (val) 2508169689Skan != dfloat64_type_node 2509169689Skan && (TREE_TYPE (val) 2510169689Skan != dfloat32_type_node))) 2511169689Skan || (type == dfloat64_type_node 2512169689Skan && (TREE_TYPE (val) 2513169689Skan != dfloat32_type_node)))) 2514169689Skan warning (0, "passing argument %d of %qE as %qT " 2515169689Skan "rather than %qT due to prototype", 2516169689Skan argnum, rname, type, TREE_TYPE (val)); 2517169689Skan 251818334Speter } 251990075Sobrien /* Detect integer changing in width or signedness. 252090075Sobrien These warnings are only activated with 252190075Sobrien -Wconversion, not with -Wtraditional. */ 252290075Sobrien else if (warn_conversion && INTEGRAL_TYPE_P (type) 252318334Speter && INTEGRAL_TYPE_P (TREE_TYPE (val))) 252418334Speter { 252518334Speter tree would_have_been = default_conversion (val); 252618334Speter tree type1 = TREE_TYPE (would_have_been); 252718334Speter 252818334Speter if (TREE_CODE (type) == ENUMERAL_TYPE 252990075Sobrien && (TYPE_MAIN_VARIANT (type) 253090075Sobrien == TYPE_MAIN_VARIANT (TREE_TYPE (val)))) 253118334Speter /* No warning if function asks for enum 253218334Speter and the actual arg is that enum type. */ 253318334Speter ; 253418334Speter else if (formal_prec != TYPE_PRECISION (type1)) 2535169689Skan warning (OPT_Wconversion, "passing argument %d of %qE " 2536169689Skan "with different width due to prototype", 2537169689Skan argnum, rname); 2538169689Skan else if (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (type1)) 253918334Speter ; 254018334Speter /* Don't complain if the formal parameter type 254118334Speter is an enum, because we can't tell now whether 254218334Speter the value was an enum--even the same enum. */ 254318334Speter else if (TREE_CODE (type) == ENUMERAL_TYPE) 254418334Speter ; 254518334Speter else if (TREE_CODE (val) == INTEGER_CST 254618334Speter && int_fits_type_p (val, type)) 254718334Speter /* Change in signedness doesn't matter 254818334Speter if a constant value is unaffected. */ 254918334Speter ; 255018334Speter /* If the value is extended from a narrower 255118334Speter unsigned type, it doesn't matter whether we 255218334Speter pass it as signed or unsigned; the value 255318334Speter certainly is the same either way. */ 255418334Speter else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type) 2555169689Skan && TYPE_UNSIGNED (TREE_TYPE (val))) 255618334Speter ; 2557169689Skan else if (TYPE_UNSIGNED (type)) 2558169689Skan warning (OPT_Wconversion, "passing argument %d of %qE " 2559169689Skan "as unsigned due to prototype", 2560169689Skan argnum, rname); 256118334Speter else 2562169689Skan warning (OPT_Wconversion, "passing argument %d of %qE " 2563169689Skan "as signed due to prototype", argnum, rname); 256418334Speter } 256518334Speter } 256618334Speter 2567169689Skan parmval = convert_for_assignment (type, val, ic_argpass, 2568169689Skan fundecl, function, 2569169689Skan parmnum + 1); 2570132718Skan 2571132718Skan if (targetm.calls.promote_prototypes (fundecl ? TREE_TYPE (fundecl) : 0) 257290075Sobrien && INTEGRAL_TYPE_P (type) 257318334Speter && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))) 257418334Speter parmval = default_conversion (parmval); 257518334Speter } 257618334Speter result = tree_cons (NULL_TREE, parmval, result); 257718334Speter } 257818334Speter else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE 2579169689Skan && (TYPE_PRECISION (TREE_TYPE (val)) 2580169689Skan < TYPE_PRECISION (double_type_node)) 2581169689Skan && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (val)))) 258218334Speter /* Convert `float' to `double'. */ 258318334Speter result = tree_cons (NULL_TREE, convert (double_type_node, val), result); 2584169689Skan else if ((invalid_func_diag = 2585169689Skan targetm.calls.invalid_arg_for_unprototyped_fn (typelist, fundecl, val))) 2586169689Skan { 2587169689Skan error (invalid_func_diag); 2588169689Skan return error_mark_node; 2589169689Skan } 259018334Speter else 259118334Speter /* Convert `short' and `char' to full-size `int'. */ 259218334Speter result = tree_cons (NULL_TREE, default_conversion (val), result); 259318334Speter 259418334Speter if (typetail) 259518334Speter typetail = TREE_CHAIN (typetail); 259618334Speter } 259718334Speter 259818334Speter if (typetail != 0 && TREE_VALUE (typetail) != void_type_node) 259918334Speter { 2600169689Skan error ("too few arguments to function %qE", function); 2601169689Skan return error_mark_node; 260218334Speter } 260318334Speter 260418334Speter return nreverse (result); 260518334Speter} 260618334Speter 2607169689Skan/* This is the entry point used by the parser to build unary operators 2608169689Skan in the input. CODE, a tree_code, specifies the unary operator, and 2609169689Skan ARG is the operand. For unary plus, the C parser currently uses 2610169689Skan CONVERT_EXPR for code. */ 261118334Speter 2612169689Skanstruct c_expr 2613169689Skanparser_build_unary_op (enum tree_code code, struct c_expr arg) 261418334Speter{ 2615169689Skan struct c_expr result; 261618334Speter 2617169689Skan result.original_code = ERROR_MARK; 2618169689Skan result.value = build_unary_op (code, arg.value, 0); 2619259585Spfg 2620259585Spfg if (TREE_OVERFLOW_P (result.value) && !TREE_OVERFLOW_P (arg.value)) 2621259585Spfg overflow_warning (result.value); 2622259585Spfg 2623169689Skan return result; 2624169689Skan} 262518334Speter 2626169689Skan/* This is the entry point used by the parser to build binary operators 2627169689Skan in the input. CODE, a tree_code, specifies the binary operator, and 2628169689Skan ARG1 and ARG2 are the operands. In addition to constructing the 2629169689Skan expression, we check for operands that were written with other binary 2630169689Skan operators in a way that is likely to confuse the user. */ 263190075Sobrien 2632169689Skanstruct c_expr 2633169689Skanparser_build_binary_op (enum tree_code code, struct c_expr arg1, 2634169689Skan struct c_expr arg2) 2635169689Skan{ 2636169689Skan struct c_expr result; 263718334Speter 2638169689Skan enum tree_code code1 = arg1.original_code; 2639169689Skan enum tree_code code2 = arg2.original_code; 2640169689Skan 2641169689Skan result.value = build_binary_op (code, arg1.value, arg2.value, 1); 2642169689Skan result.original_code = code; 2643169689Skan 2644169689Skan if (TREE_CODE (result.value) == ERROR_MARK) 2645169689Skan return result; 2646169689Skan 264718334Speter /* Check for cases such as x+y<<z which users are likely 2648169689Skan to misinterpret. */ 264918334Speter if (warn_parentheses) 2650259269Spfg warn_about_parentheses (code, code1, code2); 265118334Speter 2652169689Skan /* Warn about comparisons against string literals, with the exception 2653169689Skan of testing for equality or inequality of a string literal with NULL. */ 2654169689Skan if (code == EQ_EXPR || code == NE_EXPR) 265518334Speter { 2656169689Skan if ((code1 == STRING_CST && !integer_zerop (arg2.value)) 2657169689Skan || (code2 == STRING_CST && !integer_zerop (arg1.value))) 2658169689Skan warning (OPT_Waddress, 2659169689Skan "comparison with string literal results in unspecified behaviour"); 266018334Speter } 2661169689Skan else if (TREE_CODE_CLASS (code) == tcc_comparison 2662169689Skan && (code1 == STRING_CST || code2 == STRING_CST)) 2663169689Skan warning (OPT_Waddress, 2664169689Skan "comparison with string literal results in unspecified behaviour"); 266518334Speter 2666259585Spfg if (TREE_OVERFLOW_P (result.value) 2667259585Spfg && !TREE_OVERFLOW_P (arg1.value) 2668259585Spfg && !TREE_OVERFLOW_P (arg2.value)) 2669259585Spfg overflow_warning (result.value); 2670169689Skan 267118334Speter return result; 267218334Speter} 267318334Speter 267418334Speter/* Return a tree for the difference of pointers OP0 and OP1. 267518334Speter The resulting tree has type int. */ 267618334Speter 267718334Speterstatic tree 2678132718Skanpointer_diff (tree op0, tree op1) 267918334Speter{ 268018334Speter tree restype = ptrdiff_type_node; 268118334Speter 268218334Speter tree target_type = TREE_TYPE (TREE_TYPE (op0)); 268390075Sobrien tree con0, con1, lit0, lit1; 268490075Sobrien tree orig_op1 = op1; 268518334Speter 268618334Speter if (pedantic || warn_pointer_arith) 268718334Speter { 268818334Speter if (TREE_CODE (target_type) == VOID_TYPE) 2689169689Skan pedwarn ("pointer of type %<void *%> used in subtraction"); 269018334Speter if (TREE_CODE (target_type) == FUNCTION_TYPE) 269118334Speter pedwarn ("pointer to a function used in subtraction"); 269218334Speter } 269318334Speter 269490075Sobrien /* If the conversion to ptrdiff_type does anything like widening or 269590075Sobrien converting a partial to an integral mode, we get a convert_expression 269690075Sobrien that is in the way to do any simplifications. 269790075Sobrien (fold-const.c doesn't know that the extra bits won't be needed. 269890075Sobrien split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a 269990075Sobrien different mode in place.) 270090075Sobrien So first try to find a common term here 'by hand'; we want to cover 270190075Sobrien at least the cases that occur in legal static initializers. */ 2702169689Skan if ((TREE_CODE (op0) == NOP_EXPR || TREE_CODE (op0) == CONVERT_EXPR) 2703169689Skan && (TYPE_PRECISION (TREE_TYPE (op0)) 2704169689Skan == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0))))) 2705169689Skan con0 = TREE_OPERAND (op0, 0); 2706169689Skan else 2707169689Skan con0 = op0; 2708169689Skan if ((TREE_CODE (op1) == NOP_EXPR || TREE_CODE (op1) == CONVERT_EXPR) 2709169689Skan && (TYPE_PRECISION (TREE_TYPE (op1)) 2710169689Skan == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0))))) 2711169689Skan con1 = TREE_OPERAND (op1, 0); 2712169689Skan else 2713169689Skan con1 = op1; 271490075Sobrien 271590075Sobrien if (TREE_CODE (con0) == PLUS_EXPR) 271690075Sobrien { 271790075Sobrien lit0 = TREE_OPERAND (con0, 1); 271890075Sobrien con0 = TREE_OPERAND (con0, 0); 271990075Sobrien } 272090075Sobrien else 272190075Sobrien lit0 = integer_zero_node; 272290075Sobrien 272390075Sobrien if (TREE_CODE (con1) == PLUS_EXPR) 272490075Sobrien { 272590075Sobrien lit1 = TREE_OPERAND (con1, 1); 272690075Sobrien con1 = TREE_OPERAND (con1, 0); 272790075Sobrien } 272890075Sobrien else 272990075Sobrien lit1 = integer_zero_node; 273090075Sobrien 273190075Sobrien if (operand_equal_p (con0, con1, 0)) 273290075Sobrien { 273390075Sobrien op0 = lit0; 273490075Sobrien op1 = lit1; 273590075Sobrien } 273690075Sobrien 273790075Sobrien 273818334Speter /* First do the subtraction as integers; 273950397Sobrien then drop through to build the divide operator. 274050397Sobrien Do not do default conversions on the minus operator 274150397Sobrien in case restype is a short type. */ 274218334Speter 274318334Speter op0 = build_binary_op (MINUS_EXPR, convert (restype, op0), 274450397Sobrien convert (restype, op1), 0); 274518334Speter /* This generates an error if op1 is pointer to incomplete type. */ 274690075Sobrien if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1)))) 274718334Speter error ("arithmetic on pointer to an incomplete type"); 274818334Speter 274918334Speter /* This generates an error if op0 is pointer to incomplete type. */ 275018334Speter op1 = c_size_in_bytes (target_type); 275118334Speter 275218334Speter /* Divide by the size, in easiest possible way. */ 2753169689Skan return fold_build2 (EXACT_DIV_EXPR, restype, op0, convert (restype, op1)); 275418334Speter} 275518334Speter 275618334Speter/* Construct and perhaps optimize a tree representation 275718334Speter for a unary operation. CODE, a tree_code, specifies the operation 275890075Sobrien and XARG is the operand. 275990075Sobrien For any CODE other than ADDR_EXPR, FLAG nonzero suppresses 276090075Sobrien the default promotions (such as from short to int). 276190075Sobrien For ADDR_EXPR, the default promotions are not applied; FLAG nonzero 276290075Sobrien allows non-lvalues; this is only used to handle conversion of non-lvalue 276390075Sobrien arrays to pointers in C99. */ 276418334Speter 276518334Spetertree 2766132718Skanbuild_unary_op (enum tree_code code, tree xarg, int flag) 276718334Speter{ 276818334Speter /* No default_conversion here. It causes trouble for ADDR_EXPR. */ 276990075Sobrien tree arg = xarg; 277090075Sobrien tree argtype = 0; 277190075Sobrien enum tree_code typecode = TREE_CODE (TREE_TYPE (arg)); 277218334Speter tree val; 277390075Sobrien int noconvert = flag; 2774169689Skan const char *invalid_op_diag; 277518334Speter 277618334Speter if (typecode == ERROR_MARK) 277718334Speter return error_mark_node; 277890075Sobrien if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE) 277918334Speter typecode = INTEGER_TYPE; 278018334Speter 2781169689Skan if ((invalid_op_diag 2782169689Skan = targetm.invalid_unary_op (code, TREE_TYPE (xarg)))) 2783169689Skan { 2784169689Skan error (invalid_op_diag); 2785169689Skan return error_mark_node; 2786169689Skan } 2787169689Skan 278818334Speter switch (code) 278918334Speter { 279018334Speter case CONVERT_EXPR: 279118334Speter /* This is used for unary plus, because a CONVERT_EXPR 279218334Speter is enough to prevent anybody from looking inside for 279318334Speter associativity, but won't generate any code. */ 279418334Speter if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE 2795169689Skan || typecode == COMPLEX_TYPE 2796169689Skan || typecode == VECTOR_TYPE)) 279752284Sobrien { 279852284Sobrien error ("wrong type argument to unary plus"); 279952284Sobrien return error_mark_node; 280052284Sobrien } 280118334Speter else if (!noconvert) 280218334Speter arg = default_conversion (arg); 2803117395Skan arg = non_lvalue (arg); 280418334Speter break; 280518334Speter 280618334Speter case NEGATE_EXPR: 280718334Speter if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE 2808117395Skan || typecode == COMPLEX_TYPE 2809117395Skan || typecode == VECTOR_TYPE)) 281052284Sobrien { 281152284Sobrien error ("wrong type argument to unary minus"); 281252284Sobrien return error_mark_node; 281352284Sobrien } 281418334Speter else if (!noconvert) 281518334Speter arg = default_conversion (arg); 281618334Speter break; 281718334Speter 281818334Speter case BIT_NOT_EXPR: 2819117395Skan if (typecode == INTEGER_TYPE || typecode == VECTOR_TYPE) 282018334Speter { 2821117395Skan if (!noconvert) 2822117395Skan arg = default_conversion (arg); 2823117395Skan } 2824117395Skan else if (typecode == COMPLEX_TYPE) 2825117395Skan { 282618334Speter code = CONJ_EXPR; 282790075Sobrien if (pedantic) 2828169689Skan pedwarn ("ISO C does not support %<~%> for complex conjugation"); 282918334Speter if (!noconvert) 283018334Speter arg = default_conversion (arg); 283118334Speter } 2832117395Skan else 283352284Sobrien { 283452284Sobrien error ("wrong type argument to bit-complement"); 283552284Sobrien return error_mark_node; 283652284Sobrien } 283718334Speter break; 283818334Speter 283918334Speter case ABS_EXPR: 2840132718Skan if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE)) 284152284Sobrien { 284252284Sobrien error ("wrong type argument to abs"); 284352284Sobrien return error_mark_node; 284452284Sobrien } 284518334Speter else if (!noconvert) 284618334Speter arg = default_conversion (arg); 284718334Speter break; 284818334Speter 284918334Speter case CONJ_EXPR: 285018334Speter /* Conjugating a real value is a no-op, but allow it anyway. */ 285118334Speter if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE 285218334Speter || typecode == COMPLEX_TYPE)) 285352284Sobrien { 285452284Sobrien error ("wrong type argument to conjugation"); 285552284Sobrien return error_mark_node; 285652284Sobrien } 285718334Speter else if (!noconvert) 285818334Speter arg = default_conversion (arg); 285918334Speter break; 286018334Speter 286118334Speter case TRUTH_NOT_EXPR: 286218334Speter if (typecode != INTEGER_TYPE 286318334Speter && typecode != REAL_TYPE && typecode != POINTER_TYPE 2864169689Skan && typecode != COMPLEX_TYPE) 286518334Speter { 286652284Sobrien error ("wrong type argument to unary exclamation mark"); 286752284Sobrien return error_mark_node; 286818334Speter } 2869169689Skan arg = c_objc_common_truthvalue_conversion (arg); 287018334Speter return invert_truthvalue (arg); 287118334Speter 287218334Speter case REALPART_EXPR: 287318334Speter if (TREE_CODE (arg) == COMPLEX_CST) 287418334Speter return TREE_REALPART (arg); 287518334Speter else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE) 2876169689Skan return fold_build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg); 287718334Speter else 287818334Speter return arg; 287918334Speter 288018334Speter case IMAGPART_EXPR: 288118334Speter if (TREE_CODE (arg) == COMPLEX_CST) 288218334Speter return TREE_IMAGPART (arg); 288318334Speter else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE) 2884169689Skan return fold_build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg); 288518334Speter else 288618334Speter return convert (TREE_TYPE (arg), integer_zero_node); 2887132718Skan 288818334Speter case PREINCREMENT_EXPR: 288918334Speter case POSTINCREMENT_EXPR: 289018334Speter case PREDECREMENT_EXPR: 289118334Speter case POSTDECREMENT_EXPR: 289218334Speter 289318334Speter /* Increment or decrement the real part of the value, 289418334Speter and don't change the imaginary part. */ 289518334Speter if (typecode == COMPLEX_TYPE) 289618334Speter { 289718334Speter tree real, imag; 289818334Speter 289990075Sobrien if (pedantic) 2900169689Skan pedwarn ("ISO C does not support %<++%> and %<--%>" 2901169689Skan " on complex types"); 290290075Sobrien 290318334Speter arg = stabilize_reference (arg); 290418334Speter real = build_unary_op (REALPART_EXPR, arg, 1); 290518334Speter imag = build_unary_op (IMAGPART_EXPR, arg, 1); 2906169689Skan return build2 (COMPLEX_EXPR, TREE_TYPE (arg), 2907169689Skan build_unary_op (code, real, 1), imag); 290818334Speter } 290918334Speter 291018334Speter /* Report invalid types. */ 291118334Speter 291218334Speter if (typecode != POINTER_TYPE 291318334Speter && typecode != INTEGER_TYPE && typecode != REAL_TYPE) 291418334Speter { 291590075Sobrien if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) 2916169689Skan error ("wrong type argument to increment"); 2917169689Skan else 2918169689Skan error ("wrong type argument to decrement"); 291990075Sobrien 292052284Sobrien return error_mark_node; 292118334Speter } 292218334Speter 292318334Speter { 292490075Sobrien tree inc; 292518334Speter tree result_type = TREE_TYPE (arg); 292618334Speter 2927117395Skan arg = get_unwidened (arg, 0); 2928117395Skan argtype = TREE_TYPE (arg); 2929117395Skan 293018334Speter /* Compute the increment. */ 293118334Speter 293218334Speter if (typecode == POINTER_TYPE) 293318334Speter { 293418334Speter /* If pointer target is an undefined struct, 293518334Speter we just cannot know how to do the arithmetic. */ 293690075Sobrien if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type))) 293790075Sobrien { 293890075Sobrien if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) 293990075Sobrien error ("increment of pointer to unknown structure"); 294090075Sobrien else 294190075Sobrien error ("decrement of pointer to unknown structure"); 294290075Sobrien } 294318334Speter else if ((pedantic || warn_pointer_arith) 294418334Speter && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE 294518334Speter || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)) 2946169689Skan { 294790075Sobrien if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) 294890075Sobrien pedwarn ("wrong type argument to increment"); 294990075Sobrien else 295090075Sobrien pedwarn ("wrong type argument to decrement"); 295190075Sobrien } 295290075Sobrien 295318334Speter inc = c_size_in_bytes (TREE_TYPE (result_type)); 295418334Speter } 295518334Speter else 295618334Speter inc = integer_one_node; 295718334Speter 295818334Speter inc = convert (argtype, inc); 295918334Speter 296018334Speter /* Complain about anything else that is not a true lvalue. */ 296118334Speter if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR 296218334Speter || code == POSTINCREMENT_EXPR) 2963169689Skan ? lv_increment 2964169689Skan : lv_decrement))) 296518334Speter return error_mark_node; 296618334Speter 296718334Speter /* Report a read-only lvalue. */ 296818334Speter if (TREE_READONLY (arg)) 2969169689Skan { 2970169689Skan readonly_error (arg, 2971169689Skan ((code == PREINCREMENT_EXPR 2972169689Skan || code == POSTINCREMENT_EXPR) 2973169689Skan ? lv_increment : lv_decrement)); 2974169689Skan return error_mark_node; 2975169689Skan } 297618334Speter 297790075Sobrien if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE) 297890075Sobrien val = boolean_increment (code, arg); 297990075Sobrien else 2980169689Skan val = build2 (code, TREE_TYPE (arg), arg, inc); 298118334Speter TREE_SIDE_EFFECTS (val) = 1; 298218334Speter val = convert (result_type, val); 298318334Speter if (TREE_CODE (val) != code) 2984169689Skan TREE_NO_WARNING (val) = 1; 298518334Speter return val; 298618334Speter } 298718334Speter 298818334Speter case ADDR_EXPR: 298990075Sobrien /* Note that this operation never does default_conversion. */ 299018334Speter 299118334Speter /* Let &* cancel out to simplify resulting code. */ 299218334Speter if (TREE_CODE (arg) == INDIRECT_REF) 299318334Speter { 299418334Speter /* Don't let this be an lvalue. */ 299518334Speter if (lvalue_p (TREE_OPERAND (arg, 0))) 299618334Speter return non_lvalue (TREE_OPERAND (arg, 0)); 299718334Speter return TREE_OPERAND (arg, 0); 299818334Speter } 299918334Speter 300018334Speter /* For &x[y], return x+y */ 300118334Speter if (TREE_CODE (arg) == ARRAY_REF) 300218334Speter { 3003169689Skan tree op0 = TREE_OPERAND (arg, 0); 3004169689Skan if (!c_mark_addressable (op0)) 300518334Speter return error_mark_node; 3006169689Skan return build_binary_op (PLUS_EXPR, 3007169689Skan (TREE_CODE (TREE_TYPE (op0)) == ARRAY_TYPE 3008169689Skan ? array_to_pointer_conversion (op0) 3009169689Skan : op0), 301018334Speter TREE_OPERAND (arg, 1), 1); 301118334Speter } 301218334Speter 301318334Speter /* Anything not already handled and not a true memory reference 301490075Sobrien or a non-lvalue array is an error. */ 301590075Sobrien else if (typecode != FUNCTION_TYPE && !flag 3016169689Skan && !lvalue_or_else (arg, lv_addressof)) 301718334Speter return error_mark_node; 301818334Speter 301918334Speter /* Ordinary case; arg is a COMPONENT_REF or a decl. */ 302018334Speter argtype = TREE_TYPE (arg); 302190075Sobrien 302252284Sobrien /* If the lvalue is const or volatile, merge that into the type 3023169689Skan to which the address will point. Note that you can't get a 302452284Sobrien restricted pointer by taking the address of something, so we 302552284Sobrien only have to deal with `const' and `volatile' here. */ 3026169689Skan if ((DECL_P (arg) || REFERENCE_CLASS_P (arg)) 302790075Sobrien && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg))) 302890075Sobrien argtype = c_build_type_variant (argtype, 302990075Sobrien TREE_READONLY (arg), 303090075Sobrien TREE_THIS_VOLATILE (arg)); 303118334Speter 3032117395Skan if (!c_mark_addressable (arg)) 303318334Speter return error_mark_node; 303418334Speter 3035169689Skan gcc_assert (TREE_CODE (arg) != COMPONENT_REF 3036169689Skan || !DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1))); 303718334Speter 3038169689Skan argtype = build_pointer_type (argtype); 303918334Speter 3040169689Skan /* ??? Cope with user tricks that amount to offsetof. Delete this 3041169689Skan when we have proper support for integer constant expressions. */ 3042169689Skan val = get_base_address (arg); 3043169689Skan if (val && TREE_CODE (val) == INDIRECT_REF 3044169689Skan && TREE_CONSTANT (TREE_OPERAND (val, 0))) 3045169689Skan { 3046169689Skan tree op0 = fold_convert (argtype, fold_offsetof (arg, val)), op1; 304718334Speter 3048169689Skan op1 = fold_convert (argtype, TREE_OPERAND (val, 0)); 3049169689Skan return fold_build2 (PLUS_EXPR, argtype, op0, op1); 3050169689Skan } 305118334Speter 3052169689Skan val = build1 (ADDR_EXPR, argtype, arg); 305318334Speter 3054169689Skan return val; 305550397Sobrien 305650397Sobrien default: 3057169689Skan gcc_unreachable (); 305818334Speter } 305918334Speter 306052284Sobrien if (argtype == 0) 306152284Sobrien argtype = TREE_TYPE (arg); 3062169689Skan return require_constant_value ? fold_build1_initializer (code, argtype, arg) 3063169689Skan : fold_build1 (code, argtype, arg); 306418334Speter} 306518334Speter 306618334Speter/* Return nonzero if REF is an lvalue valid for this language. 306718334Speter Lvalues can be assigned, unless their type has TYPE_READONLY. 3068169689Skan Lvalues can have their address taken, unless they have C_DECL_REGISTER. */ 306918334Speter 3070169689Skanstatic int 3071132718Skanlvalue_p (tree ref) 307218334Speter{ 307390075Sobrien enum tree_code code = TREE_CODE (ref); 307418334Speter 307518334Speter switch (code) 307618334Speter { 307718334Speter case REALPART_EXPR: 307818334Speter case IMAGPART_EXPR: 307918334Speter case COMPONENT_REF: 308018334Speter return lvalue_p (TREE_OPERAND (ref, 0)); 308118334Speter 308290075Sobrien case COMPOUND_LITERAL_EXPR: 308318334Speter case STRING_CST: 308418334Speter return 1; 308518334Speter 308618334Speter case INDIRECT_REF: 308718334Speter case ARRAY_REF: 308818334Speter case VAR_DECL: 308918334Speter case PARM_DECL: 309018334Speter case RESULT_DECL: 309118334Speter case ERROR_MARK: 309250397Sobrien return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE 309350397Sobrien && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE); 309450397Sobrien 309550397Sobrien case BIND_EXPR: 309650397Sobrien return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE; 309750397Sobrien 309850397Sobrien default: 309950397Sobrien return 0; 310018334Speter } 310118334Speter} 3102169689Skan 3103169689Skan/* Give an error for storing in something that is 'const'. */ 310418334Speter 310518334Speterstatic void 3106169689Skanreadonly_error (tree arg, enum lvalue_use use) 310718334Speter{ 3108169689Skan gcc_assert (use == lv_assign || use == lv_increment || use == lv_decrement 3109169689Skan || use == lv_asm); 3110169689Skan /* Using this macro rather than (for example) arrays of messages 3111169689Skan ensures that all the format strings are checked at compile 3112169689Skan time. */ 3113169689Skan#define READONLY_MSG(A, I, D, AS) (use == lv_assign ? (A) \ 3114169689Skan : (use == lv_increment ? (I) \ 3115169689Skan : (use == lv_decrement ? (D) : (AS)))) 311618334Speter if (TREE_CODE (arg) == COMPONENT_REF) 311718334Speter { 311818334Speter if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0)))) 3119169689Skan readonly_error (TREE_OPERAND (arg, 0), use); 312018334Speter else 3121169689Skan error (READONLY_MSG (G_("assignment of read-only member %qD"), 3122169689Skan G_("increment of read-only member %qD"), 3123169689Skan G_("decrement of read-only member %qD"), 3124169689Skan G_("read-only member %qD used as %<asm%> output")), 3125169689Skan TREE_OPERAND (arg, 1)); 312618334Speter } 312718334Speter else if (TREE_CODE (arg) == VAR_DECL) 3128169689Skan error (READONLY_MSG (G_("assignment of read-only variable %qD"), 3129169689Skan G_("increment of read-only variable %qD"), 3130169689Skan G_("decrement of read-only variable %qD"), 3131169689Skan G_("read-only variable %qD used as %<asm%> output")), 3132169689Skan arg); 313318334Speter else 3134169689Skan error (READONLY_MSG (G_("assignment of read-only location"), 3135169689Skan G_("increment of read-only location"), 3136169689Skan G_("decrement of read-only location"), 3137169689Skan G_("read-only location used as %<asm%> output"))); 313818334Speter} 3139169689Skan 3140169689Skan 3141169689Skan/* Return nonzero if REF is an lvalue valid for this language; 3142169689Skan otherwise, print an error message and return zero. USE says 3143169689Skan how the lvalue is being used and so selects the error message. */ 3144169689Skan 3145169689Skanstatic int 3146169689Skanlvalue_or_else (tree ref, enum lvalue_use use) 3147169689Skan{ 3148169689Skan int win = lvalue_p (ref); 3149169689Skan 3150169689Skan if (!win) 3151169689Skan lvalue_error (use); 3152169689Skan 3153169689Skan return win; 3154169689Skan} 315518334Speter 315618334Speter/* Mark EXP saying that we need to be able to take the 315718334Speter address of it; it should not be allocated in a register. 3158117395Skan Returns true if successful. */ 315918334Speter 3160117395Skanbool 3161132718Skanc_mark_addressable (tree exp) 316218334Speter{ 316390075Sobrien tree x = exp; 3164117395Skan 316518334Speter while (1) 316618334Speter switch (TREE_CODE (x)) 316718334Speter { 316850397Sobrien case COMPONENT_REF: 316950397Sobrien if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1))) 317050397Sobrien { 3171169689Skan error 3172169689Skan ("cannot take address of bit-field %qD", TREE_OPERAND (x, 1)); 3173117395Skan return false; 317450397Sobrien } 317550397Sobrien 317650397Sobrien /* ... fall through ... */ 317750397Sobrien 317818334Speter case ADDR_EXPR: 317918334Speter case ARRAY_REF: 318018334Speter case REALPART_EXPR: 318118334Speter case IMAGPART_EXPR: 318218334Speter x = TREE_OPERAND (x, 0); 318318334Speter break; 318418334Speter 318590075Sobrien case COMPOUND_LITERAL_EXPR: 318618334Speter case CONSTRUCTOR: 318718334Speter TREE_ADDRESSABLE (x) = 1; 3188117395Skan return true; 318918334Speter 319018334Speter case VAR_DECL: 319118334Speter case CONST_DECL: 319218334Speter case PARM_DECL: 319318334Speter case RESULT_DECL: 3194169689Skan if (C_DECL_REGISTER (x) 319518334Speter && DECL_NONLOCAL (x)) 319618334Speter { 3197132718Skan if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x)) 319818334Speter { 3199169689Skan error 3200169689Skan ("global register variable %qD used in nested function", x); 3201117395Skan return false; 320218334Speter } 3203169689Skan pedwarn ("register variable %qD used in nested function", x); 320418334Speter } 3205169689Skan else if (C_DECL_REGISTER (x)) 320618334Speter { 3207132718Skan if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x)) 3208169689Skan error ("address of global register variable %qD requested", x); 3209169689Skan else 3210169689Skan error ("address of register variable %qD requested", x); 3211169689Skan return false; 321218334Speter } 321318334Speter 321418334Speter /* drops in */ 321518334Speter case FUNCTION_DECL: 321618334Speter TREE_ADDRESSABLE (x) = 1; 3217132718Skan /* drops out */ 321818334Speter default: 3219117395Skan return true; 322018334Speter } 322118334Speter} 322218334Speter 322318334Speter/* Build and return a conditional expression IFEXP ? OP1 : OP2. */ 322418334Speter 322518334Spetertree 3226132718Skanbuild_conditional_expr (tree ifexp, tree op1, tree op2) 322718334Speter{ 322890075Sobrien tree type1; 322990075Sobrien tree type2; 323090075Sobrien enum tree_code code1; 323190075Sobrien enum tree_code code2; 323290075Sobrien tree result_type = NULL; 323318334Speter tree orig_op1 = op1, orig_op2 = op2; 323418334Speter 323518334Speter /* Promote both alternatives. */ 323618334Speter 323718334Speter if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE) 323818334Speter op1 = default_conversion (op1); 323918334Speter if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE) 324018334Speter op2 = default_conversion (op2); 324118334Speter 324218334Speter if (TREE_CODE (ifexp) == ERROR_MARK 324318334Speter || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK 324418334Speter || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK) 324518334Speter return error_mark_node; 324618334Speter 324718334Speter type1 = TREE_TYPE (op1); 324818334Speter code1 = TREE_CODE (type1); 324918334Speter type2 = TREE_TYPE (op2); 325018334Speter code2 = TREE_CODE (type2); 3251132718Skan 3252169689Skan /* C90 does not permit non-lvalue arrays in conditional expressions. 3253169689Skan In C99 they will be pointers by now. */ 3254169689Skan if (code1 == ARRAY_TYPE || code2 == ARRAY_TYPE) 3255169689Skan { 3256169689Skan error ("non-lvalue array in conditional expression"); 3257169689Skan return error_mark_node; 3258169689Skan } 3259169689Skan 326018334Speter /* Quickly detect the usual case where op1 and op2 have the same type 326118334Speter after promotion. */ 326218334Speter if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2)) 326318334Speter { 326418334Speter if (type1 == type2) 326518334Speter result_type = type1; 326618334Speter else 326718334Speter result_type = TYPE_MAIN_VARIANT (type1); 326818334Speter } 326990075Sobrien else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE 3270169689Skan || code1 == COMPLEX_TYPE) 3271169689Skan && (code2 == INTEGER_TYPE || code2 == REAL_TYPE 3272169689Skan || code2 == COMPLEX_TYPE)) 327318334Speter { 3274169689Skan result_type = c_common_type (type1, type2); 327590075Sobrien 327690075Sobrien /* If -Wsign-compare, warn here if type1 and type2 have 327790075Sobrien different signedness. We'll promote the signed to unsigned 327890075Sobrien and later code won't know it used to be different. 327990075Sobrien Do this check on the original types, so that explicit casts 328090075Sobrien will be considered, but default promotions won't. */ 3281132718Skan if (warn_sign_compare && !skip_evaluation) 328290075Sobrien { 3283169689Skan int unsigned_op1 = TYPE_UNSIGNED (TREE_TYPE (orig_op1)); 3284169689Skan int unsigned_op2 = TYPE_UNSIGNED (TREE_TYPE (orig_op2)); 328590075Sobrien 328690075Sobrien if (unsigned_op1 ^ unsigned_op2) 328790075Sobrien { 3288169689Skan bool ovf; 3289169689Skan 329090075Sobrien /* Do not warn if the result type is signed, since the 329190075Sobrien signed type will only be chosen if it can represent 329290075Sobrien all the values of the unsigned type. */ 3293169689Skan if (!TYPE_UNSIGNED (result_type)) 329490075Sobrien /* OK */; 329590075Sobrien /* Do not warn if the signed quantity is an unsuffixed 329690075Sobrien integer literal (or some static constant expression 329790075Sobrien involving such literals) and it is non-negative. */ 3298169689Skan else if ((unsigned_op2 3299169689Skan && tree_expr_nonnegative_warnv_p (op1, &ovf)) 3300169689Skan || (unsigned_op1 3301169689Skan && tree_expr_nonnegative_warnv_p (op2, &ovf))) 330290075Sobrien /* OK */; 330390075Sobrien else 3304169689Skan warning (0, "signed and unsigned type in conditional expression"); 330590075Sobrien } 330690075Sobrien } 330718334Speter } 330818334Speter else if (code1 == VOID_TYPE || code2 == VOID_TYPE) 330918334Speter { 331018334Speter if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE)) 331190075Sobrien pedwarn ("ISO C forbids conditional expr with only one void side"); 331218334Speter result_type = void_type_node; 331318334Speter } 331418334Speter else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE) 331518334Speter { 3316169689Skan if (comp_target_types (type1, type2)) 3317169689Skan result_type = common_pointer_type (type1, type2); 3318169689Skan else if (null_pointer_constant_p (orig_op1)) 331918334Speter result_type = qualify_type (type2, type1); 3320169689Skan else if (null_pointer_constant_p (orig_op2)) 332118334Speter result_type = qualify_type (type1, type2); 332290075Sobrien else if (VOID_TYPE_P (TREE_TYPE (type1))) 332318334Speter { 332418334Speter if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE) 3325169689Skan pedwarn ("ISO C forbids conditional expr between " 3326169689Skan "%<void *%> and function pointer"); 332790075Sobrien result_type = build_pointer_type (qualify_type (TREE_TYPE (type1), 332890075Sobrien TREE_TYPE (type2))); 332918334Speter } 333090075Sobrien else if (VOID_TYPE_P (TREE_TYPE (type2))) 333118334Speter { 333218334Speter if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE) 3333169689Skan pedwarn ("ISO C forbids conditional expr between " 3334169689Skan "%<void *%> and function pointer"); 333590075Sobrien result_type = build_pointer_type (qualify_type (TREE_TYPE (type2), 333690075Sobrien TREE_TYPE (type1))); 333718334Speter } 333818334Speter else 333918334Speter { 334018334Speter pedwarn ("pointer type mismatch in conditional expression"); 334118334Speter result_type = build_pointer_type (void_type_node); 334218334Speter } 334318334Speter } 334418334Speter else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE) 334518334Speter { 3346169689Skan if (!null_pointer_constant_p (orig_op2)) 334718334Speter pedwarn ("pointer/integer type mismatch in conditional expression"); 334818334Speter else 334918334Speter { 335018334Speter op2 = null_pointer_node; 335118334Speter } 335218334Speter result_type = type1; 335318334Speter } 335418334Speter else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE) 335518334Speter { 3356169689Skan if (!null_pointer_constant_p (orig_op1)) 335718334Speter pedwarn ("pointer/integer type mismatch in conditional expression"); 335818334Speter else 335918334Speter { 336018334Speter op1 = null_pointer_node; 336118334Speter } 336218334Speter result_type = type2; 336318334Speter } 336418334Speter 336518334Speter if (!result_type) 336618334Speter { 336718334Speter if (flag_cond_mismatch) 336818334Speter result_type = void_type_node; 336918334Speter else 337018334Speter { 337118334Speter error ("type mismatch in conditional expression"); 337218334Speter return error_mark_node; 337318334Speter } 337418334Speter } 337518334Speter 337618334Speter /* Merge const and volatile flags of the incoming types. */ 337718334Speter result_type 337818334Speter = build_type_variant (result_type, 337918334Speter TREE_READONLY (op1) || TREE_READONLY (op2), 338018334Speter TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2)); 338118334Speter 338218334Speter if (result_type != TREE_TYPE (op1)) 338318334Speter op1 = convert_and_check (result_type, op1); 338418334Speter if (result_type != TREE_TYPE (op2)) 338518334Speter op2 = convert_and_check (result_type, op2); 3386132718Skan 3387169689Skan return fold_build3 (COND_EXPR, result_type, ifexp, op1, op2); 338818334Speter} 338918334Speter 3390169689Skan/* Return a compound expression that performs two expressions and 3391169689Skan returns the value of the second of them. */ 339218334Speter 339318334Spetertree 3394169689Skanbuild_compound_expr (tree expr1, tree expr2) 339518334Speter{ 3396169689Skan if (!TREE_SIDE_EFFECTS (expr1)) 339718334Speter { 339818334Speter /* The left-hand operand of a comma expression is like an expression 3399169689Skan statement: with -Wextra or -Wunused, we should warn if it doesn't have 340018334Speter any side-effects, unless it was explicitly cast to (void). */ 3401169689Skan if (warn_unused_value) 3402169689Skan { 3403169689Skan if (VOID_TYPE_P (TREE_TYPE (expr1)) 3404169689Skan && (TREE_CODE (expr1) == NOP_EXPR 3405169689Skan || TREE_CODE (expr1) == CONVERT_EXPR)) 3406169689Skan ; /* (void) a, b */ 3407169689Skan else if (VOID_TYPE_P (TREE_TYPE (expr1)) 3408169689Skan && TREE_CODE (expr1) == COMPOUND_EXPR 3409169689Skan && (TREE_CODE (TREE_OPERAND (expr1, 1)) == CONVERT_EXPR 3410169689Skan || TREE_CODE (TREE_OPERAND (expr1, 1)) == NOP_EXPR)) 3411169689Skan ; /* (void) a, (void) b, c */ 3412169689Skan else 3413169689Skan warning (0, "left-hand operand of comma expression has no effect"); 3414169689Skan } 341518334Speter } 341618334Speter 341718334Speter /* With -Wunused, we should also warn if the left-hand operand does have 341818334Speter side-effects, but computes a value which is not used. For example, in 341918334Speter `foo() + bar(), baz()' the result of the `+' operator is not used, 342018334Speter so we should issue a warning. */ 342190075Sobrien else if (warn_unused_value) 3422169689Skan warn_if_unused_value (expr1, input_location); 342318334Speter 3424169689Skan if (expr2 == error_mark_node) 3425169689Skan return error_mark_node; 3426169689Skan 3427169689Skan return build2 (COMPOUND_EXPR, TREE_TYPE (expr2), expr1, expr2); 342818334Speter} 342918334Speter 343018334Speter/* Build an expression representing a cast to type TYPE of expression EXPR. */ 343118334Speter 343218334Spetertree 3433132718Skanbuild_c_cast (tree type, tree expr) 343418334Speter{ 343590075Sobrien tree value = expr; 3436132718Skan 343718334Speter if (type == error_mark_node || expr == error_mark_node) 343818334Speter return error_mark_node; 343918334Speter 3440117395Skan /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing 3441117395Skan only in <protocol> qualifications. But when constructing cast expressions, 3442117395Skan the protocols do matter and must be kept around. */ 3443169689Skan if (objc_is_object_ptr (type) && objc_is_object_ptr (TREE_TYPE (expr))) 3444169689Skan return build1 (NOP_EXPR, type, expr); 3445117395Skan 3446169689Skan type = TYPE_MAIN_VARIANT (type); 3447169689Skan 344818334Speter if (TREE_CODE (type) == ARRAY_TYPE) 344918334Speter { 345018334Speter error ("cast specifies array type"); 345118334Speter return error_mark_node; 345218334Speter } 345318334Speter 345418334Speter if (TREE_CODE (type) == FUNCTION_TYPE) 345518334Speter { 345618334Speter error ("cast specifies function type"); 345718334Speter return error_mark_node; 345818334Speter } 345918334Speter 346090075Sobrien if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value))) 346118334Speter { 346218334Speter if (pedantic) 346318334Speter { 346418334Speter if (TREE_CODE (type) == RECORD_TYPE 346518334Speter || TREE_CODE (type) == UNION_TYPE) 346690075Sobrien pedwarn ("ISO C forbids casting nonscalar to the same type"); 346718334Speter } 346818334Speter } 346918334Speter else if (TREE_CODE (type) == UNION_TYPE) 347018334Speter { 347118334Speter tree field; 347218334Speter 347318334Speter for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 347418334Speter if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)), 3475169689Skan TYPE_MAIN_VARIANT (TREE_TYPE (value)))) 347618334Speter break; 347718334Speter 347818334Speter if (field) 347918334Speter { 348018334Speter tree t; 348118334Speter 348218334Speter if (pedantic) 348390075Sobrien pedwarn ("ISO C forbids casts to union type"); 3484132718Skan t = digest_init (type, 3485169689Skan build_constructor_single (type, field, value), 3486169689Skan true, 0); 348718334Speter TREE_CONSTANT (t) = TREE_CONSTANT (value); 3488169689Skan TREE_INVARIANT (t) = TREE_INVARIANT (value); 348918334Speter return t; 349018334Speter } 349118334Speter error ("cast to union type from type not present in union"); 349218334Speter return error_mark_node; 349318334Speter } 349418334Speter else 349518334Speter { 349618334Speter tree otype, ovalue; 349718334Speter 349818334Speter if (type == void_type_node) 349918334Speter return build1 (CONVERT_EXPR, type, value); 350018334Speter 350118334Speter otype = TREE_TYPE (value); 350218334Speter 350318334Speter /* Optionally warn about potentially worrisome casts. */ 350418334Speter 350518334Speter if (warn_cast_qual 350618334Speter && TREE_CODE (type) == POINTER_TYPE 350718334Speter && TREE_CODE (otype) == POINTER_TYPE) 350818334Speter { 350950397Sobrien tree in_type = type; 351050397Sobrien tree in_otype = otype; 351196263Sobrien int added = 0; 351296263Sobrien int discarded = 0; 351350397Sobrien 351490075Sobrien /* Check that the qualifiers on IN_TYPE are a superset of 351590075Sobrien the qualifiers of IN_OTYPE. The outermost level of 351690075Sobrien POINTER_TYPE nodes is uninteresting and we stop as soon 351790075Sobrien as we hit a non-POINTER_TYPE node on either type. */ 351890075Sobrien do 351990075Sobrien { 352090075Sobrien in_otype = TREE_TYPE (in_otype); 352190075Sobrien in_type = TREE_TYPE (in_type); 352296263Sobrien 352396263Sobrien /* GNU C allows cv-qualified function types. 'const' 352496263Sobrien means the function is very pure, 'volatile' means it 352596263Sobrien can't return. We need to warn when such qualifiers 352696263Sobrien are added, not when they're taken away. */ 352796263Sobrien if (TREE_CODE (in_otype) == FUNCTION_TYPE 352896263Sobrien && TREE_CODE (in_type) == FUNCTION_TYPE) 352996263Sobrien added |= (TYPE_QUALS (in_type) & ~TYPE_QUALS (in_otype)); 353096263Sobrien else 353196263Sobrien discarded |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type)); 353290075Sobrien } 353390075Sobrien while (TREE_CODE (in_type) == POINTER_TYPE 353490075Sobrien && TREE_CODE (in_otype) == POINTER_TYPE); 353590075Sobrien 353696263Sobrien if (added) 3537169689Skan warning (0, "cast adds new qualifiers to function type"); 353896263Sobrien 353996263Sobrien if (discarded) 354052284Sobrien /* There are qualifiers present in IN_OTYPE that are not 354152284Sobrien present in IN_TYPE. */ 3542169689Skan warning (0, "cast discards qualifiers from pointer target type"); 354318334Speter } 354418334Speter 354518334Speter /* Warn about possible alignment problems. */ 3546169689Skan if (STRICT_ALIGNMENT 354718334Speter && TREE_CODE (type) == POINTER_TYPE 354818334Speter && TREE_CODE (otype) == POINTER_TYPE 354918334Speter && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE 355018334Speter && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE 355150397Sobrien /* Don't warn about opaque types, where the actual alignment 355250397Sobrien restriction is unknown. */ 355350397Sobrien && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE 355450397Sobrien || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE) 355550397Sobrien && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode) 355618334Speter && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype))) 3557169689Skan warning (OPT_Wcast_align, 3558169689Skan "cast increases required alignment of target type"); 355918334Speter 356018334Speter if (TREE_CODE (type) == INTEGER_TYPE 356118334Speter && TREE_CODE (otype) == POINTER_TYPE 3562169689Skan && TYPE_PRECISION (type) != TYPE_PRECISION (otype)) 3563169689Skan /* Unlike conversion of integers to pointers, where the 3564169689Skan warning is disabled for converting constants because 3565169689Skan of cases such as SIG_*, warn about converting constant 3566169689Skan pointers to integers. In some cases it may cause unwanted 3567169689Skan sign extension, and a warning is appropriate. */ 3568169689Skan warning (OPT_Wpointer_to_int_cast, 3569169689Skan "cast from pointer to integer of different size"); 357018334Speter 3571169689Skan if (TREE_CODE (value) == CALL_EXPR 357218334Speter && TREE_CODE (type) != TREE_CODE (otype)) 3573169689Skan warning (OPT_Wbad_function_cast, "cast from function call of type %qT " 3574169689Skan "to non-matching type %qT", otype, type); 357518334Speter 357618334Speter if (TREE_CODE (type) == POINTER_TYPE 357718334Speter && TREE_CODE (otype) == INTEGER_TYPE 357818334Speter && TYPE_PRECISION (type) != TYPE_PRECISION (otype) 357918334Speter /* Don't warn about converting any constant. */ 358018334Speter && !TREE_CONSTANT (value)) 3581169689Skan warning (OPT_Wint_to_pointer_cast, "cast to pointer from integer " 3582169689Skan "of different size"); 358318334Speter 3584259406Spfg if (warn_strict_aliasing <= 2) 3585259406Spfg strict_aliasing_warning (otype, type, expr); 3586132718Skan 3587132718Skan /* If pedantic, warn for conversions between function and object 3588132718Skan pointer types, except for converting a null pointer constant 3589132718Skan to function pointer type. */ 3590132718Skan if (pedantic 3591132718Skan && TREE_CODE (type) == POINTER_TYPE 3592132718Skan && TREE_CODE (otype) == POINTER_TYPE 3593132718Skan && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE 3594132718Skan && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE) 3595132718Skan pedwarn ("ISO C forbids conversion of function pointer to object pointer type"); 3596132718Skan 3597132718Skan if (pedantic 3598132718Skan && TREE_CODE (type) == POINTER_TYPE 3599132718Skan && TREE_CODE (otype) == POINTER_TYPE 3600132718Skan && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE 3601132718Skan && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE 3602169689Skan && !null_pointer_constant_p (value)) 3603132718Skan pedwarn ("ISO C forbids conversion of object pointer to function pointer type"); 3604132718Skan 360518334Speter ovalue = value; 360618334Speter value = convert (type, value); 360718334Speter 360818334Speter /* Ignore any integer overflow caused by the cast. */ 360918334Speter if (TREE_CODE (value) == INTEGER_CST) 361018334Speter { 3611169689Skan if (CONSTANT_CLASS_P (ovalue) 3612169689Skan && (TREE_OVERFLOW (ovalue) || TREE_CONSTANT_OVERFLOW (ovalue))) 3613169689Skan { 3614169689Skan /* Avoid clobbering a shared constant. */ 3615169689Skan value = copy_node (value); 3616169689Skan TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue); 3617169689Skan TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue); 3618169689Skan } 3619169689Skan else if (TREE_OVERFLOW (value) || TREE_CONSTANT_OVERFLOW (value)) 3620169689Skan /* Reset VALUE's overflow flags, ensuring constant sharing. */ 3621169689Skan value = build_int_cst_wide (TREE_TYPE (value), 3622169689Skan TREE_INT_CST_LOW (value), 3623169689Skan TREE_INT_CST_HIGH (value)); 362418334Speter } 362518334Speter } 362618334Speter 3627169689Skan /* Don't let a cast be an lvalue. */ 3628169689Skan if (value == expr) 362918334Speter value = non_lvalue (value); 363018334Speter 363118334Speter return value; 363218334Speter} 363390075Sobrien 363490075Sobrien/* Interpret a cast of expression EXPR to type TYPE. */ 363590075Sobrientree 3636169689Skanc_cast_expr (struct c_type_name *type_name, tree expr) 363790075Sobrien{ 3638169689Skan tree type; 363990075Sobrien int saved_wsp = warn_strict_prototypes; 364090075Sobrien 364190075Sobrien /* This avoids warnings about unprototyped casts on 364290075Sobrien integers. E.g. "#define SIG_DFL (void(*)())0". */ 364390075Sobrien if (TREE_CODE (expr) == INTEGER_CST) 364490075Sobrien warn_strict_prototypes = 0; 3645169689Skan type = groktypename (type_name); 364690075Sobrien warn_strict_prototypes = saved_wsp; 364790075Sobrien 364890075Sobrien return build_c_cast (type, expr); 364990075Sobrien} 365018334Speter 365118334Speter/* Build an assignment expression of lvalue LHS from value RHS. 365218334Speter MODIFYCODE is the code for a binary operator that we use 365318334Speter to combine the old value of LHS with RHS to get the new value. 365418334Speter Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. */ 365518334Speter 365618334Spetertree 3657132718Skanbuild_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) 365818334Speter{ 365990075Sobrien tree result; 366018334Speter tree newrhs; 366118334Speter tree lhstype = TREE_TYPE (lhs); 366218334Speter tree olhstype = lhstype; 366318334Speter 366418334Speter /* Types that aren't fully specified cannot be used in assignments. */ 366518334Speter lhs = require_complete_type (lhs); 366618334Speter 366718334Speter /* Avoid duplicate error messages from operands that had errors. */ 366818334Speter if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK) 366918334Speter return error_mark_node; 367018334Speter 3671169689Skan if (!lvalue_or_else (lhs, lv_assign)) 3672169689Skan return error_mark_node; 367318334Speter 3674169689Skan STRIP_TYPE_NOPS (rhs); 3675169689Skan 367618334Speter newrhs = rhs; 367718334Speter 367818334Speter /* If a binary op has been requested, combine the old LHS value with the RHS 367918334Speter producing the value we should actually store into the LHS. */ 368018334Speter 368118334Speter if (modifycode != NOP_EXPR) 368218334Speter { 368318334Speter lhs = stabilize_reference (lhs); 368418334Speter newrhs = build_binary_op (modifycode, lhs, rhs, 1); 368518334Speter } 368618334Speter 3687169689Skan /* Give an error for storing in something that is 'const'. */ 368818334Speter 368918334Speter if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype) 369018334Speter || ((TREE_CODE (lhstype) == RECORD_TYPE 369118334Speter || TREE_CODE (lhstype) == UNION_TYPE) 369218334Speter && C_TYPE_FIELDS_READONLY (lhstype))) 3693169689Skan { 3694169689Skan readonly_error (lhs, lv_assign); 3695169689Skan return error_mark_node; 3696169689Skan } 369718334Speter 369818334Speter /* If storing into a structure or union member, 369918334Speter it has probably been given type `int'. 370018334Speter Compute the type that would go with 370118334Speter the actual amount of storage the member occupies. */ 370218334Speter 370318334Speter if (TREE_CODE (lhs) == COMPONENT_REF 370418334Speter && (TREE_CODE (lhstype) == INTEGER_TYPE 370590075Sobrien || TREE_CODE (lhstype) == BOOLEAN_TYPE 370618334Speter || TREE_CODE (lhstype) == REAL_TYPE 370718334Speter || TREE_CODE (lhstype) == ENUMERAL_TYPE)) 370818334Speter lhstype = TREE_TYPE (get_unwidened (lhs, 0)); 370918334Speter 371018334Speter /* If storing in a field that is in actuality a short or narrower than one, 371118334Speter we must store in the field in its actual type. */ 371218334Speter 371318334Speter if (lhstype != TREE_TYPE (lhs)) 371418334Speter { 371518334Speter lhs = copy_node (lhs); 371618334Speter TREE_TYPE (lhs) = lhstype; 371718334Speter } 371818334Speter 371918334Speter /* Convert new value to destination type. */ 372018334Speter 3721169689Skan newrhs = convert_for_assignment (lhstype, newrhs, ic_assign, 372218334Speter NULL_TREE, NULL_TREE, 0); 372318334Speter if (TREE_CODE (newrhs) == ERROR_MARK) 372418334Speter return error_mark_node; 372518334Speter 3726169689Skan /* Emit ObjC write barrier, if necessary. */ 3727169689Skan if (c_dialect_objc () && flag_objc_gc) 3728169689Skan { 3729169689Skan result = objc_generate_write_barrier (lhs, modifycode, newrhs); 3730169689Skan if (result) 3731169689Skan return result; 3732169689Skan } 373390075Sobrien 3734169689Skan /* Scan operands. */ 3735169689Skan 3736169689Skan result = build2 (MODIFY_EXPR, lhstype, lhs, newrhs); 373718334Speter TREE_SIDE_EFFECTS (result) = 1; 373818334Speter 373918334Speter /* If we got the LHS in a different type for storing in, 374018334Speter convert the result back to the nominal type of LHS 374118334Speter so that the value we return always has the same type 374218334Speter as the LHS argument. */ 374318334Speter 374418334Speter if (olhstype == TREE_TYPE (result)) 374518334Speter return result; 3746169689Skan return convert_for_assignment (olhstype, result, ic_assign, 374718334Speter NULL_TREE, NULL_TREE, 0); 374818334Speter} 374918334Speter 375018334Speter/* Convert value RHS to type TYPE as preparation for an assignment 375118334Speter to an lvalue of type TYPE. 375218334Speter The real work of conversion is done by `convert'. 375318334Speter The purpose of this function is to generate error messages 375418334Speter for assignments that are not allowed in C. 3755169689Skan ERRTYPE says whether it is argument passing, assignment, 3756169689Skan initialization or return. 375718334Speter 3758169689Skan FUNCTION is a tree for the function being called. 375918334Speter PARMNUM is the number of the argument, for printing in error messages. */ 376018334Speter 376118334Speterstatic tree 3762169689Skanconvert_for_assignment (tree type, tree rhs, enum impl_conv errtype, 3763169689Skan tree fundecl, tree function, int parmnum) 376418334Speter{ 376590075Sobrien enum tree_code codel = TREE_CODE (type); 376690075Sobrien tree rhstype; 376790075Sobrien enum tree_code coder; 3768169689Skan tree rname = NULL_TREE; 3769169689Skan bool objc_ok = false; 377018334Speter 3771169689Skan if (errtype == ic_argpass || errtype == ic_argpass_nonproto) 3772169689Skan { 3773169689Skan tree selector; 3774169689Skan /* Change pointer to function to the function itself for 3775169689Skan diagnostics. */ 3776169689Skan if (TREE_CODE (function) == ADDR_EXPR 3777169689Skan && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL) 3778169689Skan function = TREE_OPERAND (function, 0); 377918334Speter 3780169689Skan /* Handle an ObjC selector specially for diagnostics. */ 3781169689Skan selector = objc_message_selector (); 3782169689Skan rname = function; 3783169689Skan if (selector && parmnum > 2) 3784169689Skan { 3785169689Skan rname = selector; 3786169689Skan parmnum -= 2; 3787169689Skan } 3788169689Skan } 3789169689Skan 3790169689Skan /* This macro is used to emit diagnostics to ensure that all format 3791169689Skan strings are complete sentences, visible to gettext and checked at 3792169689Skan compile time. */ 3793169689Skan#define WARN_FOR_ASSIGNMENT(AR, AS, IN, RE) \ 3794169689Skan do { \ 3795169689Skan switch (errtype) \ 3796169689Skan { \ 3797169689Skan case ic_argpass: \ 3798169689Skan pedwarn (AR, parmnum, rname); \ 3799169689Skan break; \ 3800169689Skan case ic_argpass_nonproto: \ 3801169689Skan warning (0, AR, parmnum, rname); \ 3802169689Skan break; \ 3803169689Skan case ic_assign: \ 3804169689Skan pedwarn (AS); \ 3805169689Skan break; \ 3806169689Skan case ic_init: \ 3807169689Skan pedwarn (IN); \ 3808169689Skan break; \ 3809169689Skan case ic_return: \ 3810169689Skan pedwarn (RE); \ 3811169689Skan break; \ 3812169689Skan default: \ 3813169689Skan gcc_unreachable (); \ 3814169689Skan } \ 3815169689Skan } while (0) 3816169689Skan 3817169689Skan STRIP_TYPE_NOPS (rhs); 3818169689Skan 3819169689Skan if (optimize && TREE_CODE (rhs) == VAR_DECL 3820169689Skan && TREE_CODE (TREE_TYPE (rhs)) != ARRAY_TYPE) 382190075Sobrien rhs = decl_constant_value_for_broken_optimization (rhs); 382218334Speter 382318334Speter rhstype = TREE_TYPE (rhs); 382418334Speter coder = TREE_CODE (rhstype); 382518334Speter 382618334Speter if (coder == ERROR_MARK) 382718334Speter return error_mark_node; 382818334Speter 3829169689Skan if (c_dialect_objc ()) 3830169689Skan { 3831169689Skan int parmno; 3832169689Skan 3833169689Skan switch (errtype) 3834169689Skan { 3835169689Skan case ic_return: 3836169689Skan parmno = 0; 3837169689Skan break; 3838169689Skan 3839169689Skan case ic_assign: 3840169689Skan parmno = -1; 3841169689Skan break; 3842169689Skan 3843169689Skan case ic_init: 3844169689Skan parmno = -2; 3845169689Skan break; 3846169689Skan 3847169689Skan default: 3848169689Skan parmno = parmnum; 3849169689Skan break; 3850169689Skan } 3851169689Skan 3852169689Skan objc_ok = objc_compare_types (type, rhstype, parmno, rname); 3853169689Skan } 3854169689Skan 385518334Speter if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype)) 3856259585Spfg return rhs; 385718334Speter 385818334Speter if (coder == VOID_TYPE) 385918334Speter { 3860169689Skan /* Except for passing an argument to an unprototyped function, 3861169689Skan this is a constraint violation. When passing an argument to 3862169689Skan an unprototyped function, it is compile-time undefined; 3863169689Skan making it a constraint in that case was rejected in 3864169689Skan DR#252. */ 386518334Speter error ("void value not ignored as it ought to be"); 386618334Speter return error_mark_node; 386718334Speter } 3868132718Skan /* A type converts to a reference to it. 386990075Sobrien This code doesn't fully support references, it's just for the 387090075Sobrien special case of va_start and va_copy. */ 387190075Sobrien if (codel == REFERENCE_TYPE 3872169689Skan && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1) 387390075Sobrien { 3874117395Skan if (!lvalue_p (rhs)) 3875117395Skan { 3876117395Skan error ("cannot pass rvalue to reference parameter"); 3877117395Skan return error_mark_node; 3878117395Skan } 3879117395Skan if (!c_mark_addressable (rhs)) 388090075Sobrien return error_mark_node; 388190075Sobrien rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs); 388290075Sobrien 388390075Sobrien /* We already know that these two types are compatible, but they 388490075Sobrien may not be exactly identical. In fact, `TREE_TYPE (type)' is 388590075Sobrien likely to be __builtin_va_list and `TREE_TYPE (rhs)' is 388690075Sobrien likely to be va_list, a typedef to __builtin_va_list, which 388790075Sobrien is different enough that it will cause problems later. */ 388890075Sobrien if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type)) 388990075Sobrien rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs); 389090075Sobrien 389190075Sobrien rhs = build1 (NOP_EXPR, type, rhs); 389290075Sobrien return rhs; 389390075Sobrien } 3894132718Skan /* Some types can interconvert without explicit casts. */ 3895132718Skan else if (codel == VECTOR_TYPE && coder == VECTOR_TYPE 3896169689Skan && vector_types_convertible_p (type, TREE_TYPE (rhs))) 3897132718Skan return convert (type, rhs); 389818334Speter /* Arithmetic types all interconvert, and enum is treated like int. */ 3899132718Skan else if ((codel == INTEGER_TYPE || codel == REAL_TYPE 390090075Sobrien || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE 390190075Sobrien || codel == BOOLEAN_TYPE) 3902117395Skan && (coder == INTEGER_TYPE || coder == REAL_TYPE 390390075Sobrien || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE 390490075Sobrien || coder == BOOLEAN_TYPE)) 390518334Speter return convert_and_check (type, rhs); 390618334Speter 3907169689Skan /* Aggregates in different TUs might need conversion. */ 3908169689Skan if ((codel == RECORD_TYPE || codel == UNION_TYPE) 3909169689Skan && codel == coder 3910169689Skan && comptypes (type, rhstype)) 3911169689Skan return convert_and_check (type, rhs); 3912169689Skan 391350397Sobrien /* Conversion to a transparent union from its member types. 391450397Sobrien This applies only to function arguments. */ 3915169689Skan if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) 3916169689Skan && (errtype == ic_argpass || errtype == ic_argpass_nonproto)) 391718334Speter { 3918169689Skan tree memb, marginal_memb = NULL_TREE; 391918334Speter 3920169689Skan for (memb = TYPE_FIELDS (type); memb ; memb = TREE_CHAIN (memb)) 392118334Speter { 3922169689Skan tree memb_type = TREE_TYPE (memb); 392318334Speter 392450397Sobrien if (comptypes (TYPE_MAIN_VARIANT (memb_type), 3925169689Skan TYPE_MAIN_VARIANT (rhstype))) 392650397Sobrien break; 392750397Sobrien 392850397Sobrien if (TREE_CODE (memb_type) != POINTER_TYPE) 392950397Sobrien continue; 393050397Sobrien 393150397Sobrien if (coder == POINTER_TYPE) 393218334Speter { 393390075Sobrien tree ttl = TREE_TYPE (memb_type); 393490075Sobrien tree ttr = TREE_TYPE (rhstype); 393518334Speter 393618334Speter /* Any non-function converts to a [const][volatile] void * 393718334Speter and vice versa; otherwise, targets must be the same. 393818334Speter Meanwhile, the lhs target must have all the qualifiers of 393918334Speter the rhs. */ 394090075Sobrien if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr) 3941169689Skan || comp_target_types (memb_type, rhstype)) 394218334Speter { 394350397Sobrien /* If this type won't generate any warnings, use it. */ 394452284Sobrien if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr) 394552284Sobrien || ((TREE_CODE (ttr) == FUNCTION_TYPE 394652284Sobrien && TREE_CODE (ttl) == FUNCTION_TYPE) 394752284Sobrien ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr)) 394852284Sobrien == TYPE_QUALS (ttr)) 394952284Sobrien : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr)) 395052284Sobrien == TYPE_QUALS (ttl)))) 395150397Sobrien break; 395218334Speter 395350397Sobrien /* Keep looking for a better type, but remember this one. */ 3954169689Skan if (!marginal_memb) 3955169689Skan marginal_memb = memb; 395618334Speter } 395718334Speter } 395818334Speter 395918334Speter /* Can convert integer zero to any pointer type. */ 3960169689Skan if (null_pointer_constant_p (rhs)) 396150397Sobrien { 396250397Sobrien rhs = null_pointer_node; 396350397Sobrien break; 396450397Sobrien } 396518334Speter } 396650397Sobrien 3967169689Skan if (memb || marginal_memb) 396850397Sobrien { 3969169689Skan if (!memb) 397050397Sobrien { 397150397Sobrien /* We have only a marginally acceptable member type; 397250397Sobrien it needs a warning. */ 3973169689Skan tree ttl = TREE_TYPE (TREE_TYPE (marginal_memb)); 397490075Sobrien tree ttr = TREE_TYPE (rhstype); 397550397Sobrien 397650397Sobrien /* Const and volatile mean something different for function 397750397Sobrien types, so the usual warnings are not appropriate. */ 397850397Sobrien if (TREE_CODE (ttr) == FUNCTION_TYPE 397950397Sobrien && TREE_CODE (ttl) == FUNCTION_TYPE) 398050397Sobrien { 398150397Sobrien /* Because const and volatile on functions are 398250397Sobrien restrictions that say the function will not do 398350397Sobrien certain things, it is okay to use a const or volatile 398450397Sobrien function where an ordinary one is wanted, but not 398550397Sobrien vice-versa. */ 398652284Sobrien if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr)) 3987169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE " 3988169689Skan "makes qualified function " 3989169689Skan "pointer from unqualified"), 3990169689Skan G_("assignment makes qualified " 3991169689Skan "function pointer from " 3992169689Skan "unqualified"), 3993169689Skan G_("initialization makes qualified " 3994169689Skan "function pointer from " 3995169689Skan "unqualified"), 3996169689Skan G_("return makes qualified function " 3997169689Skan "pointer from unqualified")); 399850397Sobrien } 399952284Sobrien else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl)) 4000169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE discards " 4001169689Skan "qualifiers from pointer target type"), 4002169689Skan G_("assignment discards qualifiers " 4003169689Skan "from pointer target type"), 4004169689Skan G_("initialization discards qualifiers " 4005169689Skan "from pointer target type"), 4006169689Skan G_("return discards qualifiers from " 4007169689Skan "pointer target type")); 4008169689Skan 4009169689Skan memb = marginal_memb; 401050397Sobrien } 4011132718Skan 4012169689Skan if (pedantic && (!fundecl || !DECL_IN_SYSTEM_HEADER (fundecl))) 401390075Sobrien pedwarn ("ISO C prohibits argument conversion to union type"); 401450397Sobrien 4015169689Skan return build_constructor_single (type, memb, rhs); 401650397Sobrien } 401718334Speter } 401818334Speter 401918334Speter /* Conversions among pointers */ 402090075Sobrien else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE) 4021117395Skan && (coder == codel)) 402218334Speter { 402390075Sobrien tree ttl = TREE_TYPE (type); 402490075Sobrien tree ttr = TREE_TYPE (rhstype); 4025169689Skan tree mvl = ttl; 4026169689Skan tree mvr = ttr; 4027132718Skan bool is_opaque_pointer; 4028132718Skan int target_cmp = 0; /* Cache comp_target_types () result. */ 402918334Speter 4030169689Skan if (TREE_CODE (mvl) != ARRAY_TYPE) 4031169689Skan mvl = TYPE_MAIN_VARIANT (mvl); 4032169689Skan if (TREE_CODE (mvr) != ARRAY_TYPE) 4033169689Skan mvr = TYPE_MAIN_VARIANT (mvr); 4034132718Skan /* Opaque pointers are treated like void pointers. */ 4035169689Skan is_opaque_pointer = (targetm.vector_opaque_p (type) 4036169689Skan || targetm.vector_opaque_p (rhstype)) 4037169689Skan && TREE_CODE (ttl) == VECTOR_TYPE 4038169689Skan && TREE_CODE (ttr) == VECTOR_TYPE; 4039132718Skan 4040169689Skan /* C++ does not allow the implicit conversion void* -> T*. However, 4041169689Skan for the purpose of reducing the number of false positives, we 4042169689Skan tolerate the special case of 4043169689Skan 4044169689Skan int *p = NULL; 4045169689Skan 4046169689Skan where NULL is typically defined in C to be '(void *) 0'. */ 4047169689Skan if (VOID_TYPE_P (ttr) && rhs != null_pointer_node && !VOID_TYPE_P (ttl)) 4048169689Skan warning (OPT_Wc___compat, "request for implicit conversion from " 4049169689Skan "%qT to %qT not permitted in C++", rhstype, type); 4050169689Skan 4051169689Skan /* Check if the right-hand side has a format attribute but the 4052169689Skan left-hand side doesn't. */ 4053169689Skan if (warn_missing_format_attribute 4054169689Skan && check_missing_format_attribute (type, rhstype)) 4055169689Skan { 4056169689Skan switch (errtype) 4057169689Skan { 4058169689Skan case ic_argpass: 4059169689Skan case ic_argpass_nonproto: 4060169689Skan warning (OPT_Wmissing_format_attribute, 4061169689Skan "argument %d of %qE might be " 4062169689Skan "a candidate for a format attribute", 4063169689Skan parmnum, rname); 4064169689Skan break; 4065169689Skan case ic_assign: 4066169689Skan warning (OPT_Wmissing_format_attribute, 4067169689Skan "assignment left-hand side might be " 4068169689Skan "a candidate for a format attribute"); 4069169689Skan break; 4070169689Skan case ic_init: 4071169689Skan warning (OPT_Wmissing_format_attribute, 4072169689Skan "initialization left-hand side might be " 4073169689Skan "a candidate for a format attribute"); 4074169689Skan break; 4075169689Skan case ic_return: 4076169689Skan warning (OPT_Wmissing_format_attribute, 4077169689Skan "return type might be " 4078169689Skan "a candidate for a format attribute"); 4079169689Skan break; 4080169689Skan default: 4081169689Skan gcc_unreachable (); 4082169689Skan } 4083169689Skan } 4084169689Skan 408518334Speter /* Any non-function converts to a [const][volatile] void * 408618334Speter and vice versa; otherwise, targets must be the same. 408718334Speter Meanwhile, the lhs target must have all the qualifiers of the rhs. */ 408890075Sobrien if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr) 4089169689Skan || (target_cmp = comp_target_types (type, rhstype)) 4090132718Skan || is_opaque_pointer 4091169689Skan || (c_common_unsigned_type (mvl) 4092169689Skan == c_common_unsigned_type (mvr))) 409318334Speter { 409418334Speter if (pedantic 409590075Sobrien && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE) 409618334Speter || 409790075Sobrien (VOID_TYPE_P (ttr) 4098169689Skan && !null_pointer_constant_p (rhs) 409918334Speter && TREE_CODE (ttl) == FUNCTION_TYPE))) 4100169689Skan WARN_FOR_ASSIGNMENT (G_("ISO C forbids passing argument %d of " 4101169689Skan "%qE between function pointer " 4102169689Skan "and %<void *%>"), 4103169689Skan G_("ISO C forbids assignment between " 4104169689Skan "function pointer and %<void *%>"), 4105169689Skan G_("ISO C forbids initialization between " 4106169689Skan "function pointer and %<void *%>"), 4107169689Skan G_("ISO C forbids return between function " 4108169689Skan "pointer and %<void *%>")); 410918334Speter /* Const and volatile mean something different for function types, 411018334Speter so the usual warnings are not appropriate. */ 411118334Speter else if (TREE_CODE (ttr) != FUNCTION_TYPE 411218334Speter && TREE_CODE (ttl) != FUNCTION_TYPE) 411318334Speter { 411452284Sobrien if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl)) 4115169689Skan { 4116169689Skan /* Types differing only by the presence of the 'volatile' 4117169689Skan qualifier are acceptable if the 'volatile' has been added 4118169689Skan in by the Objective-C EH machinery. */ 4119169689Skan if (!objc_type_quals_match (ttl, ttr)) 4120169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE discards " 4121169689Skan "qualifiers from pointer target type"), 4122169689Skan G_("assignment discards qualifiers " 4123169689Skan "from pointer target type"), 4124169689Skan G_("initialization discards qualifiers " 4125169689Skan "from pointer target type"), 4126169689Skan G_("return discards qualifiers from " 4127169689Skan "pointer target type")); 4128169689Skan } 412918334Speter /* If this is not a case of ignoring a mismatch in signedness, 413018334Speter no warning. */ 413190075Sobrien else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr) 4132132718Skan || target_cmp) 413318334Speter ; 413418334Speter /* If there is a mismatch, do warn. */ 4135169689Skan else if (warn_pointer_sign) 4136169689Skan WARN_FOR_ASSIGNMENT (G_("pointer targets in passing argument " 4137169689Skan "%d of %qE differ in signedness"), 4138169689Skan G_("pointer targets in assignment " 4139169689Skan "differ in signedness"), 4140169689Skan G_("pointer targets in initialization " 4141169689Skan "differ in signedness"), 4142169689Skan G_("pointer targets in return differ " 4143169689Skan "in signedness")); 414418334Speter } 414518334Speter else if (TREE_CODE (ttl) == FUNCTION_TYPE 414618334Speter && TREE_CODE (ttr) == FUNCTION_TYPE) 414718334Speter { 414818334Speter /* Because const and volatile on functions are restrictions 414918334Speter that say the function will not do certain things, 415018334Speter it is okay to use a const or volatile function 415118334Speter where an ordinary one is wanted, but not vice-versa. */ 415252284Sobrien if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr)) 4153169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes " 4154169689Skan "qualified function pointer " 4155169689Skan "from unqualified"), 4156169689Skan G_("assignment makes qualified function " 4157169689Skan "pointer from unqualified"), 4158169689Skan G_("initialization makes qualified " 4159169689Skan "function pointer from unqualified"), 4160169689Skan G_("return makes qualified function " 4161169689Skan "pointer from unqualified")); 416218334Speter } 416318334Speter } 416418334Speter else 4165169689Skan /* Avoid warning about the volatile ObjC EH puts on decls. */ 4166169689Skan if (!objc_ok) 4167169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE from " 4168169689Skan "incompatible pointer type"), 4169169689Skan G_("assignment from incompatible pointer type"), 4170169689Skan G_("initialization from incompatible " 4171169689Skan "pointer type"), 4172169689Skan G_("return from incompatible pointer type")); 4173169689Skan 417418334Speter return convert (type, rhs); 417518334Speter } 4176122180Skan else if (codel == POINTER_TYPE && coder == ARRAY_TYPE) 4177122180Skan { 4178169689Skan /* ??? This should not be an error when inlining calls to 4179169689Skan unprototyped functions. */ 4180122180Skan error ("invalid use of non-lvalue array"); 4181122180Skan return error_mark_node; 4182122180Skan } 418318334Speter else if (codel == POINTER_TYPE && coder == INTEGER_TYPE) 418418334Speter { 418518334Speter /* An explicit constant 0 can convert to a pointer, 418618334Speter or one that results from arithmetic, even including 418718334Speter a cast to integer type. */ 4188169689Skan if (!null_pointer_constant_p (rhs)) 4189169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes " 4190169689Skan "pointer from integer without a cast"), 4191169689Skan G_("assignment makes pointer from integer " 4192169689Skan "without a cast"), 4193169689Skan G_("initialization makes pointer from " 4194169689Skan "integer without a cast"), 4195169689Skan G_("return makes pointer from integer " 4196169689Skan "without a cast")); 4197132718Skan 4198132718Skan return convert (type, rhs); 419918334Speter } 420018334Speter else if (codel == INTEGER_TYPE && coder == POINTER_TYPE) 420118334Speter { 4202169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes integer " 4203169689Skan "from pointer without a cast"), 4204169689Skan G_("assignment makes integer from pointer " 4205169689Skan "without a cast"), 4206169689Skan G_("initialization makes integer from pointer " 4207169689Skan "without a cast"), 4208169689Skan G_("return makes integer from pointer " 4209169689Skan "without a cast")); 421018334Speter return convert (type, rhs); 421118334Speter } 421290075Sobrien else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE) 421390075Sobrien return convert (type, rhs); 421418334Speter 4215169689Skan switch (errtype) 421618334Speter { 4217169689Skan case ic_argpass: 4218169689Skan case ic_argpass_nonproto: 4219169689Skan /* ??? This should not be an error when inlining calls to 4220169689Skan unprototyped functions. */ 4221169689Skan error ("incompatible type for argument %d of %qE", parmnum, rname); 4222169689Skan break; 4223169689Skan case ic_assign: 4224169689Skan error ("incompatible types in assignment"); 4225169689Skan break; 4226169689Skan case ic_init: 4227169689Skan error ("incompatible types in initialization"); 4228169689Skan break; 4229169689Skan case ic_return: 4230169689Skan error ("incompatible types in return"); 4231169689Skan break; 4232169689Skan default: 4233169689Skan gcc_unreachable (); 423418334Speter } 423518334Speter 423618334Speter return error_mark_node; 423718334Speter} 423818334Speter 4239132718Skan/* Convert VALUE for assignment into inlined parameter PARM. ARGNUM 4240169689Skan is used for error and warning reporting and indicates which argument 4241132718Skan is being processed. */ 424296263Sobrien 424396263Sobrientree 4244132718Skanc_convert_parm_for_inlining (tree parm, tree value, tree fn, int argnum) 424596263Sobrien{ 424696263Sobrien tree ret, type; 424796263Sobrien 4248169689Skan /* If FN was prototyped at the call site, the value has been converted 4249169689Skan already in convert_arguments. 4250169689Skan However, we might see a prototype now that was not in place when 4251169689Skan the function call was seen, so check that the VALUE actually matches 4252169689Skan PARM before taking an early exit. */ 4253169689Skan if (!value 4254169689Skan || (TYPE_ARG_TYPES (TREE_TYPE (fn)) 4255169689Skan && (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) 4256169689Skan == TYPE_MAIN_VARIANT (TREE_TYPE (value))))) 425796263Sobrien return value; 425896263Sobrien 425996263Sobrien type = TREE_TYPE (parm); 4260132718Skan ret = convert_for_assignment (type, value, 4261169689Skan ic_argpass_nonproto, fn, 4262169689Skan fn, argnum); 4263132718Skan if (targetm.calls.promote_prototypes (TREE_TYPE (fn)) 426496263Sobrien && INTEGRAL_TYPE_P (type) 426596263Sobrien && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))) 426696263Sobrien ret = default_conversion (ret); 426796263Sobrien return ret; 426896263Sobrien} 426918334Speter 427018334Speter/* If VALUE is a compound expr all of whose expressions are constant, then 427118334Speter return its value. Otherwise, return error_mark_node. 427218334Speter 427318334Speter This is for handling COMPOUND_EXPRs as initializer elements 427418334Speter which is allowed with a warning when -pedantic is specified. */ 427518334Speter 427618334Speterstatic tree 4277132718Skanvalid_compound_expr_initializer (tree value, tree endtype) 427818334Speter{ 427918334Speter if (TREE_CODE (value) == COMPOUND_EXPR) 428018334Speter { 428118334Speter if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype) 428218334Speter == error_mark_node) 428318334Speter return error_mark_node; 428418334Speter return valid_compound_expr_initializer (TREE_OPERAND (value, 1), 428518334Speter endtype); 428618334Speter } 4287169689Skan else if (!initializer_constant_valid_p (value, endtype)) 428818334Speter return error_mark_node; 428918334Speter else 429018334Speter return value; 429118334Speter} 429218334Speter 429318334Speter/* Perform appropriate conversions on the initial value of a variable, 429418334Speter store it in the declaration DECL, 429518334Speter and print any error messages that are appropriate. 429618334Speter If the init is invalid, store an ERROR_MARK. */ 429718334Speter 429818334Spetervoid 4299132718Skanstore_init_value (tree decl, tree init) 430018334Speter{ 430190075Sobrien tree value, type; 430218334Speter 430318334Speter /* If variable's type was invalidly declared, just ignore it. */ 430418334Speter 430518334Speter type = TREE_TYPE (decl); 430618334Speter if (TREE_CODE (type) == ERROR_MARK) 430718334Speter return; 430818334Speter 430918334Speter /* Digest the specified initializer into an expression. */ 431018334Speter 4311169689Skan value = digest_init (type, init, true, TREE_STATIC (decl)); 431218334Speter 431318334Speter /* Store the expression if valid; else report error. */ 431418334Speter 4315169689Skan if (!in_system_header 4316169689Skan && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && !TREE_STATIC (decl)) 4317169689Skan warning (OPT_Wtraditional, "traditional C rejects automatic " 4318169689Skan "aggregate initialization"); 431990075Sobrien 432018334Speter DECL_INITIAL (decl) = value; 432118334Speter 432218334Speter /* ANSI wants warnings about out-of-range constant initializers. */ 432318334Speter STRIP_TYPE_NOPS (value); 432418334Speter constant_expression_warning (value); 432590075Sobrien 432690075Sobrien /* Check if we need to set array size from compound literal size. */ 432790075Sobrien if (TREE_CODE (type) == ARRAY_TYPE 432890075Sobrien && TYPE_DOMAIN (type) == 0 432990075Sobrien && value != error_mark_node) 433090075Sobrien { 433190075Sobrien tree inside_init = init; 433290075Sobrien 4333169689Skan STRIP_TYPE_NOPS (inside_init); 433490075Sobrien inside_init = fold (inside_init); 433590075Sobrien 433690075Sobrien if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR) 433790075Sobrien { 4338169689Skan tree cldecl = COMPOUND_LITERAL_EXPR_DECL (inside_init); 433990075Sobrien 4340169689Skan if (TYPE_DOMAIN (TREE_TYPE (cldecl))) 434190075Sobrien { 434290075Sobrien /* For int foo[] = (int [3]){1}; we need to set array size 434390075Sobrien now since later on array initializer will be just the 434490075Sobrien brace enclosed list of the compound literal. */ 4345169689Skan type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type)); 4346169689Skan TREE_TYPE (decl) = type; 4347169689Skan TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (cldecl)); 434890075Sobrien layout_type (type); 4349169689Skan layout_decl (cldecl, 0); 435090075Sobrien } 435190075Sobrien } 435290075Sobrien } 435318334Speter} 435418334Speter 435518334Speter/* Methods for storing and printing names for error messages. */ 435618334Speter 435718334Speter/* Implement a spelling stack that allows components of a name to be pushed 435818334Speter and popped. Each element on the stack is this structure. */ 435918334Speter 436018334Speterstruct spelling 436118334Speter{ 436218334Speter int kind; 436318334Speter union 436418334Speter { 4365169689Skan unsigned HOST_WIDE_INT i; 436652284Sobrien const char *s; 436718334Speter } u; 436818334Speter}; 436918334Speter 437018334Speter#define SPELLING_STRING 1 437118334Speter#define SPELLING_MEMBER 2 437218334Speter#define SPELLING_BOUNDS 3 437318334Speter 437418334Speterstatic struct spelling *spelling; /* Next stack element (unused). */ 437518334Speterstatic struct spelling *spelling_base; /* Spelling stack base. */ 437618334Speterstatic int spelling_size; /* Size of the spelling stack. */ 437718334Speter 437818334Speter/* Macros to save and restore the spelling stack around push_... functions. 437918334Speter Alternative to SAVE_SPELLING_STACK. */ 438018334Speter 438118334Speter#define SPELLING_DEPTH() (spelling - spelling_base) 438290075Sobrien#define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH)) 438318334Speter 438418334Speter/* Push an element on the spelling stack with type KIND and assign VALUE 438518334Speter to MEMBER. */ 438618334Speter 438718334Speter#define PUSH_SPELLING(KIND, VALUE, MEMBER) \ 438818334Speter{ \ 438918334Speter int depth = SPELLING_DEPTH (); \ 439018334Speter \ 439118334Speter if (depth >= spelling_size) \ 439218334Speter { \ 439318334Speter spelling_size += 10; \ 4394169689Skan spelling_base = XRESIZEVEC (struct spelling, spelling_base, \ 4395169689Skan spelling_size); \ 439618334Speter RESTORE_SPELLING_DEPTH (depth); \ 439718334Speter } \ 439818334Speter \ 439918334Speter spelling->kind = (KIND); \ 440018334Speter spelling->MEMBER = (VALUE); \ 440118334Speter spelling++; \ 440218334Speter} 440318334Speter 440418334Speter/* Push STRING on the stack. Printed literally. */ 440518334Speter 440618334Speterstatic void 4407132718Skanpush_string (const char *string) 440818334Speter{ 440918334Speter PUSH_SPELLING (SPELLING_STRING, string, u.s); 441018334Speter} 441118334Speter 441218334Speter/* Push a member name on the stack. Printed as '.' STRING. */ 441318334Speter 441418334Speterstatic void 4415132718Skanpush_member_name (tree decl) 441618334Speter{ 441790075Sobrien const char *const string 441818334Speter = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>"; 441918334Speter PUSH_SPELLING (SPELLING_MEMBER, string, u.s); 442018334Speter} 442118334Speter 442218334Speter/* Push an array bounds on the stack. Printed as [BOUNDS]. */ 442318334Speter 442418334Speterstatic void 4425169689Skanpush_array_bounds (unsigned HOST_WIDE_INT bounds) 442618334Speter{ 442718334Speter PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i); 442818334Speter} 442918334Speter 443018334Speter/* Compute the maximum size in bytes of the printed spelling. */ 443118334Speter 443218334Speterstatic int 4433132718Skanspelling_length (void) 443418334Speter{ 443590075Sobrien int size = 0; 443690075Sobrien struct spelling *p; 443718334Speter 443818334Speter for (p = spelling_base; p < spelling; p++) 443918334Speter { 444018334Speter if (p->kind == SPELLING_BOUNDS) 444118334Speter size += 25; 444218334Speter else 444318334Speter size += strlen (p->u.s) + 1; 444418334Speter } 444518334Speter 444618334Speter return size; 444718334Speter} 444818334Speter 444918334Speter/* Print the spelling to BUFFER and return it. */ 445018334Speter 445118334Speterstatic char * 4452132718Skanprint_spelling (char *buffer) 445318334Speter{ 445490075Sobrien char *d = buffer; 445590075Sobrien struct spelling *p; 445618334Speter 445718334Speter for (p = spelling_base; p < spelling; p++) 445818334Speter if (p->kind == SPELLING_BOUNDS) 445918334Speter { 4460169689Skan sprintf (d, "[" HOST_WIDE_INT_PRINT_UNSIGNED "]", p->u.i); 446118334Speter d += strlen (d); 446218334Speter } 446318334Speter else 446418334Speter { 446590075Sobrien const char *s; 446618334Speter if (p->kind == SPELLING_MEMBER) 446718334Speter *d++ = '.'; 446850397Sobrien for (s = p->u.s; (*d = *s++); d++) 446918334Speter ; 447018334Speter } 447118334Speter *d++ = '\0'; 447218334Speter return buffer; 447318334Speter} 447418334Speter 447518334Speter/* Issue an error message for a bad initializer component. 447652284Sobrien MSGID identifies the message. 447752284Sobrien The component name is taken from the spelling stack. */ 447818334Speter 447918334Spetervoid 4480132718Skanerror_init (const char *msgid) 448118334Speter{ 448252284Sobrien char *ofwhat; 448318334Speter 448490075Sobrien error ("%s", _(msgid)); 4485169689Skan ofwhat = print_spelling ((char *) alloca (spelling_length () + 1)); 448618334Speter if (*ofwhat) 4487169689Skan error ("(near initialization for %qs)", ofwhat); 448818334Speter} 448918334Speter 449018334Speter/* Issue a pedantic warning for a bad initializer component. 449152284Sobrien MSGID identifies the message. 449252284Sobrien The component name is taken from the spelling stack. */ 449318334Speter 449418334Spetervoid 4495132718Skanpedwarn_init (const char *msgid) 449618334Speter{ 449752284Sobrien char *ofwhat; 449818334Speter 449990075Sobrien pedwarn ("%s", _(msgid)); 4500169689Skan ofwhat = print_spelling ((char *) alloca (spelling_length () + 1)); 450118334Speter if (*ofwhat) 4502169689Skan pedwarn ("(near initialization for %qs)", ofwhat); 450318334Speter} 450418334Speter 450518334Speter/* Issue a warning for a bad initializer component. 450652284Sobrien MSGID identifies the message. 450752284Sobrien The component name is taken from the spelling stack. */ 450818334Speter 450918334Speterstatic void 4510132718Skanwarning_init (const char *msgid) 451118334Speter{ 451252284Sobrien char *ofwhat; 451318334Speter 4514169689Skan warning (0, "%s", _(msgid)); 4515169689Skan ofwhat = print_spelling ((char *) alloca (spelling_length () + 1)); 451618334Speter if (*ofwhat) 4517169689Skan warning (0, "(near initialization for %qs)", ofwhat); 451818334Speter} 451918334Speter 4520169689Skan/* If TYPE is an array type and EXPR is a parenthesized string 4521169689Skan constant, warn if pedantic that EXPR is being used to initialize an 4522169689Skan object of type TYPE. */ 4523169689Skan 4524169689Skanvoid 4525169689Skanmaybe_warn_string_init (tree type, struct c_expr expr) 4526169689Skan{ 4527169689Skan if (pedantic 4528169689Skan && TREE_CODE (type) == ARRAY_TYPE 4529169689Skan && TREE_CODE (expr.value) == STRING_CST 4530169689Skan && expr.original_code != STRING_CST) 4531169689Skan pedwarn_init ("array initialized from parenthesized string constant"); 4532169689Skan} 4533169689Skan 453418334Speter/* Digest the parser output INIT as an initializer for type TYPE. 453518334Speter Return a C expression of type TYPE to represent the initial value. 453618334Speter 4537169689Skan If INIT is a string constant, STRICT_STRING is true if it is 4538169689Skan unparenthesized or we should not warn here for it being parenthesized. 4539169689Skan For other types of INIT, STRICT_STRING is not used. 4540169689Skan 4541117395Skan REQUIRE_CONSTANT requests an error if non-constant initializers or 4542117395Skan elements are seen. */ 454318334Speter 454418334Speterstatic tree 4545169689Skandigest_init (tree type, tree init, bool strict_string, int require_constant) 454618334Speter{ 454718334Speter enum tree_code code = TREE_CODE (type); 454818334Speter tree inside_init = init; 454918334Speter 455090075Sobrien if (type == error_mark_node 4551169689Skan || !init 455290075Sobrien || init == error_mark_node 455390075Sobrien || TREE_TYPE (init) == error_mark_node) 455490075Sobrien return error_mark_node; 455518334Speter 4556169689Skan STRIP_TYPE_NOPS (inside_init); 455718334Speter 455890075Sobrien inside_init = fold (inside_init); 455990075Sobrien 456018334Speter /* Initialization of an array of chars from a string constant 456118334Speter optionally enclosed in braces. */ 456218334Speter 4563169689Skan if (code == ARRAY_TYPE && inside_init 4564169689Skan && TREE_CODE (inside_init) == STRING_CST) 456518334Speter { 456618334Speter tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type)); 4567169689Skan /* Note that an array could be both an array of character type 4568169689Skan and an array of wchar_t if wchar_t is signed char or unsigned 4569169689Skan char. */ 4570169689Skan bool char_array = (typ1 == char_type_node 4571169689Skan || typ1 == signed_char_type_node 4572169689Skan || typ1 == unsigned_char_type_node); 4573169689Skan bool wchar_array = !!comptypes (typ1, wchar_type_node); 4574169689Skan if (char_array || wchar_array) 457518334Speter { 4576169689Skan struct c_expr expr; 4577169689Skan bool char_string; 4578169689Skan expr.value = inside_init; 4579169689Skan expr.original_code = (strict_string ? STRING_CST : ERROR_MARK); 4580169689Skan maybe_warn_string_init (type, expr); 4581169689Skan 4582169689Skan char_string 4583169689Skan = (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init))) 4584169689Skan == char_type_node); 4585169689Skan 458618334Speter if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), 4587169689Skan TYPE_MAIN_VARIANT (type))) 458818334Speter return inside_init; 458918334Speter 4590169689Skan if (!wchar_array && !char_string) 459118334Speter { 459252284Sobrien error_init ("char-array initialized from wide string"); 459318334Speter return error_mark_node; 459418334Speter } 4595169689Skan if (char_string && !char_array) 459618334Speter { 4597169689Skan error_init ("wchar_t-array initialized from non-wide string"); 459818334Speter return error_mark_node; 459918334Speter } 460018334Speter 460118334Speter TREE_TYPE (inside_init) = type; 460218334Speter if (TYPE_DOMAIN (type) != 0 460390075Sobrien && TYPE_SIZE (type) != 0 460490075Sobrien && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST 460518334Speter /* Subtract 1 (or sizeof (wchar_t)) 460618334Speter because it's ok to ignore the terminating null char 460718334Speter that is counted in the length of the constant. */ 460890075Sobrien && 0 > compare_tree_int (TYPE_SIZE_UNIT (type), 460990075Sobrien TREE_STRING_LENGTH (inside_init) 461090075Sobrien - ((TYPE_PRECISION (typ1) 461190075Sobrien != TYPE_PRECISION (char_type_node)) 461290075Sobrien ? (TYPE_PRECISION (wchar_type_node) 461390075Sobrien / BITS_PER_UNIT) 461490075Sobrien : 1))) 461590075Sobrien pedwarn_init ("initializer-string for array of chars is too long"); 461690075Sobrien 461718334Speter return inside_init; 461818334Speter } 4619169689Skan else if (INTEGRAL_TYPE_P (typ1)) 4620169689Skan { 4621169689Skan error_init ("array of inappropriate type initialized " 4622169689Skan "from string constant"); 4623169689Skan return error_mark_node; 4624169689Skan } 462518334Speter } 4626132718Skan 4627119256Skan /* Build a VECTOR_CST from a *constant* vector constructor. If the 4628119256Skan vector constructor is not constant (e.g. {1,2,3,foo()}) then punt 4629119256Skan below and handle as a constructor. */ 4630146895Skan if (code == VECTOR_TYPE 4631161651Skan && TREE_CODE (TREE_TYPE (inside_init)) == VECTOR_TYPE 4632161651Skan && vector_types_convertible_p (TREE_TYPE (inside_init), type) 4633146895Skan && TREE_CONSTANT (inside_init)) 4634146895Skan { 4635146895Skan if (TREE_CODE (inside_init) == VECTOR_CST 4636146895Skan && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), 4637169689Skan TYPE_MAIN_VARIANT (type))) 4638146895Skan return inside_init; 463918334Speter 4640146895Skan if (TREE_CODE (inside_init) == CONSTRUCTOR) 4641146895Skan { 4642169689Skan unsigned HOST_WIDE_INT ix; 4643169689Skan tree value; 4644169689Skan bool constant_p = true; 4645169689Skan 4646169689Skan /* Iterate through elements and check if all constructor 4647169689Skan elements are *_CSTs. */ 4648169689Skan FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (inside_init), ix, value) 4649169689Skan if (!CONSTANT_CLASS_P (value)) 4650169689Skan { 4651169689Skan constant_p = false; 4652169689Skan break; 4653169689Skan } 4654169689Skan 4655169689Skan if (constant_p) 4656169689Skan return build_vector_from_ctor (type, 4657169689Skan CONSTRUCTOR_ELTS (inside_init)); 4658169689Skan } 4659146895Skan } 4660146895Skan 466118334Speter /* Any type can be initialized 466218334Speter from an expression of the same type, optionally with braces. */ 466318334Speter 466418334Speter if (inside_init && TREE_TYPE (inside_init) != 0 466518334Speter && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), 4666169689Skan TYPE_MAIN_VARIANT (type)) 466718334Speter || (code == ARRAY_TYPE 4668169689Skan && comptypes (TREE_TYPE (inside_init), type)) 466996263Sobrien || (code == VECTOR_TYPE 4670169689Skan && comptypes (TREE_TYPE (inside_init), type)) 467118334Speter || (code == POINTER_TYPE 4672132718Skan && TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE 467318334Speter && comptypes (TREE_TYPE (TREE_TYPE (inside_init)), 4674169689Skan TREE_TYPE (type))))) 467518334Speter { 467690075Sobrien if (code == POINTER_TYPE) 4677122180Skan { 4678122180Skan if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE) 4679122180Skan { 4680169689Skan if (TREE_CODE (inside_init) == STRING_CST 4681169689Skan || TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR) 4682169689Skan inside_init = array_to_pointer_conversion (inside_init); 4683169689Skan else 4684169689Skan { 4685169689Skan error_init ("invalid use of non-lvalue array"); 4686169689Skan return error_mark_node; 4687169689Skan } 4688122180Skan } 4689169689Skan } 4690132718Skan 4691132718Skan if (code == VECTOR_TYPE) 4692132718Skan /* Although the types are compatible, we may require a 4693132718Skan conversion. */ 4694132718Skan inside_init = convert (type, inside_init); 4695132718Skan 4696169689Skan if (require_constant 4697169689Skan && (code == VECTOR_TYPE || !flag_isoc99) 469890075Sobrien && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR) 469918334Speter { 470090075Sobrien /* As an extension, allow initializing objects with static storage 470190075Sobrien duration with compound literals (which are then treated just as 4702169689Skan the brace enclosed list they contain). Also allow this for 4703169689Skan vectors, as we can only assign them with compound literals. */ 470490075Sobrien tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init); 470590075Sobrien inside_init = DECL_INITIAL (decl); 470690075Sobrien } 470790075Sobrien 470890075Sobrien if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST 470990075Sobrien && TREE_CODE (inside_init) != CONSTRUCTOR) 471090075Sobrien { 471152284Sobrien error_init ("array initialized from non-constant array expression"); 471218334Speter return error_mark_node; 471318334Speter } 471418334Speter 471518334Speter if (optimize && TREE_CODE (inside_init) == VAR_DECL) 471690075Sobrien inside_init = decl_constant_value_for_broken_optimization (inside_init); 471718334Speter 471818334Speter /* Compound expressions can only occur here if -pedantic or 471918334Speter -pedantic-errors is specified. In the later case, we always want 472018334Speter an error. In the former case, we simply want a warning. */ 472118334Speter if (require_constant && pedantic 472218334Speter && TREE_CODE (inside_init) == COMPOUND_EXPR) 472318334Speter { 472418334Speter inside_init 472518334Speter = valid_compound_expr_initializer (inside_init, 472618334Speter TREE_TYPE (inside_init)); 472718334Speter if (inside_init == error_mark_node) 472852284Sobrien error_init ("initializer element is not constant"); 472918334Speter else 473052284Sobrien pedwarn_init ("initializer element is not constant"); 473118334Speter if (flag_pedantic_errors) 473218334Speter inside_init = error_mark_node; 473318334Speter } 4734132718Skan else if (require_constant 4735169689Skan && !initializer_constant_valid_p (inside_init, 4736169689Skan TREE_TYPE (inside_init))) 473718334Speter { 473852284Sobrien error_init ("initializer element is not constant"); 473918334Speter inside_init = error_mark_node; 474018334Speter } 474118334Speter 4742169689Skan /* Added to enable additional -Wmissing-format-attribute warnings. */ 4743169689Skan if (TREE_CODE (TREE_TYPE (inside_init)) == POINTER_TYPE) 4744169689Skan inside_init = convert_for_assignment (type, inside_init, ic_init, NULL_TREE, 4745169689Skan NULL_TREE, 0); 474618334Speter return inside_init; 474718334Speter } 474818334Speter 474918334Speter /* Handle scalar types, including conversions. */ 475018334Speter 475118334Speter if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE 4752169689Skan || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE 4753169689Skan || code == VECTOR_TYPE) 475418334Speter { 4755169689Skan if (TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE 4756169689Skan && (TREE_CODE (init) == STRING_CST 4757169689Skan || TREE_CODE (init) == COMPOUND_LITERAL_EXPR)) 4758169689Skan init = array_to_pointer_conversion (init); 475918334Speter inside_init 4760169689Skan = convert_for_assignment (type, init, ic_init, 476118334Speter NULL_TREE, NULL_TREE, 0); 476218334Speter 4763169689Skan /* Check to see if we have already given an error message. */ 4764169689Skan if (inside_init == error_mark_node) 4765169689Skan ; 4766169689Skan else if (require_constant && !TREE_CONSTANT (inside_init)) 476718334Speter { 476852284Sobrien error_init ("initializer element is not constant"); 476918334Speter inside_init = error_mark_node; 477018334Speter } 477118334Speter else if (require_constant 4772169689Skan && !initializer_constant_valid_p (inside_init, 4773169689Skan TREE_TYPE (inside_init))) 477418334Speter { 477552284Sobrien error_init ("initializer element is not computable at load time"); 477618334Speter inside_init = error_mark_node; 477718334Speter } 477818334Speter 477918334Speter return inside_init; 478018334Speter } 478118334Speter 478218334Speter /* Come here only for records and arrays. */ 478318334Speter 478490075Sobrien if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) 478518334Speter { 478652284Sobrien error_init ("variable-sized object may not be initialized"); 478718334Speter return error_mark_node; 478818334Speter } 478918334Speter 479052284Sobrien error_init ("invalid initializer"); 479118334Speter return error_mark_node; 479218334Speter} 479318334Speter 479418334Speter/* Handle initializers that use braces. */ 479518334Speter 479618334Speter/* Type of object we are accumulating a constructor for. 479718334Speter This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */ 479818334Speterstatic tree constructor_type; 479918334Speter 480018334Speter/* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields 480118334Speter left to fill. */ 480218334Speterstatic tree constructor_fields; 480318334Speter 480418334Speter/* For an ARRAY_TYPE, this is the specified index 480590075Sobrien at which to store the next element we get. */ 480618334Speterstatic tree constructor_index; 480718334Speter 480818334Speter/* For an ARRAY_TYPE, this is the maximum index. */ 480918334Speterstatic tree constructor_max_index; 481018334Speter 481118334Speter/* For a RECORD_TYPE, this is the first field not yet written out. */ 481218334Speterstatic tree constructor_unfilled_fields; 481318334Speter 481418334Speter/* For an ARRAY_TYPE, this is the index of the first element 481590075Sobrien not yet written out. */ 481618334Speterstatic tree constructor_unfilled_index; 481718334Speter 481818334Speter/* In a RECORD_TYPE, the byte index of the next consecutive field. 481990075Sobrien This is so we can generate gaps between fields, when appropriate. */ 482018334Speterstatic tree constructor_bit_index; 482118334Speter 482218334Speter/* If we are saving up the elements rather than allocating them, 482318334Speter this is the list of elements so far (in reverse order, 482418334Speter most recent first). */ 4825169689Skanstatic VEC(constructor_elt,gc) *constructor_elements; 482618334Speter 482790075Sobrien/* 1 if constructor should be incrementally stored into a constructor chain, 482890075Sobrien 0 if all the elements should be kept in AVL tree. */ 482990075Sobrienstatic int constructor_incremental; 483090075Sobrien 483118334Speter/* 1 if so far this constructor's elements are all compile-time constants. */ 483218334Speterstatic int constructor_constant; 483318334Speter 483418334Speter/* 1 if so far this constructor's elements are all valid address constants. */ 483518334Speterstatic int constructor_simple; 483618334Speter 483718334Speter/* 1 if this constructor is erroneous so far. */ 483818334Speterstatic int constructor_erroneous; 483918334Speter 484050397Sobrien/* Structure for managing pending initializer elements, organized as an 484150397Sobrien AVL tree. */ 484250397Sobrien 484350397Sobrienstruct init_node 484450397Sobrien{ 484550397Sobrien struct init_node *left, *right; 484650397Sobrien struct init_node *parent; 484750397Sobrien int balance; 484850397Sobrien tree purpose; 484950397Sobrien tree value; 485050397Sobrien}; 485150397Sobrien 485250397Sobrien/* Tree of pending elements at this constructor level. 485318334Speter These are elements encountered out of order 485418334Speter which belong at places we haven't reached yet in actually 485590075Sobrien writing the output. 485690075Sobrien Will never hold tree nodes across GC runs. */ 485750397Sobrienstatic struct init_node *constructor_pending_elts; 485818334Speter 485918334Speter/* The SPELLING_DEPTH of this constructor. */ 486018334Speterstatic int constructor_depth; 486118334Speter 486218334Speter/* DECL node for which an initializer is being read. 486318334Speter 0 means we are reading a constructor expression 486418334Speter such as (struct foo) {...}. */ 486518334Speterstatic tree constructor_decl; 486618334Speter 486718334Speter/* Nonzero if this is an initializer for a top-level decl. */ 486818334Speterstatic int constructor_top_level; 486918334Speter 487090075Sobrien/* Nonzero if there were any member designators in this initializer. */ 487190075Sobrienstatic int constructor_designated; 487290075Sobrien 487390075Sobrien/* Nesting depth of designator list. */ 487490075Sobrienstatic int designator_depth; 487590075Sobrien 487690075Sobrien/* Nonzero if there were diagnosed errors in this designator list. */ 4877169689Skanstatic int designator_erroneous; 487890075Sobrien 487918334Speter 488018334Speter/* This stack has a level for each implicit or explicit level of 488118334Speter structuring in the initializer, including the outermost one. It 488218334Speter saves the values of most of the variables above. */ 488318334Speter 488490075Sobrienstruct constructor_range_stack; 488590075Sobrien 488618334Speterstruct constructor_stack 488718334Speter{ 488818334Speter struct constructor_stack *next; 488918334Speter tree type; 489018334Speter tree fields; 489118334Speter tree index; 489218334Speter tree max_index; 489318334Speter tree unfilled_index; 489418334Speter tree unfilled_fields; 489518334Speter tree bit_index; 4896169689Skan VEC(constructor_elt,gc) *elements; 489790075Sobrien struct init_node *pending_elts; 489818334Speter int offset; 489918334Speter int depth; 4900169689Skan /* If value nonzero, this value should replace the entire 490118334Speter constructor at this level. */ 4902169689Skan struct c_expr replacement_value; 490390075Sobrien struct constructor_range_stack *range_stack; 490418334Speter char constant; 490518334Speter char simple; 490618334Speter char implicit; 490718334Speter char erroneous; 490818334Speter char outer; 490990075Sobrien char incremental; 491090075Sobrien char designated; 491118334Speter}; 491218334Speter 4913169689Skanstatic struct constructor_stack *constructor_stack; 491418334Speter 491590075Sobrien/* This stack represents designators from some range designator up to 491690075Sobrien the last designator in the list. */ 491790075Sobrien 491890075Sobrienstruct constructor_range_stack 491990075Sobrien{ 492090075Sobrien struct constructor_range_stack *next, *prev; 492190075Sobrien struct constructor_stack *stack; 492290075Sobrien tree range_start; 492390075Sobrien tree index; 492490075Sobrien tree range_end; 492590075Sobrien tree fields; 492690075Sobrien}; 492790075Sobrien 4928169689Skanstatic struct constructor_range_stack *constructor_range_stack; 492990075Sobrien 493018334Speter/* This stack records separate initializers that are nested. 493118334Speter Nested initializers can't happen in ANSI C, but GNU C allows them 493218334Speter in cases like { ... (struct foo) { ... } ... }. */ 493318334Speter 493418334Speterstruct initializer_stack 493518334Speter{ 493618334Speter struct initializer_stack *next; 493718334Speter tree decl; 493818334Speter struct constructor_stack *constructor_stack; 493990075Sobrien struct constructor_range_stack *constructor_range_stack; 4940169689Skan VEC(constructor_elt,gc) *elements; 494118334Speter struct spelling *spelling; 494218334Speter struct spelling *spelling_base; 494318334Speter int spelling_size; 494418334Speter char top_level; 494518334Speter char require_constant_value; 494618334Speter char require_constant_elements; 494718334Speter}; 494818334Speter 4949169689Skanstatic struct initializer_stack *initializer_stack; 495018334Speter 495118334Speter/* Prepare to parse and output the initializer for variable DECL. */ 495218334Speter 495318334Spetervoid 4954169689Skanstart_init (tree decl, tree asmspec_tree ATTRIBUTE_UNUSED, int top_level) 495518334Speter{ 495652284Sobrien const char *locus; 4957169689Skan struct initializer_stack *p = XNEW (struct initializer_stack); 495818334Speter 495918334Speter p->decl = constructor_decl; 496018334Speter p->require_constant_value = require_constant_value; 496118334Speter p->require_constant_elements = require_constant_elements; 496218334Speter p->constructor_stack = constructor_stack; 496390075Sobrien p->constructor_range_stack = constructor_range_stack; 496418334Speter p->elements = constructor_elements; 496518334Speter p->spelling = spelling; 496618334Speter p->spelling_base = spelling_base; 496718334Speter p->spelling_size = spelling_size; 496818334Speter p->top_level = constructor_top_level; 496918334Speter p->next = initializer_stack; 497018334Speter initializer_stack = p; 497118334Speter 497218334Speter constructor_decl = decl; 497390075Sobrien constructor_designated = 0; 497418334Speter constructor_top_level = top_level; 497518334Speter 4976169689Skan if (decl != 0 && decl != error_mark_node) 497718334Speter { 497818334Speter require_constant_value = TREE_STATIC (decl); 497918334Speter require_constant_elements 498090075Sobrien = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99)) 498118334Speter /* For a scalar, you can always use any value to initialize, 498218334Speter even within braces. */ 498318334Speter && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE 498418334Speter || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE 498518334Speter || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE 498618334Speter || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE)); 498718334Speter locus = IDENTIFIER_POINTER (DECL_NAME (decl)); 498818334Speter } 498918334Speter else 499018334Speter { 499118334Speter require_constant_value = 0; 499218334Speter require_constant_elements = 0; 499318334Speter locus = "(anonymous)"; 499418334Speter } 499518334Speter 499618334Speter constructor_stack = 0; 499790075Sobrien constructor_range_stack = 0; 499818334Speter 499918334Speter missing_braces_mentioned = 0; 500018334Speter 500118334Speter spelling_base = 0; 500218334Speter spelling_size = 0; 500318334Speter RESTORE_SPELLING_DEPTH (0); 500418334Speter 500518334Speter if (locus) 500618334Speter push_string (locus); 500718334Speter} 500818334Speter 500918334Spetervoid 5010132718Skanfinish_init (void) 501118334Speter{ 501218334Speter struct initializer_stack *p = initializer_stack; 501318334Speter 501418334Speter /* Free the whole constructor stack of this initializer. */ 501518334Speter while (constructor_stack) 501618334Speter { 501718334Speter struct constructor_stack *q = constructor_stack; 501818334Speter constructor_stack = q->next; 501918334Speter free (q); 502018334Speter } 502118334Speter 5022169689Skan gcc_assert (!constructor_range_stack); 502390075Sobrien 502418334Speter /* Pop back to the data of the outer initializer (if any). */ 5025132718Skan free (spelling_base); 5026132718Skan 502718334Speter constructor_decl = p->decl; 502818334Speter require_constant_value = p->require_constant_value; 502918334Speter require_constant_elements = p->require_constant_elements; 503018334Speter constructor_stack = p->constructor_stack; 503190075Sobrien constructor_range_stack = p->constructor_range_stack; 503218334Speter constructor_elements = p->elements; 503318334Speter spelling = p->spelling; 503418334Speter spelling_base = p->spelling_base; 503518334Speter spelling_size = p->spelling_size; 503618334Speter constructor_top_level = p->top_level; 503718334Speter initializer_stack = p->next; 503818334Speter free (p); 503918334Speter} 504018334Speter 504118334Speter/* Call here when we see the initializer is surrounded by braces. 504218334Speter This is instead of a call to push_init_level; 504318334Speter it is matched by a call to pop_init_level. 504418334Speter 504518334Speter TYPE is the type to initialize, for a constructor expression. 504618334Speter For an initializer for a decl, TYPE is zero. */ 504718334Speter 504818334Spetervoid 5049132718Skanreally_start_incremental_init (tree type) 505018334Speter{ 5051169689Skan struct constructor_stack *p = XNEW (struct constructor_stack); 505218334Speter 505318334Speter if (type == 0) 505418334Speter type = TREE_TYPE (constructor_decl); 505518334Speter 5056169689Skan if (targetm.vector_opaque_p (type)) 5057132718Skan error ("opaque vector types cannot be initialized"); 5058132718Skan 505918334Speter p->type = constructor_type; 506018334Speter p->fields = constructor_fields; 506118334Speter p->index = constructor_index; 506218334Speter p->max_index = constructor_max_index; 506318334Speter p->unfilled_index = constructor_unfilled_index; 506418334Speter p->unfilled_fields = constructor_unfilled_fields; 506518334Speter p->bit_index = constructor_bit_index; 506618334Speter p->elements = constructor_elements; 506718334Speter p->constant = constructor_constant; 506818334Speter p->simple = constructor_simple; 506918334Speter p->erroneous = constructor_erroneous; 507018334Speter p->pending_elts = constructor_pending_elts; 507118334Speter p->depth = constructor_depth; 5072169689Skan p->replacement_value.value = 0; 5073169689Skan p->replacement_value.original_code = ERROR_MARK; 507418334Speter p->implicit = 0; 507590075Sobrien p->range_stack = 0; 507690075Sobrien p->outer = 0; 507718334Speter p->incremental = constructor_incremental; 507890075Sobrien p->designated = constructor_designated; 507918334Speter p->next = 0; 508018334Speter constructor_stack = p; 508118334Speter 508218334Speter constructor_constant = 1; 508318334Speter constructor_simple = 1; 508418334Speter constructor_depth = SPELLING_DEPTH (); 508518334Speter constructor_elements = 0; 508618334Speter constructor_pending_elts = 0; 508718334Speter constructor_type = type; 508890075Sobrien constructor_incremental = 1; 508990075Sobrien constructor_designated = 0; 509090075Sobrien designator_depth = 0; 5091169689Skan designator_erroneous = 0; 509218334Speter 509318334Speter if (TREE_CODE (constructor_type) == RECORD_TYPE 509418334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 509518334Speter { 509618334Speter constructor_fields = TYPE_FIELDS (constructor_type); 509718334Speter /* Skip any nameless bit fields at the beginning. */ 509850397Sobrien while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields) 509918334Speter && DECL_NAME (constructor_fields) == 0) 510018334Speter constructor_fields = TREE_CHAIN (constructor_fields); 510190075Sobrien 510218334Speter constructor_unfilled_fields = constructor_fields; 510390075Sobrien constructor_bit_index = bitsize_zero_node; 510418334Speter } 510518334Speter else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 510618334Speter { 510718334Speter if (TYPE_DOMAIN (constructor_type)) 510818334Speter { 510918334Speter constructor_max_index 511018334Speter = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)); 511190075Sobrien 511290075Sobrien /* Detect non-empty initializations of zero-length arrays. */ 511390075Sobrien if (constructor_max_index == NULL_TREE 511490075Sobrien && TYPE_SIZE (constructor_type)) 5115169689Skan constructor_max_index = build_int_cst (NULL_TREE, -1); 511690075Sobrien 511790075Sobrien /* constructor_max_index needs to be an INTEGER_CST. Attempts 5118117395Skan to initialize VLAs will cause a proper error; avoid tree 511990075Sobrien checking errors as well by setting a safe value. */ 512090075Sobrien if (constructor_max_index 512190075Sobrien && TREE_CODE (constructor_max_index) != INTEGER_CST) 5122169689Skan constructor_max_index = build_int_cst (NULL_TREE, -1); 512390075Sobrien 512418334Speter constructor_index 512590075Sobrien = convert (bitsizetype, 512690075Sobrien TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type))); 512718334Speter } 512818334Speter else 5129169689Skan { 5130169689Skan constructor_index = bitsize_zero_node; 5131169689Skan constructor_max_index = NULL_TREE; 5132169689Skan } 513390075Sobrien 513490075Sobrien constructor_unfilled_index = constructor_index; 513518334Speter } 513696263Sobrien else if (TREE_CODE (constructor_type) == VECTOR_TYPE) 513796263Sobrien { 513896263Sobrien /* Vectors are like simple fixed-size arrays. */ 513996263Sobrien constructor_max_index = 5140169689Skan build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1); 5141169689Skan constructor_index = bitsize_zero_node; 514296263Sobrien constructor_unfilled_index = constructor_index; 514396263Sobrien } 514418334Speter else 514518334Speter { 514618334Speter /* Handle the case of int x = {5}; */ 514718334Speter constructor_fields = constructor_type; 514818334Speter constructor_unfilled_fields = constructor_type; 514918334Speter } 515018334Speter} 515118334Speter 515218334Speter/* Push down into a subobject, for initialization. 515318334Speter If this is for an explicit set of braces, IMPLICIT is 0. 515418334Speter If it is because the next element belongs at a lower level, 515590075Sobrien IMPLICIT is 1 (or 2 if the push is because of designator list). */ 515618334Speter 515718334Spetervoid 5158132718Skanpush_init_level (int implicit) 515918334Speter{ 516018334Speter struct constructor_stack *p; 516190075Sobrien tree value = NULL_TREE; 516218334Speter 516318334Speter /* If we've exhausted any levels that didn't have braces, 5164161651Skan pop them now. If implicit == 1, this will have been done in 5165161651Skan process_init_element; do not repeat it here because in the case 5166161651Skan of excess initializers for an empty aggregate this leads to an 5167161651Skan infinite cycle of popping a level and immediately recreating 5168161651Skan it. */ 5169161651Skan if (implicit != 1) 517018334Speter { 5171161651Skan while (constructor_stack->implicit) 5172161651Skan { 5173161651Skan if ((TREE_CODE (constructor_type) == RECORD_TYPE 5174161651Skan || TREE_CODE (constructor_type) == UNION_TYPE) 5175161651Skan && constructor_fields == 0) 5176161651Skan process_init_element (pop_init_level (1)); 5177161651Skan else if (TREE_CODE (constructor_type) == ARRAY_TYPE 5178161651Skan && constructor_max_index 5179161651Skan && tree_int_cst_lt (constructor_max_index, 5180161651Skan constructor_index)) 5181161651Skan process_init_element (pop_init_level (1)); 5182161651Skan else 5183161651Skan break; 5184161651Skan } 518518334Speter } 518618334Speter 518790075Sobrien /* Unless this is an explicit brace, we need to preserve previous 518890075Sobrien content if any. */ 518990075Sobrien if (implicit) 519018334Speter { 519190075Sobrien if ((TREE_CODE (constructor_type) == RECORD_TYPE 519290075Sobrien || TREE_CODE (constructor_type) == UNION_TYPE) 519390075Sobrien && constructor_fields) 519490075Sobrien value = find_init_member (constructor_fields); 519590075Sobrien else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 519690075Sobrien value = find_init_member (constructor_index); 519718334Speter } 519818334Speter 5199169689Skan p = XNEW (struct constructor_stack); 520018334Speter p->type = constructor_type; 520118334Speter p->fields = constructor_fields; 520218334Speter p->index = constructor_index; 520318334Speter p->max_index = constructor_max_index; 520418334Speter p->unfilled_index = constructor_unfilled_index; 520518334Speter p->unfilled_fields = constructor_unfilled_fields; 520618334Speter p->bit_index = constructor_bit_index; 520718334Speter p->elements = constructor_elements; 520818334Speter p->constant = constructor_constant; 520918334Speter p->simple = constructor_simple; 521018334Speter p->erroneous = constructor_erroneous; 521118334Speter p->pending_elts = constructor_pending_elts; 521218334Speter p->depth = constructor_depth; 5213169689Skan p->replacement_value.value = 0; 5214169689Skan p->replacement_value.original_code = ERROR_MARK; 521518334Speter p->implicit = implicit; 521690075Sobrien p->outer = 0; 521718334Speter p->incremental = constructor_incremental; 521890075Sobrien p->designated = constructor_designated; 521918334Speter p->next = constructor_stack; 522090075Sobrien p->range_stack = 0; 522118334Speter constructor_stack = p; 522218334Speter 522318334Speter constructor_constant = 1; 522418334Speter constructor_simple = 1; 522518334Speter constructor_depth = SPELLING_DEPTH (); 522618334Speter constructor_elements = 0; 522790075Sobrien constructor_incremental = 1; 522890075Sobrien constructor_designated = 0; 522918334Speter constructor_pending_elts = 0; 523090075Sobrien if (!implicit) 523190075Sobrien { 523290075Sobrien p->range_stack = constructor_range_stack; 523390075Sobrien constructor_range_stack = 0; 523490075Sobrien designator_depth = 0; 5235169689Skan designator_erroneous = 0; 523690075Sobrien } 523718334Speter 523818334Speter /* Don't die if an entire brace-pair level is superfluous 523918334Speter in the containing level. */ 524018334Speter if (constructor_type == 0) 524118334Speter ; 524218334Speter else if (TREE_CODE (constructor_type) == RECORD_TYPE 524318334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 524418334Speter { 524518334Speter /* Don't die if there are extra init elts at the end. */ 524618334Speter if (constructor_fields == 0) 524718334Speter constructor_type = 0; 524818334Speter else 524918334Speter { 525018334Speter constructor_type = TREE_TYPE (constructor_fields); 525118334Speter push_member_name (constructor_fields); 525218334Speter constructor_depth++; 525318334Speter } 525418334Speter } 525518334Speter else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 525618334Speter { 525718334Speter constructor_type = TREE_TYPE (constructor_type); 5258169689Skan push_array_bounds (tree_low_cst (constructor_index, 1)); 525918334Speter constructor_depth++; 526018334Speter } 526118334Speter 526218334Speter if (constructor_type == 0) 526318334Speter { 526452284Sobrien error_init ("extra brace group at end of initializer"); 526518334Speter constructor_fields = 0; 526618334Speter constructor_unfilled_fields = 0; 526718334Speter return; 526818334Speter } 526918334Speter 527090075Sobrien if (value && TREE_CODE (value) == CONSTRUCTOR) 527190075Sobrien { 527290075Sobrien constructor_constant = TREE_CONSTANT (value); 527390075Sobrien constructor_simple = TREE_STATIC (value); 5274132718Skan constructor_elements = CONSTRUCTOR_ELTS (value); 5275169689Skan if (!VEC_empty (constructor_elt, constructor_elements) 527690075Sobrien && (TREE_CODE (constructor_type) == RECORD_TYPE 527790075Sobrien || TREE_CODE (constructor_type) == ARRAY_TYPE)) 527890075Sobrien set_nonincremental_init (); 527990075Sobrien } 528018334Speter 528190075Sobrien if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned) 528218334Speter { 528318334Speter missing_braces_mentioned = 1; 528452284Sobrien warning_init ("missing braces around initializer"); 528518334Speter } 528618334Speter 528718334Speter if (TREE_CODE (constructor_type) == RECORD_TYPE 528818334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 528918334Speter { 529018334Speter constructor_fields = TYPE_FIELDS (constructor_type); 529118334Speter /* Skip any nameless bit fields at the beginning. */ 529250397Sobrien while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields) 529318334Speter && DECL_NAME (constructor_fields) == 0) 529418334Speter constructor_fields = TREE_CHAIN (constructor_fields); 529590075Sobrien 529618334Speter constructor_unfilled_fields = constructor_fields; 529790075Sobrien constructor_bit_index = bitsize_zero_node; 529818334Speter } 529996263Sobrien else if (TREE_CODE (constructor_type) == VECTOR_TYPE) 530096263Sobrien { 530196263Sobrien /* Vectors are like simple fixed-size arrays. */ 530296263Sobrien constructor_max_index = 5303169689Skan build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1); 530496263Sobrien constructor_index = convert (bitsizetype, integer_zero_node); 530596263Sobrien constructor_unfilled_index = constructor_index; 530696263Sobrien } 530718334Speter else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 530818334Speter { 530918334Speter if (TYPE_DOMAIN (constructor_type)) 531018334Speter { 531118334Speter constructor_max_index 531218334Speter = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)); 531390075Sobrien 531490075Sobrien /* Detect non-empty initializations of zero-length arrays. */ 531590075Sobrien if (constructor_max_index == NULL_TREE 531690075Sobrien && TYPE_SIZE (constructor_type)) 5317169689Skan constructor_max_index = build_int_cst (NULL_TREE, -1); 531890075Sobrien 531990075Sobrien /* constructor_max_index needs to be an INTEGER_CST. Attempts 5320117395Skan to initialize VLAs will cause a proper error; avoid tree 532190075Sobrien checking errors as well by setting a safe value. */ 532290075Sobrien if (constructor_max_index 532390075Sobrien && TREE_CODE (constructor_max_index) != INTEGER_CST) 5324169689Skan constructor_max_index = build_int_cst (NULL_TREE, -1); 532590075Sobrien 532618334Speter constructor_index 5327132718Skan = convert (bitsizetype, 532890075Sobrien TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type))); 532918334Speter } 533018334Speter else 533190075Sobrien constructor_index = bitsize_zero_node; 533290075Sobrien 533390075Sobrien constructor_unfilled_index = constructor_index; 533490075Sobrien if (value && TREE_CODE (value) == STRING_CST) 533590075Sobrien { 533690075Sobrien /* We need to split the char/wchar array into individual 533790075Sobrien characters, so that we don't have to special case it 533890075Sobrien everywhere. */ 533990075Sobrien set_nonincremental_init_from_string (value); 534090075Sobrien } 534118334Speter } 534218334Speter else 534318334Speter { 5344169689Skan if (constructor_type != error_mark_node) 5345169689Skan warning_init ("braces around scalar initializer"); 534618334Speter constructor_fields = constructor_type; 534718334Speter constructor_unfilled_fields = constructor_type; 534818334Speter } 534918334Speter} 535018334Speter 5351132718Skan/* At the end of an implicit or explicit brace level, 5352169689Skan finish up that level of constructor. If a single expression 5353169689Skan with redundant braces initialized that level, return the 5354169689Skan c_expr structure for that expression. Otherwise, the original_code 5355169689Skan element is set to ERROR_MARK. 5356169689Skan If we were outputting the elements as they are read, return 0 as the value 535718334Speter from inner levels (process_init_element ignores that), 5358169689Skan but return error_mark_node as the value from the outermost level 535918334Speter (that's what we want to put in DECL_INITIAL). 5360169689Skan Otherwise, return a CONSTRUCTOR expression as the value. */ 536118334Speter 5362169689Skanstruct c_expr 5363132718Skanpop_init_level (int implicit) 536418334Speter{ 536518334Speter struct constructor_stack *p; 5366169689Skan struct c_expr ret; 5367169689Skan ret.value = 0; 5368169689Skan ret.original_code = ERROR_MARK; 536918334Speter 537018334Speter if (implicit == 0) 537118334Speter { 537218334Speter /* When we come to an explicit close brace, 537318334Speter pop any inner levels that didn't have explicit braces. */ 537418334Speter while (constructor_stack->implicit) 537518334Speter process_init_element (pop_init_level (1)); 537690075Sobrien 5377169689Skan gcc_assert (!constructor_range_stack); 537818334Speter } 537918334Speter 5380132718Skan /* Now output all pending elements. */ 5381132718Skan constructor_incremental = 1; 5382132718Skan output_pending_init_elements (1); 5383132718Skan 538418334Speter p = constructor_stack; 538518334Speter 538690075Sobrien /* Error for initializing a flexible array member, or a zero-length 538790075Sobrien array member in an inappropriate context. */ 538890075Sobrien if (constructor_type && constructor_fields 538990075Sobrien && TREE_CODE (constructor_type) == ARRAY_TYPE 539090075Sobrien && TYPE_DOMAIN (constructor_type) 5391169689Skan && !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type))) 539290075Sobrien { 539390075Sobrien /* Silently discard empty initializations. The parser will 539490075Sobrien already have pedwarned for empty brackets. */ 539590075Sobrien if (integer_zerop (constructor_unfilled_index)) 539690075Sobrien constructor_type = NULL_TREE; 5397169689Skan else 539890075Sobrien { 5399169689Skan gcc_assert (!TYPE_SIZE (constructor_type)); 5400169689Skan 540190075Sobrien if (constructor_depth > 2) 540290075Sobrien error_init ("initialization of flexible array member in a nested context"); 540390075Sobrien else if (pedantic) 540490075Sobrien pedwarn_init ("initialization of a flexible array member"); 540518334Speter 540690075Sobrien /* We have already issued an error message for the existence 540790075Sobrien of a flexible array member not at the end of the structure. 5408169689Skan Discard the initializer so that we do not die later. */ 540990075Sobrien if (TREE_CHAIN (constructor_fields) != NULL_TREE) 541090075Sobrien constructor_type = NULL_TREE; 541190075Sobrien } 541290075Sobrien } 541390075Sobrien 541450397Sobrien /* Warn when some struct elements are implicitly initialized to zero. */ 5415169689Skan if (warn_missing_field_initializers 541650397Sobrien && constructor_type 541750397Sobrien && TREE_CODE (constructor_type) == RECORD_TYPE 541850397Sobrien && constructor_unfilled_fields) 541950397Sobrien { 542090075Sobrien /* Do not warn for flexible array members or zero-length arrays. */ 542190075Sobrien while (constructor_unfilled_fields 5422169689Skan && (!DECL_SIZE (constructor_unfilled_fields) 542390075Sobrien || integer_zerop (DECL_SIZE (constructor_unfilled_fields)))) 542490075Sobrien constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields); 542590075Sobrien 542690075Sobrien /* Do not warn if this level of the initializer uses member 542790075Sobrien designators; it is likely to be deliberate. */ 542890075Sobrien if (constructor_unfilled_fields && !constructor_designated) 542990075Sobrien { 543090075Sobrien push_member_name (constructor_unfilled_fields); 543190075Sobrien warning_init ("missing initializer"); 543290075Sobrien RESTORE_SPELLING_DEPTH (constructor_depth); 543390075Sobrien } 543450397Sobrien } 543550397Sobrien 543618334Speter /* Pad out the end of the structure. */ 5437169689Skan if (p->replacement_value.value) 543890075Sobrien /* If this closes a superfluous brace pair, 543990075Sobrien just pass out the element between them. */ 5440169689Skan ret = p->replacement_value; 544118334Speter else if (constructor_type == 0) 544218334Speter ; 544318334Speter else if (TREE_CODE (constructor_type) != RECORD_TYPE 544418334Speter && TREE_CODE (constructor_type) != UNION_TYPE 544596263Sobrien && TREE_CODE (constructor_type) != ARRAY_TYPE 544696263Sobrien && TREE_CODE (constructor_type) != VECTOR_TYPE) 544718334Speter { 544818334Speter /* A nonincremental scalar initializer--just return 544918334Speter the element, after verifying there is just one. */ 5450169689Skan if (VEC_empty (constructor_elt,constructor_elements)) 545118334Speter { 545290075Sobrien if (!constructor_erroneous) 545390075Sobrien error_init ("empty scalar initializer"); 5454169689Skan ret.value = error_mark_node; 545518334Speter } 5456169689Skan else if (VEC_length (constructor_elt,constructor_elements) != 1) 545718334Speter { 545852284Sobrien error_init ("extra elements in scalar initializer"); 5459169689Skan ret.value = VEC_index (constructor_elt,constructor_elements,0)->value; 546018334Speter } 546118334Speter else 5462169689Skan ret.value = VEC_index (constructor_elt,constructor_elements,0)->value; 546318334Speter } 546490075Sobrien else 546518334Speter { 546618334Speter if (constructor_erroneous) 5467169689Skan ret.value = error_mark_node; 546818334Speter else 546918334Speter { 5470169689Skan ret.value = build_constructor (constructor_type, 5471169689Skan constructor_elements); 547218334Speter if (constructor_constant) 5473169689Skan TREE_CONSTANT (ret.value) = TREE_INVARIANT (ret.value) = 1; 547418334Speter if (constructor_constant && constructor_simple) 5475169689Skan TREE_STATIC (ret.value) = 1; 547618334Speter } 547718334Speter } 547818334Speter 547918334Speter constructor_type = p->type; 548018334Speter constructor_fields = p->fields; 548118334Speter constructor_index = p->index; 548218334Speter constructor_max_index = p->max_index; 548318334Speter constructor_unfilled_index = p->unfilled_index; 548418334Speter constructor_unfilled_fields = p->unfilled_fields; 548518334Speter constructor_bit_index = p->bit_index; 548618334Speter constructor_elements = p->elements; 548718334Speter constructor_constant = p->constant; 548818334Speter constructor_simple = p->simple; 548918334Speter constructor_erroneous = p->erroneous; 549090075Sobrien constructor_incremental = p->incremental; 549190075Sobrien constructor_designated = p->designated; 549218334Speter constructor_pending_elts = p->pending_elts; 549318334Speter constructor_depth = p->depth; 549490075Sobrien if (!p->implicit) 549590075Sobrien constructor_range_stack = p->range_stack; 549618334Speter RESTORE_SPELLING_DEPTH (constructor_depth); 549718334Speter 549818334Speter constructor_stack = p->next; 549918334Speter free (p); 550018334Speter 5501169689Skan if (ret.value == 0 && constructor_stack == 0) 5502169689Skan ret.value = error_mark_node; 5503169689Skan return ret; 550418334Speter} 550518334Speter 550690075Sobrien/* Common handling for both array range and field name designators. 5507117395Skan ARRAY argument is nonzero for array ranges. Returns zero for success. */ 550890075Sobrien 550990075Sobrienstatic int 5510132718Skanset_designator (int array) 551190075Sobrien{ 551290075Sobrien tree subtype; 551390075Sobrien enum tree_code subcode; 551490075Sobrien 551590075Sobrien /* Don't die if an entire brace-pair level is superfluous 551690075Sobrien in the containing level. */ 551790075Sobrien if (constructor_type == 0) 551890075Sobrien return 1; 551990075Sobrien 5520169689Skan /* If there were errors in this designator list already, bail out 5521169689Skan silently. */ 5522169689Skan if (designator_erroneous) 552390075Sobrien return 1; 552490075Sobrien 552590075Sobrien if (!designator_depth) 552690075Sobrien { 5527169689Skan gcc_assert (!constructor_range_stack); 552890075Sobrien 552990075Sobrien /* Designator list starts at the level of closest explicit 553090075Sobrien braces. */ 553190075Sobrien while (constructor_stack->implicit) 553290075Sobrien process_init_element (pop_init_level (1)); 553390075Sobrien constructor_designated = 1; 553490075Sobrien return 0; 553590075Sobrien } 553690075Sobrien 5537169689Skan switch (TREE_CODE (constructor_type)) 553890075Sobrien { 5539169689Skan case RECORD_TYPE: 5540169689Skan case UNION_TYPE: 554190075Sobrien subtype = TREE_TYPE (constructor_fields); 554290075Sobrien if (subtype != error_mark_node) 554390075Sobrien subtype = TYPE_MAIN_VARIANT (subtype); 5544169689Skan break; 5545169689Skan case ARRAY_TYPE: 554690075Sobrien subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type)); 5547169689Skan break; 5548169689Skan default: 5549169689Skan gcc_unreachable (); 555090075Sobrien } 555190075Sobrien 555290075Sobrien subcode = TREE_CODE (subtype); 555390075Sobrien if (array && subcode != ARRAY_TYPE) 555490075Sobrien { 555590075Sobrien error_init ("array index in non-array initializer"); 555690075Sobrien return 1; 555790075Sobrien } 555890075Sobrien else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE) 555990075Sobrien { 556090075Sobrien error_init ("field name not in record or union initializer"); 556190075Sobrien return 1; 556290075Sobrien } 556390075Sobrien 556490075Sobrien constructor_designated = 1; 556590075Sobrien push_init_level (2); 556690075Sobrien return 0; 556790075Sobrien} 556890075Sobrien 556990075Sobrien/* If there are range designators in designator list, push a new designator 557090075Sobrien to constructor_range_stack. RANGE_END is end of such stack range or 557190075Sobrien NULL_TREE if there is no range designator at this level. */ 557290075Sobrien 557390075Sobrienstatic void 5574132718Skanpush_range_stack (tree range_end) 557590075Sobrien{ 557690075Sobrien struct constructor_range_stack *p; 557790075Sobrien 5578169689Skan p = GGC_NEW (struct constructor_range_stack); 557990075Sobrien p->prev = constructor_range_stack; 558090075Sobrien p->next = 0; 558190075Sobrien p->fields = constructor_fields; 558290075Sobrien p->range_start = constructor_index; 558390075Sobrien p->index = constructor_index; 558490075Sobrien p->stack = constructor_stack; 558590075Sobrien p->range_end = range_end; 558690075Sobrien if (constructor_range_stack) 558790075Sobrien constructor_range_stack->next = p; 558890075Sobrien constructor_range_stack = p; 558990075Sobrien} 559090075Sobrien 559118334Speter/* Within an array initializer, specify the next index to be initialized. 559218334Speter FIRST is that index. If LAST is nonzero, then initialize a range 559318334Speter of indices, running from FIRST through LAST. */ 559418334Speter 559518334Spetervoid 5596132718Skanset_init_index (tree first, tree last) 559718334Speter{ 559890075Sobrien if (set_designator (1)) 559990075Sobrien return; 560090075Sobrien 5601169689Skan designator_erroneous = 1; 560290075Sobrien 5603169689Skan if (!INTEGRAL_TYPE_P (TREE_TYPE (first)) 5604169689Skan || (last && !INTEGRAL_TYPE_P (TREE_TYPE (last)))) 5605169689Skan { 5606169689Skan error_init ("array index in initializer not of integer type"); 5607169689Skan return; 5608169689Skan } 560990075Sobrien 561018334Speter if (TREE_CODE (first) != INTEGER_CST) 561152284Sobrien error_init ("nonconstant array index in initializer"); 561218334Speter else if (last != 0 && TREE_CODE (last) != INTEGER_CST) 561352284Sobrien error_init ("nonconstant array index in initializer"); 561490075Sobrien else if (TREE_CODE (constructor_type) != ARRAY_TYPE) 561552284Sobrien error_init ("array index in non-array initializer"); 5616122180Skan else if (tree_int_cst_sgn (first) == -1) 5617122180Skan error_init ("array index in initializer exceeds array bounds"); 561890075Sobrien else if (constructor_max_index 561990075Sobrien && tree_int_cst_lt (constructor_max_index, first)) 562090075Sobrien error_init ("array index in initializer exceeds array bounds"); 562118334Speter else 562218334Speter { 562390075Sobrien constructor_index = convert (bitsizetype, first); 562418334Speter 562590075Sobrien if (last) 562618334Speter { 562790075Sobrien if (tree_int_cst_equal (first, last)) 562890075Sobrien last = 0; 562990075Sobrien else if (tree_int_cst_lt (last, first)) 563090075Sobrien { 563190075Sobrien error_init ("empty index range in initializer"); 563290075Sobrien last = 0; 563390075Sobrien } 563490075Sobrien else 563590075Sobrien { 563690075Sobrien last = convert (bitsizetype, last); 563790075Sobrien if (constructor_max_index != 0 563890075Sobrien && tree_int_cst_lt (constructor_max_index, last)) 563990075Sobrien { 564090075Sobrien error_init ("array index range in initializer exceeds array bounds"); 564190075Sobrien last = 0; 564290075Sobrien } 564390075Sobrien } 564418334Speter } 564590075Sobrien 564690075Sobrien designator_depth++; 5647169689Skan designator_erroneous = 0; 564890075Sobrien if (constructor_range_stack || last) 564990075Sobrien push_range_stack (last); 565018334Speter } 565118334Speter} 565218334Speter 565318334Speter/* Within a struct initializer, specify the next field to be initialized. */ 565418334Speter 565518334Spetervoid 5656132718Skanset_init_label (tree fieldname) 565718334Speter{ 565818334Speter tree tail; 565918334Speter 566090075Sobrien if (set_designator (0)) 566118334Speter return; 566218334Speter 5663169689Skan designator_erroneous = 1; 566490075Sobrien 566590075Sobrien if (TREE_CODE (constructor_type) != RECORD_TYPE 566690075Sobrien && TREE_CODE (constructor_type) != UNION_TYPE) 566790075Sobrien { 566890075Sobrien error_init ("field name not in record or union initializer"); 566990075Sobrien return; 567090075Sobrien } 5671132718Skan 567218334Speter for (tail = TYPE_FIELDS (constructor_type); tail; 567318334Speter tail = TREE_CHAIN (tail)) 567418334Speter { 567518334Speter if (DECL_NAME (tail) == fieldname) 567618334Speter break; 567718334Speter } 567818334Speter 567918334Speter if (tail == 0) 5680169689Skan error ("unknown field %qE specified in initializer", fieldname); 568118334Speter else 568218334Speter { 568318334Speter constructor_fields = tail; 568490075Sobrien designator_depth++; 5685169689Skan designator_erroneous = 0; 568690075Sobrien if (constructor_range_stack) 568790075Sobrien push_range_stack (NULL_TREE); 568818334Speter } 568918334Speter} 569018334Speter 569150397Sobrien/* Add a new initializer to the tree of pending initializers. PURPOSE 5692132718Skan identifies the initializer, either array index or field in a structure. 569350397Sobrien VALUE is the value of that index or field. */ 569450397Sobrien 569550397Sobrienstatic void 5696132718Skanadd_pending_init (tree purpose, tree value) 569750397Sobrien{ 569850397Sobrien struct init_node *p, **q, *r; 569950397Sobrien 570050397Sobrien q = &constructor_pending_elts; 570150397Sobrien p = 0; 570250397Sobrien 570350397Sobrien if (TREE_CODE (constructor_type) == ARRAY_TYPE) 570450397Sobrien { 570550397Sobrien while (*q != 0) 570650397Sobrien { 570750397Sobrien p = *q; 570850397Sobrien if (tree_int_cst_lt (purpose, p->purpose)) 570950397Sobrien q = &p->left; 571090075Sobrien else if (tree_int_cst_lt (p->purpose, purpose)) 571150397Sobrien q = &p->right; 571250397Sobrien else 571390075Sobrien { 571490075Sobrien if (TREE_SIDE_EFFECTS (p->value)) 571590075Sobrien warning_init ("initialized field with side-effects overwritten"); 5716169689Skan else if (warn_override_init) 5717169689Skan warning_init ("initialized field overwritten"); 571890075Sobrien p->value = value; 571990075Sobrien return; 572090075Sobrien } 572150397Sobrien } 572250397Sobrien } 572350397Sobrien else 572450397Sobrien { 572590075Sobrien tree bitpos; 572690075Sobrien 572790075Sobrien bitpos = bit_position (purpose); 572850397Sobrien while (*q != NULL) 572950397Sobrien { 573050397Sobrien p = *q; 573190075Sobrien if (tree_int_cst_lt (bitpos, bit_position (p->purpose))) 573250397Sobrien q = &p->left; 573360967Sobrien else if (p->purpose != purpose) 573450397Sobrien q = &p->right; 573550397Sobrien else 573690075Sobrien { 573790075Sobrien if (TREE_SIDE_EFFECTS (p->value)) 573890075Sobrien warning_init ("initialized field with side-effects overwritten"); 5739169689Skan else if (warn_override_init) 5740169689Skan warning_init ("initialized field overwritten"); 574190075Sobrien p->value = value; 574290075Sobrien return; 574390075Sobrien } 574450397Sobrien } 574550397Sobrien } 574650397Sobrien 5747169689Skan r = GGC_NEW (struct init_node); 574850397Sobrien r->purpose = purpose; 574950397Sobrien r->value = value; 575050397Sobrien 575150397Sobrien *q = r; 575250397Sobrien r->parent = p; 575350397Sobrien r->left = 0; 575450397Sobrien r->right = 0; 575550397Sobrien r->balance = 0; 575650397Sobrien 575750397Sobrien while (p) 575850397Sobrien { 575950397Sobrien struct init_node *s; 576050397Sobrien 576150397Sobrien if (r == p->left) 576250397Sobrien { 576350397Sobrien if (p->balance == 0) 576450397Sobrien p->balance = -1; 576550397Sobrien else if (p->balance < 0) 576650397Sobrien { 576750397Sobrien if (r->balance < 0) 576850397Sobrien { 576990075Sobrien /* L rotation. */ 577050397Sobrien p->left = r->right; 577150397Sobrien if (p->left) 577250397Sobrien p->left->parent = p; 577350397Sobrien r->right = p; 577450397Sobrien 577550397Sobrien p->balance = 0; 577650397Sobrien r->balance = 0; 577750397Sobrien 577850397Sobrien s = p->parent; 577950397Sobrien p->parent = r; 578050397Sobrien r->parent = s; 578150397Sobrien if (s) 578250397Sobrien { 578350397Sobrien if (s->left == p) 578450397Sobrien s->left = r; 578550397Sobrien else 578650397Sobrien s->right = r; 578750397Sobrien } 578850397Sobrien else 578950397Sobrien constructor_pending_elts = r; 579050397Sobrien } 579150397Sobrien else 579250397Sobrien { 579390075Sobrien /* LR rotation. */ 579450397Sobrien struct init_node *t = r->right; 579550397Sobrien 579650397Sobrien r->right = t->left; 579750397Sobrien if (r->right) 579850397Sobrien r->right->parent = r; 579950397Sobrien t->left = r; 580050397Sobrien 580150397Sobrien p->left = t->right; 580250397Sobrien if (p->left) 580350397Sobrien p->left->parent = p; 580450397Sobrien t->right = p; 580550397Sobrien 580650397Sobrien p->balance = t->balance < 0; 580750397Sobrien r->balance = -(t->balance > 0); 580850397Sobrien t->balance = 0; 580950397Sobrien 581050397Sobrien s = p->parent; 581150397Sobrien p->parent = t; 581250397Sobrien r->parent = t; 581350397Sobrien t->parent = s; 581450397Sobrien if (s) 581550397Sobrien { 581650397Sobrien if (s->left == p) 581750397Sobrien s->left = t; 581850397Sobrien else 581950397Sobrien s->right = t; 582050397Sobrien } 582150397Sobrien else 582250397Sobrien constructor_pending_elts = t; 582350397Sobrien } 582450397Sobrien break; 582550397Sobrien } 582650397Sobrien else 582750397Sobrien { 582850397Sobrien /* p->balance == +1; growth of left side balances the node. */ 582950397Sobrien p->balance = 0; 583050397Sobrien break; 583150397Sobrien } 583250397Sobrien } 583350397Sobrien else /* r == p->right */ 583450397Sobrien { 583550397Sobrien if (p->balance == 0) 583650397Sobrien /* Growth propagation from right side. */ 583750397Sobrien p->balance++; 583850397Sobrien else if (p->balance > 0) 583950397Sobrien { 584050397Sobrien if (r->balance > 0) 584150397Sobrien { 584290075Sobrien /* R rotation. */ 584350397Sobrien p->right = r->left; 584450397Sobrien if (p->right) 584550397Sobrien p->right->parent = p; 584650397Sobrien r->left = p; 584750397Sobrien 584850397Sobrien p->balance = 0; 584950397Sobrien r->balance = 0; 585050397Sobrien 585150397Sobrien s = p->parent; 585250397Sobrien p->parent = r; 585350397Sobrien r->parent = s; 585450397Sobrien if (s) 585550397Sobrien { 585650397Sobrien if (s->left == p) 585750397Sobrien s->left = r; 585850397Sobrien else 585950397Sobrien s->right = r; 586050397Sobrien } 586150397Sobrien else 586250397Sobrien constructor_pending_elts = r; 586350397Sobrien } 586450397Sobrien else /* r->balance == -1 */ 586550397Sobrien { 586650397Sobrien /* RL rotation */ 586750397Sobrien struct init_node *t = r->left; 586850397Sobrien 586950397Sobrien r->left = t->right; 587050397Sobrien if (r->left) 587150397Sobrien r->left->parent = r; 587250397Sobrien t->right = r; 587350397Sobrien 587450397Sobrien p->right = t->left; 587550397Sobrien if (p->right) 587650397Sobrien p->right->parent = p; 587750397Sobrien t->left = p; 587850397Sobrien 587950397Sobrien r->balance = (t->balance < 0); 588050397Sobrien p->balance = -(t->balance > 0); 588150397Sobrien t->balance = 0; 588250397Sobrien 588350397Sobrien s = p->parent; 588450397Sobrien p->parent = t; 588550397Sobrien r->parent = t; 588650397Sobrien t->parent = s; 588750397Sobrien if (s) 588850397Sobrien { 588950397Sobrien if (s->left == p) 589050397Sobrien s->left = t; 589150397Sobrien else 589250397Sobrien s->right = t; 589350397Sobrien } 589450397Sobrien else 589550397Sobrien constructor_pending_elts = t; 589650397Sobrien } 589750397Sobrien break; 589850397Sobrien } 589950397Sobrien else 590050397Sobrien { 590190075Sobrien /* p->balance == -1; growth of right side balances the node. */ 590250397Sobrien p->balance = 0; 590350397Sobrien break; 590450397Sobrien } 590550397Sobrien } 590650397Sobrien 590750397Sobrien r = p; 590850397Sobrien p = p->parent; 590950397Sobrien } 591050397Sobrien} 591150397Sobrien 591290075Sobrien/* Build AVL tree from a sorted chain. */ 591350397Sobrien 591490075Sobrienstatic void 5915132718Skanset_nonincremental_init (void) 591690075Sobrien{ 5917169689Skan unsigned HOST_WIDE_INT ix; 5918169689Skan tree index, value; 591990075Sobrien 592090075Sobrien if (TREE_CODE (constructor_type) != RECORD_TYPE 592190075Sobrien && TREE_CODE (constructor_type) != ARRAY_TYPE) 592290075Sobrien return; 592390075Sobrien 5924169689Skan FOR_EACH_CONSTRUCTOR_ELT (constructor_elements, ix, index, value) 5925169689Skan add_pending_init (index, value); 592690075Sobrien constructor_elements = 0; 592790075Sobrien if (TREE_CODE (constructor_type) == RECORD_TYPE) 592890075Sobrien { 592990075Sobrien constructor_unfilled_fields = TYPE_FIELDS (constructor_type); 593090075Sobrien /* Skip any nameless bit fields at the beginning. */ 593190075Sobrien while (constructor_unfilled_fields != 0 593290075Sobrien && DECL_C_BIT_FIELD (constructor_unfilled_fields) 593390075Sobrien && DECL_NAME (constructor_unfilled_fields) == 0) 593490075Sobrien constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields); 5935132718Skan 593690075Sobrien } 593790075Sobrien else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 593890075Sobrien { 593990075Sobrien if (TYPE_DOMAIN (constructor_type)) 594090075Sobrien constructor_unfilled_index 594190075Sobrien = convert (bitsizetype, 594290075Sobrien TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type))); 594390075Sobrien else 594490075Sobrien constructor_unfilled_index = bitsize_zero_node; 594590075Sobrien } 594690075Sobrien constructor_incremental = 0; 594790075Sobrien} 594890075Sobrien 594990075Sobrien/* Build AVL tree from a string constant. */ 595090075Sobrien 595190075Sobrienstatic void 5952132718Skanset_nonincremental_init_from_string (tree str) 595390075Sobrien{ 595490075Sobrien tree value, purpose, type; 595590075Sobrien HOST_WIDE_INT val[2]; 595690075Sobrien const char *p, *end; 595790075Sobrien int byte, wchar_bytes, charwidth, bitpos; 595890075Sobrien 5959169689Skan gcc_assert (TREE_CODE (constructor_type) == ARRAY_TYPE); 596090075Sobrien 596190075Sobrien if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str))) 596290075Sobrien == TYPE_PRECISION (char_type_node)) 596390075Sobrien wchar_bytes = 1; 596490075Sobrien else 5965169689Skan { 5966169689Skan gcc_assert (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str))) 5967169689Skan == TYPE_PRECISION (wchar_type_node)); 5968169689Skan wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT; 5969169689Skan } 597090075Sobrien charwidth = TYPE_PRECISION (char_type_node); 597190075Sobrien type = TREE_TYPE (constructor_type); 597290075Sobrien p = TREE_STRING_POINTER (str); 597390075Sobrien end = p + TREE_STRING_LENGTH (str); 597490075Sobrien 597590075Sobrien for (purpose = bitsize_zero_node; 597690075Sobrien p < end && !tree_int_cst_lt (constructor_max_index, purpose); 597790075Sobrien purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node)) 597890075Sobrien { 597990075Sobrien if (wchar_bytes == 1) 598090075Sobrien { 598190075Sobrien val[1] = (unsigned char) *p++; 598290075Sobrien val[0] = 0; 598390075Sobrien } 598490075Sobrien else 598590075Sobrien { 598690075Sobrien val[0] = 0; 598790075Sobrien val[1] = 0; 598890075Sobrien for (byte = 0; byte < wchar_bytes; byte++) 598990075Sobrien { 599090075Sobrien if (BYTES_BIG_ENDIAN) 599190075Sobrien bitpos = (wchar_bytes - byte - 1) * charwidth; 599290075Sobrien else 599390075Sobrien bitpos = byte * charwidth; 599490075Sobrien val[bitpos < HOST_BITS_PER_WIDE_INT] 599590075Sobrien |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++)) 599690075Sobrien << (bitpos % HOST_BITS_PER_WIDE_INT); 599790075Sobrien } 599890075Sobrien } 599990075Sobrien 6000169689Skan if (!TYPE_UNSIGNED (type)) 600190075Sobrien { 600290075Sobrien bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR; 600390075Sobrien if (bitpos < HOST_BITS_PER_WIDE_INT) 600490075Sobrien { 600590075Sobrien if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1))) 600690075Sobrien { 600790075Sobrien val[1] |= ((HOST_WIDE_INT) -1) << bitpos; 600890075Sobrien val[0] = -1; 600990075Sobrien } 601090075Sobrien } 601190075Sobrien else if (bitpos == HOST_BITS_PER_WIDE_INT) 601290075Sobrien { 601390075Sobrien if (val[1] < 0) 6014169689Skan val[0] = -1; 601590075Sobrien } 601690075Sobrien else if (val[0] & (((HOST_WIDE_INT) 1) 601790075Sobrien << (bitpos - 1 - HOST_BITS_PER_WIDE_INT))) 601890075Sobrien val[0] |= ((HOST_WIDE_INT) -1) 601990075Sobrien << (bitpos - HOST_BITS_PER_WIDE_INT); 602090075Sobrien } 602190075Sobrien 6022169689Skan value = build_int_cst_wide (type, val[1], val[0]); 602390075Sobrien add_pending_init (purpose, value); 602490075Sobrien } 602590075Sobrien 602690075Sobrien constructor_incremental = 0; 602790075Sobrien} 602890075Sobrien 602990075Sobrien/* Return value of FIELD in pending initializer or zero if the field was 603090075Sobrien not initialized yet. */ 603190075Sobrien 603290075Sobrienstatic tree 6033132718Skanfind_init_member (tree field) 603450397Sobrien{ 603550397Sobrien struct init_node *p; 603650397Sobrien 603750397Sobrien if (TREE_CODE (constructor_type) == ARRAY_TYPE) 603850397Sobrien { 603990075Sobrien if (constructor_incremental 604090075Sobrien && tree_int_cst_lt (field, constructor_unfilled_index)) 604190075Sobrien set_nonincremental_init (); 604290075Sobrien 604390075Sobrien p = constructor_pending_elts; 604450397Sobrien while (p) 604550397Sobrien { 604690075Sobrien if (tree_int_cst_lt (field, p->purpose)) 604750397Sobrien p = p->left; 604890075Sobrien else if (tree_int_cst_lt (p->purpose, field)) 604990075Sobrien p = p->right; 605050397Sobrien else 605190075Sobrien return p->value; 605250397Sobrien } 605350397Sobrien } 605490075Sobrien else if (TREE_CODE (constructor_type) == RECORD_TYPE) 605550397Sobrien { 605690075Sobrien tree bitpos = bit_position (field); 605790075Sobrien 605890075Sobrien if (constructor_incremental 605990075Sobrien && (!constructor_unfilled_fields 606090075Sobrien || tree_int_cst_lt (bitpos, 606190075Sobrien bit_position (constructor_unfilled_fields)))) 606290075Sobrien set_nonincremental_init (); 606390075Sobrien 606490075Sobrien p = constructor_pending_elts; 606550397Sobrien while (p) 606650397Sobrien { 606750397Sobrien if (field == p->purpose) 606890075Sobrien return p->value; 606990075Sobrien else if (tree_int_cst_lt (bitpos, bit_position (p->purpose))) 607050397Sobrien p = p->left; 607150397Sobrien else 607250397Sobrien p = p->right; 607350397Sobrien } 607450397Sobrien } 607590075Sobrien else if (TREE_CODE (constructor_type) == UNION_TYPE) 607690075Sobrien { 6077169689Skan if (!VEC_empty (constructor_elt, constructor_elements) 6078169689Skan && (VEC_last (constructor_elt, constructor_elements)->index 6079169689Skan == field)) 6080169689Skan return VEC_last (constructor_elt, constructor_elements)->value; 608190075Sobrien } 608250397Sobrien return 0; 608350397Sobrien} 608450397Sobrien 608518334Speter/* "Output" the next constructor element. 608618334Speter At top level, really output it to assembler code now. 608718334Speter Otherwise, collect it in a list from which we will make a CONSTRUCTOR. 608818334Speter TYPE is the data type that the containing data type wants here. 608918334Speter FIELD is the field (a FIELD_DECL) or the index that this element fills. 6090169689Skan If VALUE is a string constant, STRICT_STRING is true if it is 6091169689Skan unparenthesized or we should not warn here for it being parenthesized. 6092169689Skan For other types of VALUE, STRICT_STRING is not used. 609318334Speter 609418334Speter PENDING if non-nil means output pending elements that belong 609518334Speter right after this element. (PENDING is normally 1; 609618334Speter it is 0 while outputting pending elements, to avoid recursion.) */ 609718334Speter 609818334Speterstatic void 6099169689Skanoutput_init_element (tree value, bool strict_string, tree type, tree field, 6100169689Skan int pending) 610118334Speter{ 6102169689Skan constructor_elt *celt; 6103169689Skan 6104169689Skan if (type == error_mark_node || value == error_mark_node) 6105132718Skan { 6106132718Skan constructor_erroneous = 1; 6107132718Skan return; 6108132718Skan } 6109169689Skan if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE 6110169689Skan && (TREE_CODE (value) == STRING_CST 6111169689Skan || TREE_CODE (value) == COMPOUND_LITERAL_EXPR) 6112169689Skan && !(TREE_CODE (value) == STRING_CST 6113169689Skan && TREE_CODE (type) == ARRAY_TYPE 6114169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (type))) 6115169689Skan && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)), 6116169689Skan TYPE_MAIN_VARIANT (type))) 6117169689Skan value = array_to_pointer_conversion (value); 611818334Speter 611990075Sobrien if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR 612090075Sobrien && require_constant_value && !flag_isoc99 && pending) 612190075Sobrien { 612290075Sobrien /* As an extension, allow initializing objects with static storage 612390075Sobrien duration with compound literals (which are then treated just as 612490075Sobrien the brace enclosed list they contain). */ 612590075Sobrien tree decl = COMPOUND_LITERAL_EXPR_DECL (value); 612690075Sobrien value = DECL_INITIAL (decl); 612790075Sobrien } 612890075Sobrien 612918334Speter if (value == error_mark_node) 613018334Speter constructor_erroneous = 1; 613118334Speter else if (!TREE_CONSTANT (value)) 613218334Speter constructor_constant = 0; 6133169689Skan else if (!initializer_constant_valid_p (value, TREE_TYPE (value)) 613418334Speter || ((TREE_CODE (constructor_type) == RECORD_TYPE 613518334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 613650397Sobrien && DECL_C_BIT_FIELD (field) 613750397Sobrien && TREE_CODE (value) != INTEGER_CST)) 613818334Speter constructor_simple = 0; 613918334Speter 6140169689Skan if (!initializer_constant_valid_p (value, TREE_TYPE (value))) 614118334Speter { 6142169689Skan if (require_constant_value) 6143169689Skan { 6144169689Skan error_init ("initializer element is not constant"); 6145169689Skan value = error_mark_node; 6146169689Skan } 6147169689Skan else if (require_constant_elements) 6148169689Skan pedwarn ("initializer element is not computable at load time"); 614918334Speter } 615018334Speter 615190075Sobrien /* If this field is empty (and not at the end of structure), 615290075Sobrien don't do anything other than checking the initializer. */ 615390075Sobrien if (field 615490075Sobrien && (TREE_TYPE (field) == error_mark_node 615590075Sobrien || (COMPLETE_TYPE_P (TREE_TYPE (field)) 615690075Sobrien && integer_zerop (TYPE_SIZE (TREE_TYPE (field))) 615790075Sobrien && (TREE_CODE (constructor_type) == ARRAY_TYPE 615890075Sobrien || TREE_CHAIN (field))))) 615990075Sobrien return; 616090075Sobrien 6161169689Skan value = digest_init (type, value, strict_string, require_constant_value); 616290075Sobrien if (value == error_mark_node) 616318334Speter { 616490075Sobrien constructor_erroneous = 1; 616590075Sobrien return; 616618334Speter } 616718334Speter 616818334Speter /* If this element doesn't come next in sequence, 616918334Speter put it on constructor_pending_elts. */ 617018334Speter if (TREE_CODE (constructor_type) == ARRAY_TYPE 617190075Sobrien && (!constructor_incremental 617290075Sobrien || !tree_int_cst_equal (field, constructor_unfilled_index))) 617318334Speter { 617490075Sobrien if (constructor_incremental 617590075Sobrien && tree_int_cst_lt (field, constructor_unfilled_index)) 617690075Sobrien set_nonincremental_init (); 617790075Sobrien 617890075Sobrien add_pending_init (field, value); 617990075Sobrien return; 618018334Speter } 618118334Speter else if (TREE_CODE (constructor_type) == RECORD_TYPE 618290075Sobrien && (!constructor_incremental 618390075Sobrien || field != constructor_unfilled_fields)) 618418334Speter { 618518334Speter /* We do this for records but not for unions. In a union, 618618334Speter no matter which field is specified, it can be initialized 618718334Speter right away since it starts at the beginning of the union. */ 618890075Sobrien if (constructor_incremental) 618918334Speter { 619090075Sobrien if (!constructor_unfilled_fields) 619190075Sobrien set_nonincremental_init (); 619218334Speter else 619318334Speter { 619490075Sobrien tree bitpos, unfillpos; 619518334Speter 619690075Sobrien bitpos = bit_position (field); 619790075Sobrien unfillpos = bit_position (constructor_unfilled_fields); 619818334Speter 619990075Sobrien if (tree_int_cst_lt (bitpos, unfillpos)) 620090075Sobrien set_nonincremental_init (); 620118334Speter } 620218334Speter } 620318334Speter 620490075Sobrien add_pending_init (field, value); 620590075Sobrien return; 620690075Sobrien } 620790075Sobrien else if (TREE_CODE (constructor_type) == UNION_TYPE 6208169689Skan && !VEC_empty (constructor_elt, constructor_elements)) 620990075Sobrien { 6210169689Skan if (TREE_SIDE_EFFECTS (VEC_last (constructor_elt, 6211169689Skan constructor_elements)->value)) 621290075Sobrien warning_init ("initialized field with side-effects overwritten"); 6213169689Skan else if (warn_override_init) 6214169689Skan warning_init ("initialized field overwritten"); 621518334Speter 621690075Sobrien /* We can have just one union field set. */ 621790075Sobrien constructor_elements = 0; 621818334Speter } 621990075Sobrien 622090075Sobrien /* Otherwise, output this element either to 622190075Sobrien constructor_elements or to the assembler file. */ 622290075Sobrien 6223169689Skan celt = VEC_safe_push (constructor_elt, gc, constructor_elements, NULL); 6224169689Skan celt->index = field; 6225169689Skan celt->value = value; 622690075Sobrien 622790075Sobrien /* Advance the variable that indicates sequential elements output. */ 622890075Sobrien if (TREE_CODE (constructor_type) == ARRAY_TYPE) 622990075Sobrien constructor_unfilled_index 623090075Sobrien = size_binop (PLUS_EXPR, constructor_unfilled_index, 623190075Sobrien bitsize_one_node); 623290075Sobrien else if (TREE_CODE (constructor_type) == RECORD_TYPE) 623390075Sobrien { 623490075Sobrien constructor_unfilled_fields 623590075Sobrien = TREE_CHAIN (constructor_unfilled_fields); 623690075Sobrien 623790075Sobrien /* Skip any nameless bit fields. */ 623890075Sobrien while (constructor_unfilled_fields != 0 623990075Sobrien && DECL_C_BIT_FIELD (constructor_unfilled_fields) 624090075Sobrien && DECL_NAME (constructor_unfilled_fields) == 0) 624190075Sobrien constructor_unfilled_fields = 624290075Sobrien TREE_CHAIN (constructor_unfilled_fields); 624390075Sobrien } 624490075Sobrien else if (TREE_CODE (constructor_type) == UNION_TYPE) 624590075Sobrien constructor_unfilled_fields = 0; 624690075Sobrien 624790075Sobrien /* Now output any pending elements which have become next. */ 624890075Sobrien if (pending) 624990075Sobrien output_pending_init_elements (0); 625018334Speter} 625118334Speter 625218334Speter/* Output any pending elements which have become next. 625318334Speter As we output elements, constructor_unfilled_{fields,index} 625418334Speter advances, which may cause other elements to become next; 625518334Speter if so, they too are output. 625618334Speter 625718334Speter If ALL is 0, we return when there are 625818334Speter no more pending elements to output now. 625918334Speter 626018334Speter If ALL is 1, we output space as necessary so that 626118334Speter we can output all the pending elements. */ 626218334Speter 626318334Speterstatic void 6264132718Skanoutput_pending_init_elements (int all) 626518334Speter{ 626650397Sobrien struct init_node *elt = constructor_pending_elts; 626718334Speter tree next; 626818334Speter 626918334Speter retry: 627018334Speter 6271132718Skan /* Look through the whole pending tree. 627218334Speter If we find an element that should be output now, 627318334Speter output it. Otherwise, set NEXT to the element 627418334Speter that comes first among those still pending. */ 6275132718Skan 627618334Speter next = 0; 627750397Sobrien while (elt) 627818334Speter { 627918334Speter if (TREE_CODE (constructor_type) == ARRAY_TYPE) 628018334Speter { 628150397Sobrien if (tree_int_cst_equal (elt->purpose, 628218334Speter constructor_unfilled_index)) 6283169689Skan output_init_element (elt->value, true, 628450397Sobrien TREE_TYPE (constructor_type), 628550397Sobrien constructor_unfilled_index, 0); 628650397Sobrien else if (tree_int_cst_lt (constructor_unfilled_index, 628750397Sobrien elt->purpose)) 628818334Speter { 628950397Sobrien /* Advance to the next smaller node. */ 629050397Sobrien if (elt->left) 629150397Sobrien elt = elt->left; 629250397Sobrien else 629350397Sobrien { 629450397Sobrien /* We have reached the smallest node bigger than the 629550397Sobrien current unfilled index. Fill the space first. */ 629650397Sobrien next = elt->purpose; 629750397Sobrien break; 629850397Sobrien } 629918334Speter } 630050397Sobrien else 630150397Sobrien { 630250397Sobrien /* Advance to the next bigger node. */ 630350397Sobrien if (elt->right) 630450397Sobrien elt = elt->right; 630550397Sobrien else 630650397Sobrien { 630750397Sobrien /* We have reached the biggest node in a subtree. Find 630850397Sobrien the parent of it, which is the next bigger node. */ 630950397Sobrien while (elt->parent && elt->parent->right == elt) 631050397Sobrien elt = elt->parent; 631150397Sobrien elt = elt->parent; 631250397Sobrien if (elt && tree_int_cst_lt (constructor_unfilled_index, 631350397Sobrien elt->purpose)) 631450397Sobrien { 631550397Sobrien next = elt->purpose; 631650397Sobrien break; 631750397Sobrien } 631850397Sobrien } 631950397Sobrien } 632018334Speter } 632118334Speter else if (TREE_CODE (constructor_type) == RECORD_TYPE 632218334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 632318334Speter { 632490075Sobrien tree ctor_unfilled_bitpos, elt_bitpos; 632590075Sobrien 632650397Sobrien /* If the current record is complete we are done. */ 632750397Sobrien if (constructor_unfilled_fields == 0) 632850397Sobrien break; 632990075Sobrien 633090075Sobrien ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields); 633190075Sobrien elt_bitpos = bit_position (elt->purpose); 633290075Sobrien /* We can't compare fields here because there might be empty 633390075Sobrien fields in between. */ 633490075Sobrien if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos)) 633518334Speter { 633690075Sobrien constructor_unfilled_fields = elt->purpose; 6337169689Skan output_init_element (elt->value, true, TREE_TYPE (elt->purpose), 633890075Sobrien elt->purpose, 0); 633918334Speter } 634090075Sobrien else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos)) 634150397Sobrien { 634250397Sobrien /* Advance to the next smaller node. */ 634350397Sobrien if (elt->left) 634450397Sobrien elt = elt->left; 634550397Sobrien else 634650397Sobrien { 634750397Sobrien /* We have reached the smallest node bigger than the 634850397Sobrien current unfilled field. Fill the space first. */ 634950397Sobrien next = elt->purpose; 635050397Sobrien break; 635150397Sobrien } 635250397Sobrien } 635350397Sobrien else 635450397Sobrien { 635550397Sobrien /* Advance to the next bigger node. */ 635650397Sobrien if (elt->right) 635750397Sobrien elt = elt->right; 635850397Sobrien else 635950397Sobrien { 636050397Sobrien /* We have reached the biggest node in a subtree. Find 636150397Sobrien the parent of it, which is the next bigger node. */ 636250397Sobrien while (elt->parent && elt->parent->right == elt) 636350397Sobrien elt = elt->parent; 636450397Sobrien elt = elt->parent; 636550397Sobrien if (elt 636690075Sobrien && (tree_int_cst_lt (ctor_unfilled_bitpos, 636790075Sobrien bit_position (elt->purpose)))) 636850397Sobrien { 636950397Sobrien next = elt->purpose; 637050397Sobrien break; 637150397Sobrien } 637250397Sobrien } 637350397Sobrien } 637418334Speter } 637518334Speter } 637618334Speter 637718334Speter /* Ordinarily return, but not if we want to output all 637818334Speter and there are elements left. */ 6379169689Skan if (!(all && next != 0)) 638018334Speter return; 638118334Speter 638290075Sobrien /* If it's not incremental, just skip over the gap, so that after 638390075Sobrien jumping to retry we will output the next successive element. */ 638490075Sobrien if (TREE_CODE (constructor_type) == RECORD_TYPE 638590075Sobrien || TREE_CODE (constructor_type) == UNION_TYPE) 638690075Sobrien constructor_unfilled_fields = next; 638790075Sobrien else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 638890075Sobrien constructor_unfilled_index = next; 638918334Speter 639050397Sobrien /* ELT now points to the node in the pending tree with the next 639150397Sobrien initializer to output. */ 639218334Speter goto retry; 639318334Speter} 639418334Speter 639518334Speter/* Add one non-braced element to the current constructor level. 639618334Speter This adjusts the current position within the constructor's type. 639718334Speter This may also start or terminate implicit levels 639818334Speter to handle a partly-braced initializer. 639918334Speter 640018334Speter Once this has found the correct level for the new element, 640190075Sobrien it calls output_init_element. */ 640218334Speter 640318334Spetervoid 6404169689Skanprocess_init_element (struct c_expr value) 640518334Speter{ 6406169689Skan tree orig_value = value.value; 6407169689Skan int string_flag = orig_value != 0 && TREE_CODE (orig_value) == STRING_CST; 6408169689Skan bool strict_string = value.original_code == STRING_CST; 640918334Speter 641090075Sobrien designator_depth = 0; 6411169689Skan designator_erroneous = 0; 641290075Sobrien 641318334Speter /* Handle superfluous braces around string cst as in 641418334Speter char x[] = {"foo"}; */ 641518334Speter if (string_flag 641618334Speter && constructor_type 641718334Speter && TREE_CODE (constructor_type) == ARRAY_TYPE 6418169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type)) 641918334Speter && integer_zerop (constructor_unfilled_index)) 642018334Speter { 6421169689Skan if (constructor_stack->replacement_value.value) 6422169689Skan error_init ("excess elements in char array initializer"); 642318334Speter constructor_stack->replacement_value = value; 642418334Speter return; 642518334Speter } 642618334Speter 6427169689Skan if (constructor_stack->replacement_value.value != 0) 642818334Speter { 642952284Sobrien error_init ("excess elements in struct initializer"); 643018334Speter return; 643118334Speter } 643218334Speter 643318334Speter /* Ignore elements of a brace group if it is entirely superfluous 643418334Speter and has already been diagnosed. */ 643518334Speter if (constructor_type == 0) 643618334Speter return; 643718334Speter 643818334Speter /* If we've exhausted any levels that didn't have braces, 643918334Speter pop them now. */ 644018334Speter while (constructor_stack->implicit) 644118334Speter { 644218334Speter if ((TREE_CODE (constructor_type) == RECORD_TYPE 644318334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 644418334Speter && constructor_fields == 0) 644518334Speter process_init_element (pop_init_level (1)); 644618334Speter else if (TREE_CODE (constructor_type) == ARRAY_TYPE 644750397Sobrien && (constructor_max_index == 0 644850397Sobrien || tree_int_cst_lt (constructor_max_index, 644950397Sobrien constructor_index))) 645018334Speter process_init_element (pop_init_level (1)); 645118334Speter else 645218334Speter break; 645318334Speter } 645418334Speter 645590075Sobrien /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */ 645690075Sobrien if (constructor_range_stack) 645790075Sobrien { 645890075Sobrien /* If value is a compound literal and we'll be just using its 645990075Sobrien content, don't put it into a SAVE_EXPR. */ 6460169689Skan if (TREE_CODE (value.value) != COMPOUND_LITERAL_EXPR 646190075Sobrien || !require_constant_value 646290075Sobrien || flag_isoc99) 6463169689Skan value.value = save_expr (value.value); 646490075Sobrien } 646590075Sobrien 646618334Speter while (1) 646718334Speter { 646818334Speter if (TREE_CODE (constructor_type) == RECORD_TYPE) 646918334Speter { 647018334Speter tree fieldtype; 647118334Speter enum tree_code fieldcode; 647218334Speter 647318334Speter if (constructor_fields == 0) 647418334Speter { 647552284Sobrien pedwarn_init ("excess elements in struct initializer"); 647618334Speter break; 647718334Speter } 647818334Speter 647918334Speter fieldtype = TREE_TYPE (constructor_fields); 648018334Speter if (fieldtype != error_mark_node) 648118334Speter fieldtype = TYPE_MAIN_VARIANT (fieldtype); 648218334Speter fieldcode = TREE_CODE (fieldtype); 648318334Speter 648496263Sobrien /* Error for non-static initialization of a flexible array member. */ 648596263Sobrien if (fieldcode == ARRAY_TYPE 648696263Sobrien && !require_constant_value 648796263Sobrien && TYPE_SIZE (fieldtype) == NULL_TREE 648896263Sobrien && TREE_CHAIN (constructor_fields) == NULL_TREE) 648996263Sobrien { 649096263Sobrien error_init ("non-static initialization of a flexible array member"); 649196263Sobrien break; 649296263Sobrien } 649396263Sobrien 649418334Speter /* Accept a string constant to initialize a subarray. */ 6495169689Skan if (value.value != 0 649618334Speter && fieldcode == ARRAY_TYPE 6497169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype)) 649818334Speter && string_flag) 6499169689Skan value.value = orig_value; 650018334Speter /* Otherwise, if we have come to a subaggregate, 650118334Speter and we don't have an element of its type, push into it. */ 6502169689Skan else if (value.value != 0 6503169689Skan && value.value != error_mark_node 6504169689Skan && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype 650518334Speter && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE 650618334Speter || fieldcode == UNION_TYPE)) 650718334Speter { 650818334Speter push_init_level (1); 650918334Speter continue; 651018334Speter } 651118334Speter 6512169689Skan if (value.value) 651318334Speter { 651418334Speter push_member_name (constructor_fields); 6515169689Skan output_init_element (value.value, strict_string, 6516169689Skan fieldtype, constructor_fields, 1); 651718334Speter RESTORE_SPELLING_DEPTH (constructor_depth); 651818334Speter } 651918334Speter else 652018334Speter /* Do the bookkeeping for an element that was 652118334Speter directly output as a constructor. */ 652218334Speter { 652318334Speter /* For a record, keep track of end position of last field. */ 652490075Sobrien if (DECL_SIZE (constructor_fields)) 6525169689Skan constructor_bit_index 652690075Sobrien = size_binop (PLUS_EXPR, 6527169689Skan bit_position (constructor_fields), 6528169689Skan DECL_SIZE (constructor_fields)); 652918334Speter 6530110611Skan /* If the current field was the first one not yet written out, 6531110611Skan it isn't now, so update. */ 6532110611Skan if (constructor_unfilled_fields == constructor_fields) 6533110611Skan { 6534110611Skan constructor_unfilled_fields = TREE_CHAIN (constructor_fields); 6535110611Skan /* Skip any nameless bit fields. */ 6536110611Skan while (constructor_unfilled_fields != 0 6537110611Skan && DECL_C_BIT_FIELD (constructor_unfilled_fields) 6538110611Skan && DECL_NAME (constructor_unfilled_fields) == 0) 6539110611Skan constructor_unfilled_fields = 6540110611Skan TREE_CHAIN (constructor_unfilled_fields); 6541110611Skan } 654218334Speter } 654318334Speter 654418334Speter constructor_fields = TREE_CHAIN (constructor_fields); 654518334Speter /* Skip any nameless bit fields at the beginning. */ 654650397Sobrien while (constructor_fields != 0 654750397Sobrien && DECL_C_BIT_FIELD (constructor_fields) 654818334Speter && DECL_NAME (constructor_fields) == 0) 654918334Speter constructor_fields = TREE_CHAIN (constructor_fields); 655018334Speter } 655190075Sobrien else if (TREE_CODE (constructor_type) == UNION_TYPE) 655218334Speter { 655318334Speter tree fieldtype; 655418334Speter enum tree_code fieldcode; 655518334Speter 655618334Speter if (constructor_fields == 0) 655718334Speter { 655852284Sobrien pedwarn_init ("excess elements in union initializer"); 655918334Speter break; 656018334Speter } 656118334Speter 656218334Speter fieldtype = TREE_TYPE (constructor_fields); 656318334Speter if (fieldtype != error_mark_node) 656418334Speter fieldtype = TYPE_MAIN_VARIANT (fieldtype); 656518334Speter fieldcode = TREE_CODE (fieldtype); 656618334Speter 656790075Sobrien /* Warn that traditional C rejects initialization of unions. 656890075Sobrien We skip the warning if the value is zero. This is done 656990075Sobrien under the assumption that the zero initializer in user 657090075Sobrien code appears conditioned on e.g. __STDC__ to avoid 657190075Sobrien "missing initializer" warnings and relies on default 657290075Sobrien initialization to zero in the traditional C case. 657390075Sobrien We also skip the warning if the initializer is designated, 657490075Sobrien again on the assumption that this must be conditional on 657590075Sobrien __STDC__ anyway (and we've already complained about the 657690075Sobrien member-designator already). */ 6577169689Skan if (!in_system_header && !constructor_designated 6578169689Skan && !(value.value && (integer_zerop (value.value) 6579169689Skan || real_zerop (value.value)))) 6580169689Skan warning (OPT_Wtraditional, "traditional C rejects initialization " 6581169689Skan "of unions"); 658290075Sobrien 658318334Speter /* Accept a string constant to initialize a subarray. */ 6584169689Skan if (value.value != 0 658518334Speter && fieldcode == ARRAY_TYPE 6586169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype)) 658718334Speter && string_flag) 6588169689Skan value.value = orig_value; 658918334Speter /* Otherwise, if we have come to a subaggregate, 659018334Speter and we don't have an element of its type, push into it. */ 6591169689Skan else if (value.value != 0 6592169689Skan && value.value != error_mark_node 6593169689Skan && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype 659418334Speter && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE 659518334Speter || fieldcode == UNION_TYPE)) 659618334Speter { 659718334Speter push_init_level (1); 659818334Speter continue; 659918334Speter } 660018334Speter 6601169689Skan if (value.value) 660218334Speter { 660318334Speter push_member_name (constructor_fields); 6604169689Skan output_init_element (value.value, strict_string, 6605169689Skan fieldtype, constructor_fields, 1); 660618334Speter RESTORE_SPELLING_DEPTH (constructor_depth); 660718334Speter } 660818334Speter else 660918334Speter /* Do the bookkeeping for an element that was 661018334Speter directly output as a constructor. */ 661118334Speter { 661290075Sobrien constructor_bit_index = DECL_SIZE (constructor_fields); 661318334Speter constructor_unfilled_fields = TREE_CHAIN (constructor_fields); 661418334Speter } 661518334Speter 661618334Speter constructor_fields = 0; 661718334Speter } 661890075Sobrien else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 661918334Speter { 662018334Speter tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type)); 662118334Speter enum tree_code eltcode = TREE_CODE (elttype); 662218334Speter 662318334Speter /* Accept a string constant to initialize a subarray. */ 6624169689Skan if (value.value != 0 662518334Speter && eltcode == ARRAY_TYPE 6626169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (elttype)) 662718334Speter && string_flag) 6628169689Skan value.value = orig_value; 662918334Speter /* Otherwise, if we have come to a subaggregate, 663018334Speter and we don't have an element of its type, push into it. */ 6631169689Skan else if (value.value != 0 6632169689Skan && value.value != error_mark_node 6633169689Skan && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != elttype 663418334Speter && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE 663518334Speter || eltcode == UNION_TYPE)) 663618334Speter { 663718334Speter push_init_level (1); 663818334Speter continue; 663918334Speter } 664018334Speter 664118334Speter if (constructor_max_index != 0 664290075Sobrien && (tree_int_cst_lt (constructor_max_index, constructor_index) 664390075Sobrien || integer_all_onesp (constructor_max_index))) 664418334Speter { 664552284Sobrien pedwarn_init ("excess elements in array initializer"); 664618334Speter break; 664718334Speter } 664818334Speter 664990075Sobrien /* Now output the actual element. */ 6650169689Skan if (value.value) 665150397Sobrien { 6652169689Skan push_array_bounds (tree_low_cst (constructor_index, 1)); 6653169689Skan output_init_element (value.value, strict_string, 6654169689Skan elttype, constructor_index, 1); 665590075Sobrien RESTORE_SPELLING_DEPTH (constructor_depth); 665650397Sobrien } 665750397Sobrien 665890075Sobrien constructor_index 665990075Sobrien = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node); 666018334Speter 6661169689Skan if (!value.value) 666290075Sobrien /* If we are doing the bookkeeping for an element that was 666390075Sobrien directly output as a constructor, we must update 666490075Sobrien constructor_unfilled_index. */ 666590075Sobrien constructor_unfilled_index = constructor_index; 666618334Speter } 666796263Sobrien else if (TREE_CODE (constructor_type) == VECTOR_TYPE) 666896263Sobrien { 666996263Sobrien tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type)); 667018334Speter 6671169689Skan /* Do a basic check of initializer size. Note that vectors 6672169689Skan always have a fixed size derived from their type. */ 667396263Sobrien if (tree_int_cst_lt (constructor_max_index, constructor_index)) 667496263Sobrien { 667596263Sobrien pedwarn_init ("excess elements in vector initializer"); 667696263Sobrien break; 667796263Sobrien } 667896263Sobrien 667996263Sobrien /* Now output the actual element. */ 6680169689Skan if (value.value) 6681169689Skan output_init_element (value.value, strict_string, 6682169689Skan elttype, constructor_index, 1); 668396263Sobrien 668496263Sobrien constructor_index 668596263Sobrien = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node); 668696263Sobrien 6687169689Skan if (!value.value) 668896263Sobrien /* If we are doing the bookkeeping for an element that was 668996263Sobrien directly output as a constructor, we must update 669096263Sobrien constructor_unfilled_index. */ 669196263Sobrien constructor_unfilled_index = constructor_index; 669296263Sobrien } 669396263Sobrien 669418334Speter /* Handle the sole element allowed in a braced initializer 669518334Speter for a scalar variable. */ 6696169689Skan else if (constructor_type != error_mark_node 6697169689Skan && constructor_fields == 0) 669818334Speter { 669952284Sobrien pedwarn_init ("excess elements in scalar initializer"); 670018334Speter break; 670118334Speter } 670290075Sobrien else 670390075Sobrien { 6704169689Skan if (value.value) 6705169689Skan output_init_element (value.value, strict_string, 6706169689Skan constructor_type, NULL_TREE, 1); 670790075Sobrien constructor_fields = 0; 670890075Sobrien } 670918334Speter 671090075Sobrien /* Handle range initializers either at this level or anywhere higher 671190075Sobrien in the designator stack. */ 671290075Sobrien if (constructor_range_stack) 671390075Sobrien { 671490075Sobrien struct constructor_range_stack *p, *range_stack; 671590075Sobrien int finish = 0; 671690075Sobrien 671790075Sobrien range_stack = constructor_range_stack; 671890075Sobrien constructor_range_stack = 0; 671990075Sobrien while (constructor_stack != range_stack->stack) 672090075Sobrien { 6721169689Skan gcc_assert (constructor_stack->implicit); 672290075Sobrien process_init_element (pop_init_level (1)); 672390075Sobrien } 672490075Sobrien for (p = range_stack; 672590075Sobrien !p->range_end || tree_int_cst_equal (p->index, p->range_end); 672690075Sobrien p = p->prev) 672790075Sobrien { 6728169689Skan gcc_assert (constructor_stack->implicit); 672990075Sobrien process_init_element (pop_init_level (1)); 673090075Sobrien } 673190075Sobrien 673290075Sobrien p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node); 673390075Sobrien if (tree_int_cst_equal (p->index, p->range_end) && !p->prev) 673490075Sobrien finish = 1; 673590075Sobrien 673690075Sobrien while (1) 673790075Sobrien { 673890075Sobrien constructor_index = p->index; 673990075Sobrien constructor_fields = p->fields; 674090075Sobrien if (finish && p->range_end && p->index == p->range_start) 674190075Sobrien { 674290075Sobrien finish = 0; 674390075Sobrien p->prev = 0; 674490075Sobrien } 674590075Sobrien p = p->next; 674690075Sobrien if (!p) 674790075Sobrien break; 674890075Sobrien push_init_level (2); 674990075Sobrien p->stack = constructor_stack; 675090075Sobrien if (p->range_end && tree_int_cst_equal (p->index, p->range_end)) 675190075Sobrien p->index = p->range_start; 675290075Sobrien } 675390075Sobrien 675490075Sobrien if (!finish) 675590075Sobrien constructor_range_stack = range_stack; 675690075Sobrien continue; 675790075Sobrien } 675890075Sobrien 675918334Speter break; 676018334Speter } 676118334Speter 676290075Sobrien constructor_range_stack = 0; 676318334Speter} 676418334Speter 6765169689Skan/* Build a complete asm-statement, whose components are a CV_QUALIFIER 6766169689Skan (guaranteed to be 'volatile' or null) and ARGS (represented using 6767169689Skan an ASM_EXPR node). */ 676890075Sobrientree 6769169689Skanbuild_asm_stmt (tree cv_qualifier, tree args) 677090075Sobrien{ 6771169689Skan if (!ASM_VOLATILE_P (args) && cv_qualifier) 6772169689Skan ASM_VOLATILE_P (args) = 1; 6773169689Skan return add_stmt (args); 677490075Sobrien} 677590075Sobrien 6776169689Skan/* Build an asm-expr, whose components are a STRING, some OUTPUTS, 6777169689Skan some INPUTS, and some CLOBBERS. The latter three may be NULL. 6778169689Skan SIMPLE indicates whether there was anything at all after the 6779169689Skan string in the asm expression -- asm("blah") and asm("blah" : ) 6780169689Skan are subtly different. We use a ASM_EXPR node to represent this. */ 678190075Sobrientree 6782169689Skanbuild_asm_expr (tree string, tree outputs, tree inputs, tree clobbers, 6783169689Skan bool simple) 678490075Sobrien{ 678590075Sobrien tree tail; 6786169689Skan tree args; 6787169689Skan int i; 6788169689Skan const char *constraint; 6789169689Skan const char **oconstraints; 6790169689Skan bool allows_mem, allows_reg, is_inout; 6791169689Skan int ninputs, noutputs; 679290075Sobrien 6793169689Skan ninputs = list_length (inputs); 6794169689Skan noutputs = list_length (outputs); 6795169689Skan oconstraints = (const char **) alloca (noutputs * sizeof (const char *)); 679690075Sobrien 6797169689Skan string = resolve_asm_operand_names (string, outputs, inputs); 679890075Sobrien 6799169689Skan /* Remove output conversions that change the type but not the mode. */ 6800169689Skan for (i = 0, tail = outputs; tail; ++i, tail = TREE_CHAIN (tail)) 680190075Sobrien { 680290075Sobrien tree output = TREE_VALUE (tail); 680390075Sobrien 6804169689Skan /* ??? Really, this should not be here. Users should be using a 6805169689Skan proper lvalue, dammit. But there's a long history of using casts 6806169689Skan in the output operands. In cases like longlong.h, this becomes a 6807169689Skan primitive form of typechecking -- if the cast can be removed, then 6808169689Skan the output operand had a type of the proper width; otherwise we'll 6809169689Skan get an error. Gross, but ... */ 681090075Sobrien STRIP_NOPS (output); 681190075Sobrien 6812169689Skan if (!lvalue_or_else (output, lv_asm)) 6813169689Skan output = error_mark_node; 681490075Sobrien 6815169689Skan if (output != error_mark_node 6816169689Skan && (TREE_READONLY (output) 6817169689Skan || TYPE_READONLY (TREE_TYPE (output)) 6818169689Skan || ((TREE_CODE (TREE_TYPE (output)) == RECORD_TYPE 6819169689Skan || TREE_CODE (TREE_TYPE (output)) == UNION_TYPE) 6820169689Skan && C_TYPE_FIELDS_READONLY (TREE_TYPE (output))))) 6821169689Skan readonly_error (output, lv_asm); 6822169689Skan 6823169689Skan constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail))); 6824169689Skan oconstraints[i] = constraint; 6825169689Skan 6826169689Skan if (parse_output_constraint (&constraint, i, ninputs, noutputs, 6827169689Skan &allows_mem, &allows_reg, &is_inout)) 6828169689Skan { 6829169689Skan /* If the operand is going to end up in memory, 6830169689Skan mark it addressable. */ 6831169689Skan if (!allows_reg && !c_mark_addressable (output)) 6832169689Skan output = error_mark_node; 6833169689Skan } 6834169689Skan else 6835169689Skan output = error_mark_node; 6836169689Skan 6837169689Skan TREE_VALUE (tail) = output; 683890075Sobrien } 683990075Sobrien 6840169689Skan for (i = 0, tail = inputs; tail; ++i, tail = TREE_CHAIN (tail)) 684190075Sobrien { 6842169689Skan tree input; 6843169689Skan 6844169689Skan constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail))); 6845169689Skan input = TREE_VALUE (tail); 6846169689Skan 6847169689Skan if (parse_input_constraint (&constraint, i, ninputs, noutputs, 0, 6848169689Skan oconstraints, &allows_mem, &allows_reg)) 6849169689Skan { 6850169689Skan /* If the operand is going to end up in memory, 6851169689Skan mark it addressable. */ 6852169689Skan if (!allows_reg && allows_mem) 6853169689Skan { 6854169689Skan /* Strip the nops as we allow this case. FIXME, this really 6855169689Skan should be rejected or made deprecated. */ 6856169689Skan STRIP_NOPS (input); 6857169689Skan if (!c_mark_addressable (input)) 6858169689Skan input = error_mark_node; 6859169689Skan } 6860169689Skan } 6861169689Skan else 6862169689Skan input = error_mark_node; 6863169689Skan 6864169689Skan TREE_VALUE (tail) = input; 686590075Sobrien } 686690075Sobrien 6867169689Skan args = build_stmt (ASM_EXPR, string, outputs, inputs, clobbers); 686890075Sobrien 6869169689Skan /* asm statements without outputs, including simple ones, are treated 6870169689Skan as volatile. */ 6871169689Skan ASM_INPUT_P (args) = simple; 6872169689Skan ASM_VOLATILE_P (args) = (noutputs == 0); 6873169689Skan 6874169689Skan return args; 687590075Sobrien} 6876169689Skan 6877169689Skan/* Generate a goto statement to LABEL. */ 687890075Sobrien 6879169689Skantree 6880169689Skanc_finish_goto_label (tree label) 688118334Speter{ 6882169689Skan tree decl = lookup_label (label); 6883169689Skan if (!decl) 6884169689Skan return NULL_TREE; 688518334Speter 6886169689Skan if (C_DECL_UNJUMPABLE_STMT_EXPR (decl)) 6887117395Skan { 6888169689Skan error ("jump into statement expression"); 6889169689Skan return NULL_TREE; 6890117395Skan } 689118334Speter 6892169689Skan if (C_DECL_UNJUMPABLE_VM (decl)) 6893169689Skan { 6894169689Skan error ("jump into scope of identifier with variably modified type"); 6895169689Skan return NULL_TREE; 6896169689Skan } 689718334Speter 6898169689Skan if (!C_DECL_UNDEFINABLE_STMT_EXPR (decl)) 689918334Speter { 6900169689Skan /* No jump from outside this statement expression context, so 6901169689Skan record that there is a jump from within this context. */ 6902169689Skan struct c_label_list *nlist; 6903169689Skan nlist = XOBNEW (&parser_obstack, struct c_label_list); 6904169689Skan nlist->next = label_context_stack_se->labels_used; 6905169689Skan nlist->label = decl; 6906169689Skan label_context_stack_se->labels_used = nlist; 6907169689Skan } 690890075Sobrien 6909169689Skan if (!C_DECL_UNDEFINABLE_VM (decl)) 6910169689Skan { 6911169689Skan /* No jump from outside this context context of identifiers with 6912169689Skan variably modified type, so record that there is a jump from 6913169689Skan within this context. */ 6914169689Skan struct c_label_list *nlist; 6915169689Skan nlist = XOBNEW (&parser_obstack, struct c_label_list); 6916169689Skan nlist->next = label_context_stack_vm->labels_used; 6917169689Skan nlist->label = decl; 6918169689Skan label_context_stack_vm->labels_used = nlist; 691918334Speter } 692018334Speter 6921169689Skan TREE_USED (decl) = 1; 6922169689Skan return add_stmt (build1 (GOTO_EXPR, void_type_node, decl)); 692318334Speter} 692418334Speter 6925169689Skan/* Generate a computed goto statement to EXPR. */ 6926169689Skan 692790075Sobrientree 6928169689Skanc_finish_goto_ptr (tree expr) 692918334Speter{ 6930169689Skan if (pedantic) 6931169689Skan pedwarn ("ISO C forbids %<goto *expr;%>"); 6932169689Skan expr = convert (ptr_type_node, expr); 6933169689Skan return add_stmt (build1 (GOTO_EXPR, void_type_node, expr)); 6934169689Skan} 693518334Speter 6936169689Skan/* Generate a C `return' statement. RETVAL is the expression for what 6937169689Skan to return, or a null pointer for `return;' with no value. */ 6938169689Skan 6939169689Skantree 6940169689Skanc_finish_return (tree retval) 6941169689Skan{ 6942169689Skan tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl)), ret_stmt; 6943169689Skan bool no_warning = false; 6944169689Skan 694518334Speter if (TREE_THIS_VOLATILE (current_function_decl)) 6946169689Skan warning (0, "function declared %<noreturn%> has a %<return%> statement"); 694718334Speter 694818334Speter if (!retval) 694918334Speter { 695018334Speter current_function_returns_null = 1; 695190075Sobrien if ((warn_return_type || flag_isoc99) 695290075Sobrien && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE) 6953169689Skan { 6954169689Skan pedwarn_c99 ("%<return%> with no value, in " 6955169689Skan "function returning non-void"); 6956169689Skan no_warning = true; 6957169689Skan } 695818334Speter } 695918334Speter else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE) 696018334Speter { 696118334Speter current_function_returns_null = 1; 696218334Speter if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE) 6963169689Skan pedwarn ("%<return%> with a value, in function returning void"); 696418334Speter } 696518334Speter else 696618334Speter { 6967169689Skan tree t = convert_for_assignment (valtype, retval, ic_return, 696818334Speter NULL_TREE, NULL_TREE, 0); 696918334Speter tree res = DECL_RESULT (current_function_decl); 697018334Speter tree inner; 697118334Speter 697296263Sobrien current_function_returns_value = 1; 697318334Speter if (t == error_mark_node) 697490075Sobrien return NULL_TREE; 697518334Speter 697618334Speter inner = t = convert (TREE_TYPE (res), t); 697718334Speter 697818334Speter /* Strip any conversions, additions, and subtractions, and see if 697918334Speter we are returning the address of a local variable. Warn if so. */ 698018334Speter while (1) 698118334Speter { 698218334Speter switch (TREE_CODE (inner)) 698318334Speter { 698418334Speter case NOP_EXPR: case NON_LVALUE_EXPR: case CONVERT_EXPR: 698518334Speter case PLUS_EXPR: 698618334Speter inner = TREE_OPERAND (inner, 0); 698718334Speter continue; 698818334Speter 698918334Speter case MINUS_EXPR: 699018334Speter /* If the second operand of the MINUS_EXPR has a pointer 699118334Speter type (or is converted from it), this may be valid, so 699218334Speter don't give a warning. */ 699318334Speter { 699418334Speter tree op1 = TREE_OPERAND (inner, 1); 699518334Speter 6996169689Skan while (!POINTER_TYPE_P (TREE_TYPE (op1)) 699718334Speter && (TREE_CODE (op1) == NOP_EXPR 699818334Speter || TREE_CODE (op1) == NON_LVALUE_EXPR 699918334Speter || TREE_CODE (op1) == CONVERT_EXPR)) 700018334Speter op1 = TREE_OPERAND (op1, 0); 700118334Speter 700218334Speter if (POINTER_TYPE_P (TREE_TYPE (op1))) 700318334Speter break; 700418334Speter 700518334Speter inner = TREE_OPERAND (inner, 0); 700618334Speter continue; 700718334Speter } 7008132718Skan 700918334Speter case ADDR_EXPR: 701018334Speter inner = TREE_OPERAND (inner, 0); 701118334Speter 7012169689Skan while (REFERENCE_CLASS_P (inner) 7013169689Skan && TREE_CODE (inner) != INDIRECT_REF) 701418334Speter inner = TREE_OPERAND (inner, 0); 701518334Speter 7016169689Skan if (DECL_P (inner) 7017169689Skan && !DECL_EXTERNAL (inner) 7018169689Skan && !TREE_STATIC (inner) 701918334Speter && DECL_CONTEXT (inner) == current_function_decl) 7020169689Skan warning (0, "function returns address of local variable"); 702118334Speter break; 702250397Sobrien 702350397Sobrien default: 702450397Sobrien break; 702518334Speter } 702618334Speter 702718334Speter break; 702818334Speter } 702918334Speter 7030169689Skan retval = build2 (MODIFY_EXPR, TREE_TYPE (res), res, t); 703118334Speter } 703290075Sobrien 7033169689Skan ret_stmt = build_stmt (RETURN_EXPR, retval); 7034169689Skan TREE_NO_WARNING (ret_stmt) |= no_warning; 7035169689Skan return add_stmt (ret_stmt); 703618334Speter} 703718334Speter 703890075Sobrienstruct c_switch { 7039169689Skan /* The SWITCH_EXPR being built. */ 7040169689Skan tree switch_expr; 7041169689Skan 7042169689Skan /* The original type of the testing expression, i.e. before the 7043169689Skan default conversion is applied. */ 7044169689Skan tree orig_type; 7045169689Skan 704690075Sobrien /* A splay-tree mapping the low element of a case range to the high 704790075Sobrien element, or NULL_TREE if there is no high element. Used to 704890075Sobrien determine whether or not a new case label duplicates an old case 704990075Sobrien label. We need a tree, rather than simply a hash table, because 705090075Sobrien of the GNU case range extension. */ 705190075Sobrien splay_tree cases; 7052169689Skan 7053169689Skan /* Number of nested statement expressions within this switch 7054169689Skan statement; if nonzero, case and default labels may not 7055169689Skan appear. */ 7056169689Skan unsigned int blocked_stmt_expr; 7057169689Skan 7058169689Skan /* Scope of outermost declarations of identifiers with variably 7059169689Skan modified type within this switch statement; if nonzero, case and 7060169689Skan default labels may not appear. */ 7061169689Skan unsigned int blocked_vm; 7062169689Skan 706390075Sobrien /* The next node on the stack. */ 706490075Sobrien struct c_switch *next; 706590075Sobrien}; 706618334Speter 706790075Sobrien/* A stack of the currently active switch statements. The innermost 706890075Sobrien switch statement is on the top of the stack. There is no need to 706990075Sobrien mark the stack for garbage collection because it is only active 707090075Sobrien during the processing of the body of a function, and we never 707190075Sobrien collect at that point. */ 707290075Sobrien 7073169689Skanstruct c_switch *c_switch_stack; 707490075Sobrien 707590075Sobrien/* Start a C switch statement, testing expression EXP. Return the new 7076169689Skan SWITCH_EXPR. */ 707790075Sobrien 707818334Spetertree 7079132718Skanc_start_case (tree exp) 708018334Speter{ 7081169689Skan tree orig_type = error_mark_node; 708290075Sobrien struct c_switch *cs; 708318334Speter 708490075Sobrien if (exp != error_mark_node) 708518334Speter { 708696263Sobrien orig_type = TREE_TYPE (exp); 708790075Sobrien 7088169689Skan if (!INTEGRAL_TYPE_P (orig_type)) 708990075Sobrien { 7090169689Skan if (orig_type != error_mark_node) 7091169689Skan { 7092169689Skan error ("switch quantity not an integer"); 7093169689Skan orig_type = error_mark_node; 7094169689Skan } 709590075Sobrien exp = integer_zero_node; 709690075Sobrien } 709790075Sobrien else 709890075Sobrien { 7099169689Skan tree type = TYPE_MAIN_VARIANT (orig_type); 710090075Sobrien 7101169689Skan if (!in_system_header 710290075Sobrien && (type == long_integer_type_node 710390075Sobrien || type == long_unsigned_type_node)) 7104169689Skan warning (OPT_Wtraditional, "%<long%> switch expression not " 7105169689Skan "converted to %<int%> in ISO C"); 710690075Sobrien 710790075Sobrien exp = default_conversion (exp); 710890075Sobrien } 710918334Speter } 711018334Speter 7111169689Skan /* Add this new SWITCH_EXPR to the stack. */ 7112169689Skan cs = XNEW (struct c_switch); 7113169689Skan cs->switch_expr = build3 (SWITCH_EXPR, orig_type, exp, NULL_TREE, NULL_TREE); 7114169689Skan cs->orig_type = orig_type; 711590075Sobrien cs->cases = splay_tree_new (case_compare, NULL, NULL); 7116169689Skan cs->blocked_stmt_expr = 0; 7117169689Skan cs->blocked_vm = 0; 7118169689Skan cs->next = c_switch_stack; 7119169689Skan c_switch_stack = cs; 712018334Speter 7121169689Skan return add_stmt (cs->switch_expr); 712290075Sobrien} 712390075Sobrien 712490075Sobrien/* Process a case label. */ 712590075Sobrien 712690075Sobrientree 7127132718Skando_case (tree low_value, tree high_value) 712890075Sobrien{ 712990075Sobrien tree label = NULL_TREE; 713090075Sobrien 7131169689Skan if (c_switch_stack && !c_switch_stack->blocked_stmt_expr 7132169689Skan && !c_switch_stack->blocked_vm) 713390075Sobrien { 7134169689Skan label = c_add_case_label (c_switch_stack->cases, 7135169689Skan SWITCH_COND (c_switch_stack->switch_expr), 7136169689Skan c_switch_stack->orig_type, 713790075Sobrien low_value, high_value); 713890075Sobrien if (label == error_mark_node) 713990075Sobrien label = NULL_TREE; 714018334Speter } 7141169689Skan else if (c_switch_stack && c_switch_stack->blocked_stmt_expr) 7142169689Skan { 7143169689Skan if (low_value) 7144169689Skan error ("case label in statement expression not containing " 7145169689Skan "enclosing switch statement"); 7146169689Skan else 7147169689Skan error ("%<default%> label in statement expression not containing " 7148169689Skan "enclosing switch statement"); 7149169689Skan } 7150169689Skan else if (c_switch_stack && c_switch_stack->blocked_vm) 7151169689Skan { 7152169689Skan if (low_value) 7153169689Skan error ("case label in scope of identifier with variably modified " 7154169689Skan "type not containing enclosing switch statement"); 7155169689Skan else 7156169689Skan error ("%<default%> label in scope of identifier with variably " 7157169689Skan "modified type not containing enclosing switch statement"); 7158169689Skan } 715990075Sobrien else if (low_value) 716090075Sobrien error ("case label not within a switch statement"); 716190075Sobrien else 7162169689Skan error ("%<default%> label not within a switch statement"); 716318334Speter 716490075Sobrien return label; 716590075Sobrien} 716618334Speter 716790075Sobrien/* Finish the switch statement. */ 716890075Sobrien 716990075Sobrienvoid 7170169689Skanc_finish_case (tree body) 717190075Sobrien{ 7172169689Skan struct c_switch *cs = c_switch_stack; 7173169689Skan location_t switch_location; 717490075Sobrien 7175169689Skan SWITCH_BODY (cs->switch_expr) = body; 7176146895Skan 7177169689Skan /* We must not be within a statement expression nested in the switch 7178169689Skan at this point; we might, however, be within the scope of an 7179169689Skan identifier with variably modified type nested in the switch. */ 7180169689Skan gcc_assert (!cs->blocked_stmt_expr); 718190075Sobrien 7182169689Skan /* Emit warnings as needed. */ 7183169689Skan if (EXPR_HAS_LOCATION (cs->switch_expr)) 7184169689Skan switch_location = EXPR_LOCATION (cs->switch_expr); 7185169689Skan else 7186169689Skan switch_location = input_location; 7187169689Skan c_do_switch_warnings (cs->cases, switch_location, 7188169689Skan TREE_TYPE (cs->switch_expr), 7189169689Skan SWITCH_COND (cs->switch_expr)); 7190169689Skan 719190075Sobrien /* Pop the stack. */ 7192169689Skan c_switch_stack = cs->next; 719390075Sobrien splay_tree_delete (cs->cases); 7194169689Skan XDELETE (cs); 719518334Speter} 7196169689Skan 7197169689Skan/* Emit an if statement. IF_LOCUS is the location of the 'if'. COND, 7198169689Skan THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK 7199169689Skan may be null. NESTED_IF is true if THEN_BLOCK contains another IF 7200169689Skan statement, and was not surrounded with parenthesis. */ 7201132718Skan 7202169689Skanvoid 7203169689Skanc_finish_if_stmt (location_t if_locus, tree cond, tree then_block, 7204169689Skan tree else_block, bool nested_if) 7205169689Skan{ 7206169689Skan tree stmt; 7207169689Skan 7208169689Skan /* Diagnose an ambiguous else if if-then-else is nested inside if-then. */ 7209169689Skan if (warn_parentheses && nested_if && else_block == NULL) 7210169689Skan { 7211169689Skan tree inner_if = then_block; 7212169689Skan 7213169689Skan /* We know from the grammar productions that there is an IF nested 7214169689Skan within THEN_BLOCK. Due to labels and c99 conditional declarations, 7215169689Skan it might not be exactly THEN_BLOCK, but should be the last 7216169689Skan non-container statement within. */ 7217169689Skan while (1) 7218169689Skan switch (TREE_CODE (inner_if)) 7219169689Skan { 7220169689Skan case COND_EXPR: 7221169689Skan goto found; 7222169689Skan case BIND_EXPR: 7223169689Skan inner_if = BIND_EXPR_BODY (inner_if); 7224169689Skan break; 7225169689Skan case STATEMENT_LIST: 7226169689Skan inner_if = expr_last (then_block); 7227169689Skan break; 7228169689Skan case TRY_FINALLY_EXPR: 7229169689Skan case TRY_CATCH_EXPR: 7230169689Skan inner_if = TREE_OPERAND (inner_if, 0); 7231169689Skan break; 7232169689Skan default: 7233169689Skan gcc_unreachable (); 7234169689Skan } 7235169689Skan found: 7236169689Skan 7237169689Skan if (COND_EXPR_ELSE (inner_if)) 7238169689Skan warning (OPT_Wparentheses, 7239169689Skan "%Hsuggest explicit braces to avoid ambiguous %<else%>", 7240169689Skan &if_locus); 7241169689Skan } 7242169689Skan 7243169689Skan empty_body_warning (then_block, else_block); 7244169689Skan 7245169689Skan stmt = build3 (COND_EXPR, void_type_node, cond, then_block, else_block); 7246169689Skan SET_EXPR_LOCATION (stmt, if_locus); 7247169689Skan add_stmt (stmt); 7248169689Skan} 7249169689Skan 7250169689Skan/* Emit a general-purpose loop construct. START_LOCUS is the location of 7251169689Skan the beginning of the loop. COND is the loop condition. COND_IS_FIRST 7252169689Skan is false for DO loops. INCR is the FOR increment expression. BODY is 7253169689Skan the statement controlled by the loop. BLAB is the break label. CLAB is 7254169689Skan the continue label. Everything is allowed to be NULL. */ 7255169689Skan 7256169689Skanvoid 7257169689Skanc_finish_loop (location_t start_locus, tree cond, tree incr, tree body, 7258169689Skan tree blab, tree clab, bool cond_is_first) 7259169689Skan{ 7260169689Skan tree entry = NULL, exit = NULL, t; 7261169689Skan 7262169689Skan /* If the condition is zero don't generate a loop construct. */ 7263169689Skan if (cond && integer_zerop (cond)) 7264169689Skan { 7265169689Skan if (cond_is_first) 7266169689Skan { 7267169689Skan t = build_and_jump (&blab); 7268169689Skan SET_EXPR_LOCATION (t, start_locus); 7269169689Skan add_stmt (t); 7270169689Skan } 7271169689Skan } 7272169689Skan else 7273169689Skan { 7274169689Skan tree top = build1 (LABEL_EXPR, void_type_node, NULL_TREE); 7275169689Skan 7276169689Skan /* If we have an exit condition, then we build an IF with gotos either 7277169689Skan out of the loop, or to the top of it. If there's no exit condition, 7278169689Skan then we just build a jump back to the top. */ 7279169689Skan exit = build_and_jump (&LABEL_EXPR_LABEL (top)); 7280169689Skan 7281169689Skan if (cond && !integer_nonzerop (cond)) 7282169689Skan { 7283169689Skan /* Canonicalize the loop condition to the end. This means 7284169689Skan generating a branch to the loop condition. Reuse the 7285169689Skan continue label, if possible. */ 7286169689Skan if (cond_is_first) 7287169689Skan { 7288169689Skan if (incr || !clab) 7289169689Skan { 7290169689Skan entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE); 7291169689Skan t = build_and_jump (&LABEL_EXPR_LABEL (entry)); 7292169689Skan } 7293169689Skan else 7294169689Skan t = build1 (GOTO_EXPR, void_type_node, clab); 7295169689Skan SET_EXPR_LOCATION (t, start_locus); 7296169689Skan add_stmt (t); 7297169689Skan } 7298169689Skan 7299169689Skan t = build_and_jump (&blab); 7300169689Skan exit = fold_build3 (COND_EXPR, void_type_node, cond, exit, t); 7301169689Skan if (cond_is_first) 7302169689Skan SET_EXPR_LOCATION (exit, start_locus); 7303169689Skan else 7304169689Skan SET_EXPR_LOCATION (exit, input_location); 7305169689Skan } 7306169689Skan 7307169689Skan add_stmt (top); 7308169689Skan } 7309169689Skan 7310169689Skan if (body) 7311169689Skan add_stmt (body); 7312169689Skan if (clab) 7313169689Skan add_stmt (build1 (LABEL_EXPR, void_type_node, clab)); 7314169689Skan if (incr) 7315169689Skan add_stmt (incr); 7316169689Skan if (entry) 7317169689Skan add_stmt (entry); 7318169689Skan if (exit) 7319169689Skan add_stmt (exit); 7320169689Skan if (blab) 7321169689Skan add_stmt (build1 (LABEL_EXPR, void_type_node, blab)); 7322169689Skan} 7323169689Skan 7324169689Skantree 7325169689Skanc_finish_bc_stmt (tree *label_p, bool is_break) 7326169689Skan{ 7327169689Skan bool skip; 7328169689Skan tree label = *label_p; 7329169689Skan 7330169689Skan /* In switch statements break is sometimes stylistically used after 7331169689Skan a return statement. This can lead to spurious warnings about 7332169689Skan control reaching the end of a non-void function when it is 7333169689Skan inlined. Note that we are calling block_may_fallthru with 7334169689Skan language specific tree nodes; this works because 7335169689Skan block_may_fallthru returns true when given something it does not 7336169689Skan understand. */ 7337169689Skan skip = !block_may_fallthru (cur_stmt_list); 7338169689Skan 7339169689Skan if (!label) 7340169689Skan { 7341169689Skan if (!skip) 7342169689Skan *label_p = label = create_artificial_label (); 7343169689Skan } 7344169689Skan else if (TREE_CODE (label) == LABEL_DECL) 7345169689Skan ; 7346169689Skan else switch (TREE_INT_CST_LOW (label)) 7347169689Skan { 7348169689Skan case 0: 7349169689Skan if (is_break) 7350169689Skan error ("break statement not within loop or switch"); 7351169689Skan else 7352169689Skan error ("continue statement not within a loop"); 7353169689Skan return NULL_TREE; 7354169689Skan 7355169689Skan case 1: 7356169689Skan gcc_assert (is_break); 7357169689Skan error ("break statement used with OpenMP for loop"); 7358169689Skan return NULL_TREE; 7359169689Skan 7360169689Skan default: 7361169689Skan gcc_unreachable (); 7362169689Skan } 7363169689Skan 7364169689Skan if (skip) 7365169689Skan return NULL_TREE; 7366169689Skan 7367169689Skan return add_stmt (build1 (GOTO_EXPR, void_type_node, label)); 7368169689Skan} 7369169689Skan 7370169689Skan/* A helper routine for c_process_expr_stmt and c_finish_stmt_expr. */ 7371169689Skan 7372169689Skanstatic void 7373169689Skanemit_side_effect_warnings (tree expr) 7374169689Skan{ 7375169689Skan if (expr == error_mark_node) 7376169689Skan ; 7377169689Skan else if (!TREE_SIDE_EFFECTS (expr)) 7378169689Skan { 7379169689Skan if (!VOID_TYPE_P (TREE_TYPE (expr)) && !TREE_NO_WARNING (expr)) 7380169689Skan warning (0, "%Hstatement with no effect", 7381169689Skan EXPR_HAS_LOCATION (expr) ? EXPR_LOCUS (expr) : &input_location); 7382169689Skan } 7383169689Skan else if (warn_unused_value) 7384169689Skan warn_if_unused_value (expr, input_location); 7385169689Skan} 7386169689Skan 7387169689Skan/* Process an expression as if it were a complete statement. Emit 7388169689Skan diagnostics, but do not call ADD_STMT. */ 7389169689Skan 7390169689Skantree 7391169689Skanc_process_expr_stmt (tree expr) 7392169689Skan{ 7393169689Skan if (!expr) 7394169689Skan return NULL_TREE; 7395169689Skan 7396169689Skan if (warn_sequence_point) 7397169689Skan verify_sequence_points (expr); 7398169689Skan 7399169689Skan if (TREE_TYPE (expr) != error_mark_node 7400169689Skan && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr)) 7401169689Skan && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE) 7402169689Skan error ("expression statement has incomplete type"); 7403169689Skan 7404169689Skan /* If we're not processing a statement expression, warn about unused values. 7405169689Skan Warnings for statement expressions will be emitted later, once we figure 7406169689Skan out which is the result. */ 7407169689Skan if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list) 7408169689Skan && (extra_warnings || warn_unused_value)) 7409169689Skan emit_side_effect_warnings (expr); 7410169689Skan 7411169689Skan /* If the expression is not of a type to which we cannot assign a line 7412169689Skan number, wrap the thing in a no-op NOP_EXPR. */ 7413169689Skan if (DECL_P (expr) || CONSTANT_CLASS_P (expr)) 7414169689Skan expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr); 7415169689Skan 7416169689Skan if (EXPR_P (expr)) 7417169689Skan SET_EXPR_LOCATION (expr, input_location); 7418169689Skan 7419169689Skan return expr; 7420169689Skan} 7421169689Skan 7422169689Skan/* Emit an expression as a statement. */ 7423169689Skan 7424169689Skantree 7425169689Skanc_finish_expr_stmt (tree expr) 7426169689Skan{ 7427169689Skan if (expr) 7428169689Skan return add_stmt (c_process_expr_stmt (expr)); 7429169689Skan else 7430169689Skan return NULL; 7431169689Skan} 7432169689Skan 7433169689Skan/* Do the opposite and emit a statement as an expression. To begin, 7434169689Skan create a new binding level and return it. */ 7435169689Skan 7436169689Skantree 7437169689Skanc_begin_stmt_expr (void) 7438169689Skan{ 7439169689Skan tree ret; 7440169689Skan struct c_label_context_se *nstack; 7441169689Skan struct c_label_list *glist; 7442169689Skan 7443169689Skan /* We must force a BLOCK for this level so that, if it is not expanded 7444169689Skan later, there is a way to turn off the entire subtree of blocks that 7445169689Skan are contained in it. */ 7446169689Skan keep_next_level (); 7447169689Skan ret = c_begin_compound_stmt (true); 7448169689Skan if (c_switch_stack) 7449169689Skan { 7450169689Skan c_switch_stack->blocked_stmt_expr++; 7451169689Skan gcc_assert (c_switch_stack->blocked_stmt_expr != 0); 7452169689Skan } 7453169689Skan for (glist = label_context_stack_se->labels_used; 7454169689Skan glist != NULL; 7455169689Skan glist = glist->next) 7456169689Skan { 7457169689Skan C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 1; 7458169689Skan } 7459169689Skan nstack = XOBNEW (&parser_obstack, struct c_label_context_se); 7460169689Skan nstack->labels_def = NULL; 7461169689Skan nstack->labels_used = NULL; 7462169689Skan nstack->next = label_context_stack_se; 7463169689Skan label_context_stack_se = nstack; 7464169689Skan 7465169689Skan /* Mark the current statement list as belonging to a statement list. */ 7466169689Skan STATEMENT_LIST_STMT_EXPR (ret) = 1; 7467169689Skan 7468169689Skan return ret; 7469169689Skan} 7470169689Skan 7471169689Skantree 7472169689Skanc_finish_stmt_expr (tree body) 7473169689Skan{ 7474169689Skan tree last, type, tmp, val; 7475169689Skan tree *last_p; 7476169689Skan struct c_label_list *dlist, *glist, *glist_prev = NULL; 7477169689Skan 7478169689Skan body = c_end_compound_stmt (body, true); 7479169689Skan if (c_switch_stack) 7480169689Skan { 7481169689Skan gcc_assert (c_switch_stack->blocked_stmt_expr != 0); 7482169689Skan c_switch_stack->blocked_stmt_expr--; 7483169689Skan } 7484169689Skan /* It is no longer possible to jump to labels defined within this 7485169689Skan statement expression. */ 7486169689Skan for (dlist = label_context_stack_se->labels_def; 7487169689Skan dlist != NULL; 7488169689Skan dlist = dlist->next) 7489169689Skan { 7490169689Skan C_DECL_UNJUMPABLE_STMT_EXPR (dlist->label) = 1; 7491169689Skan } 7492169689Skan /* It is again possible to define labels with a goto just outside 7493169689Skan this statement expression. */ 7494169689Skan for (glist = label_context_stack_se->next->labels_used; 7495169689Skan glist != NULL; 7496169689Skan glist = glist->next) 7497169689Skan { 7498169689Skan C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 0; 7499169689Skan glist_prev = glist; 7500169689Skan } 7501169689Skan if (glist_prev != NULL) 7502169689Skan glist_prev->next = label_context_stack_se->labels_used; 7503169689Skan else 7504169689Skan label_context_stack_se->next->labels_used 7505169689Skan = label_context_stack_se->labels_used; 7506169689Skan label_context_stack_se = label_context_stack_se->next; 7507169689Skan 7508169689Skan /* Locate the last statement in BODY. See c_end_compound_stmt 7509169689Skan about always returning a BIND_EXPR. */ 7510169689Skan last_p = &BIND_EXPR_BODY (body); 7511169689Skan last = BIND_EXPR_BODY (body); 7512169689Skan 7513169689Skan continue_searching: 7514169689Skan if (TREE_CODE (last) == STATEMENT_LIST) 7515169689Skan { 7516169689Skan tree_stmt_iterator i; 7517169689Skan 7518169689Skan /* This can happen with degenerate cases like ({ }). No value. */ 7519169689Skan if (!TREE_SIDE_EFFECTS (last)) 7520169689Skan return body; 7521169689Skan 7522169689Skan /* If we're supposed to generate side effects warnings, process 7523169689Skan all of the statements except the last. */ 7524169689Skan if (extra_warnings || warn_unused_value) 7525169689Skan { 7526169689Skan for (i = tsi_start (last); !tsi_one_before_end_p (i); tsi_next (&i)) 7527169689Skan emit_side_effect_warnings (tsi_stmt (i)); 7528169689Skan } 7529169689Skan else 7530169689Skan i = tsi_last (last); 7531169689Skan last_p = tsi_stmt_ptr (i); 7532169689Skan last = *last_p; 7533169689Skan } 7534169689Skan 7535169689Skan /* If the end of the list is exception related, then the list was split 7536169689Skan by a call to push_cleanup. Continue searching. */ 7537169689Skan if (TREE_CODE (last) == TRY_FINALLY_EXPR 7538169689Skan || TREE_CODE (last) == TRY_CATCH_EXPR) 7539169689Skan { 7540169689Skan last_p = &TREE_OPERAND (last, 0); 7541169689Skan last = *last_p; 7542169689Skan goto continue_searching; 7543169689Skan } 7544169689Skan 7545169689Skan /* In the case that the BIND_EXPR is not necessary, return the 7546169689Skan expression out from inside it. */ 7547169689Skan if (last == error_mark_node 7548169689Skan || (last == BIND_EXPR_BODY (body) 7549169689Skan && BIND_EXPR_VARS (body) == NULL)) 7550169689Skan { 7551169689Skan /* Do not warn if the return value of a statement expression is 7552169689Skan unused. */ 7553169689Skan if (EXPR_P (last)) 7554169689Skan TREE_NO_WARNING (last) = 1; 7555169689Skan return last; 7556169689Skan } 7557169689Skan 7558169689Skan /* Extract the type of said expression. */ 7559169689Skan type = TREE_TYPE (last); 7560169689Skan 7561169689Skan /* If we're not returning a value at all, then the BIND_EXPR that 7562169689Skan we already have is a fine expression to return. */ 7563169689Skan if (!type || VOID_TYPE_P (type)) 7564169689Skan return body; 7565169689Skan 7566169689Skan /* Now that we've located the expression containing the value, it seems 7567169689Skan silly to make voidify_wrapper_expr repeat the process. Create a 7568169689Skan temporary of the appropriate type and stick it in a TARGET_EXPR. */ 7569169689Skan tmp = create_tmp_var_raw (type, NULL); 7570169689Skan 7571169689Skan /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt. This avoids 7572169689Skan tree_expr_nonnegative_p giving up immediately. */ 7573169689Skan val = last; 7574169689Skan if (TREE_CODE (val) == NOP_EXPR 7575169689Skan && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0))) 7576169689Skan val = TREE_OPERAND (val, 0); 7577169689Skan 7578169689Skan *last_p = build2 (MODIFY_EXPR, void_type_node, tmp, val); 7579169689Skan SET_EXPR_LOCUS (*last_p, EXPR_LOCUS (last)); 7580169689Skan 7581169689Skan return build4 (TARGET_EXPR, type, tmp, body, NULL_TREE, NULL_TREE); 7582169689Skan} 7583169689Skan 7584169689Skan/* Begin the scope of an identifier of variably modified type, scope 7585169689Skan number SCOPE. Jumping from outside this scope to inside it is not 7586169689Skan permitted. */ 7587169689Skan 7588169689Skanvoid 7589169689Skanc_begin_vm_scope (unsigned int scope) 7590169689Skan{ 7591169689Skan struct c_label_context_vm *nstack; 7592169689Skan struct c_label_list *glist; 7593169689Skan 7594169689Skan gcc_assert (scope > 0); 7595169689Skan 7596169689Skan /* At file_scope, we don't have to do any processing. */ 7597169689Skan if (label_context_stack_vm == NULL) 7598169689Skan return; 7599169689Skan 7600169689Skan if (c_switch_stack && !c_switch_stack->blocked_vm) 7601169689Skan c_switch_stack->blocked_vm = scope; 7602169689Skan for (glist = label_context_stack_vm->labels_used; 7603169689Skan glist != NULL; 7604169689Skan glist = glist->next) 7605169689Skan { 7606169689Skan C_DECL_UNDEFINABLE_VM (glist->label) = 1; 7607169689Skan } 7608169689Skan nstack = XOBNEW (&parser_obstack, struct c_label_context_vm); 7609169689Skan nstack->labels_def = NULL; 7610169689Skan nstack->labels_used = NULL; 7611169689Skan nstack->scope = scope; 7612169689Skan nstack->next = label_context_stack_vm; 7613169689Skan label_context_stack_vm = nstack; 7614169689Skan} 7615169689Skan 7616169689Skan/* End a scope which may contain identifiers of variably modified 7617169689Skan type, scope number SCOPE. */ 7618169689Skan 7619169689Skanvoid 7620169689Skanc_end_vm_scope (unsigned int scope) 7621169689Skan{ 7622169689Skan if (label_context_stack_vm == NULL) 7623169689Skan return; 7624169689Skan if (c_switch_stack && c_switch_stack->blocked_vm == scope) 7625169689Skan c_switch_stack->blocked_vm = 0; 7626169689Skan /* We may have a number of nested scopes of identifiers with 7627169689Skan variably modified type, all at this depth. Pop each in turn. */ 7628169689Skan while (label_context_stack_vm->scope == scope) 7629169689Skan { 7630169689Skan struct c_label_list *dlist, *glist, *glist_prev = NULL; 7631169689Skan 7632169689Skan /* It is no longer possible to jump to labels defined within this 7633169689Skan scope. */ 7634169689Skan for (dlist = label_context_stack_vm->labels_def; 7635169689Skan dlist != NULL; 7636169689Skan dlist = dlist->next) 7637169689Skan { 7638169689Skan C_DECL_UNJUMPABLE_VM (dlist->label) = 1; 7639169689Skan } 7640169689Skan /* It is again possible to define labels with a goto just outside 7641169689Skan this scope. */ 7642169689Skan for (glist = label_context_stack_vm->next->labels_used; 7643169689Skan glist != NULL; 7644169689Skan glist = glist->next) 7645169689Skan { 7646169689Skan C_DECL_UNDEFINABLE_VM (glist->label) = 0; 7647169689Skan glist_prev = glist; 7648169689Skan } 7649169689Skan if (glist_prev != NULL) 7650169689Skan glist_prev->next = label_context_stack_vm->labels_used; 7651169689Skan else 7652169689Skan label_context_stack_vm->next->labels_used 7653169689Skan = label_context_stack_vm->labels_used; 7654169689Skan label_context_stack_vm = label_context_stack_vm->next; 7655169689Skan } 7656169689Skan} 7657169689Skan 7658169689Skan/* Begin and end compound statements. This is as simple as pushing 7659169689Skan and popping new statement lists from the tree. */ 7660169689Skan 7661169689Skantree 7662169689Skanc_begin_compound_stmt (bool do_scope) 7663169689Skan{ 7664169689Skan tree stmt = push_stmt_list (); 7665169689Skan if (do_scope) 7666169689Skan push_scope (); 7667169689Skan return stmt; 7668169689Skan} 7669169689Skan 7670169689Skantree 7671169689Skanc_end_compound_stmt (tree stmt, bool do_scope) 7672169689Skan{ 7673169689Skan tree block = NULL; 7674169689Skan 7675169689Skan if (do_scope) 7676169689Skan { 7677169689Skan if (c_dialect_objc ()) 7678169689Skan objc_clear_super_receiver (); 7679169689Skan block = pop_scope (); 7680169689Skan } 7681169689Skan 7682169689Skan stmt = pop_stmt_list (stmt); 7683169689Skan stmt = c_build_bind_expr (block, stmt); 7684169689Skan 7685169689Skan /* If this compound statement is nested immediately inside a statement 7686169689Skan expression, then force a BIND_EXPR to be created. Otherwise we'll 7687169689Skan do the wrong thing for ({ { 1; } }) or ({ 1; { } }). In particular, 7688169689Skan STATEMENT_LISTs merge, and thus we can lose track of what statement 7689169689Skan was really last. */ 7690169689Skan if (cur_stmt_list 7691169689Skan && STATEMENT_LIST_STMT_EXPR (cur_stmt_list) 7692169689Skan && TREE_CODE (stmt) != BIND_EXPR) 7693169689Skan { 7694169689Skan stmt = build3 (BIND_EXPR, void_type_node, NULL, stmt, NULL); 7695169689Skan TREE_SIDE_EFFECTS (stmt) = 1; 7696169689Skan } 7697169689Skan 7698169689Skan return stmt; 7699169689Skan} 7700169689Skan 7701169689Skan/* Queue a cleanup. CLEANUP is an expression/statement to be executed 7702169689Skan when the current scope is exited. EH_ONLY is true when this is not 7703169689Skan meant to apply to normal control flow transfer. */ 7704169689Skan 7705169689Skanvoid 7706169689Skanpush_cleanup (tree ARG_UNUSED (decl), tree cleanup, bool eh_only) 7707169689Skan{ 7708169689Skan enum tree_code code; 7709169689Skan tree stmt, list; 7710169689Skan bool stmt_expr; 7711169689Skan 7712169689Skan code = eh_only ? TRY_CATCH_EXPR : TRY_FINALLY_EXPR; 7713169689Skan stmt = build_stmt (code, NULL, cleanup); 7714169689Skan add_stmt (stmt); 7715169689Skan stmt_expr = STATEMENT_LIST_STMT_EXPR (cur_stmt_list); 7716169689Skan list = push_stmt_list (); 7717169689Skan TREE_OPERAND (stmt, 0) = list; 7718169689Skan STATEMENT_LIST_STMT_EXPR (list) = stmt_expr; 7719169689Skan} 7720169689Skan 7721132718Skan/* Build a binary-operation expression without default conversions. 7722132718Skan CODE is the kind of expression to build. 7723132718Skan This function differs from `build' in several ways: 7724132718Skan the data type of the result is computed and recorded in it, 7725132718Skan warnings are generated if arg data types are invalid, 7726132718Skan special handling for addition and subtraction of pointers is known, 7727132718Skan and some optimization is done (operations on narrow ints 7728132718Skan are done in the narrower type when that gives the same result). 7729132718Skan Constant folding is also done before the result is returned. 7730132718Skan 7731132718Skan Note that the operands will never have enumeral types, or function 7732132718Skan or array types, because either they will have the default conversions 7733132718Skan performed or they have both just been converted to some other type in which 7734132718Skan the arithmetic is to be done. */ 7735132718Skan 7736132718Skantree 7737132718Skanbuild_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, 7738132718Skan int convert_p) 7739132718Skan{ 7740132718Skan tree type0, type1; 7741132718Skan enum tree_code code0, code1; 7742132718Skan tree op0, op1; 7743169689Skan const char *invalid_op_diag; 7744132718Skan 7745132718Skan /* Expression code to give to the expression when it is built. 7746132718Skan Normally this is CODE, which is what the caller asked for, 7747132718Skan but in some special cases we change it. */ 7748132718Skan enum tree_code resultcode = code; 7749132718Skan 7750132718Skan /* Data type in which the computation is to be performed. 7751132718Skan In the simplest cases this is the common type of the arguments. */ 7752132718Skan tree result_type = NULL; 7753132718Skan 7754132718Skan /* Nonzero means operands have already been type-converted 7755132718Skan in whatever way is necessary. 7756132718Skan Zero means they need to be converted to RESULT_TYPE. */ 7757132718Skan int converted = 0; 7758132718Skan 7759132718Skan /* Nonzero means create the expression with this type, rather than 7760132718Skan RESULT_TYPE. */ 7761132718Skan tree build_type = 0; 7762132718Skan 7763132718Skan /* Nonzero means after finally constructing the expression 7764132718Skan convert it to this type. */ 7765132718Skan tree final_type = 0; 7766132718Skan 7767132718Skan /* Nonzero if this is an operation like MIN or MAX which can 7768132718Skan safely be computed in short if both args are promoted shorts. 7769132718Skan Also implies COMMON. 7770132718Skan -1 indicates a bitwise operation; this makes a difference 7771132718Skan in the exact conditions for when it is safe to do the operation 7772132718Skan in a narrower mode. */ 7773132718Skan int shorten = 0; 7774132718Skan 7775132718Skan /* Nonzero if this is a comparison operation; 7776132718Skan if both args are promoted shorts, compare the original shorts. 7777132718Skan Also implies COMMON. */ 7778132718Skan int short_compare = 0; 7779132718Skan 7780132718Skan /* Nonzero if this is a right-shift operation, which can be computed on the 7781132718Skan original short and then promoted if the operand is a promoted short. */ 7782132718Skan int short_shift = 0; 7783132718Skan 7784132718Skan /* Nonzero means set RESULT_TYPE to the common type of the args. */ 7785132718Skan int common = 0; 7786132718Skan 7787169689Skan /* True means types are compatible as far as ObjC is concerned. */ 7788169689Skan bool objc_ok; 7789169689Skan 7790132718Skan if (convert_p) 7791132718Skan { 7792132718Skan op0 = default_conversion (orig_op0); 7793132718Skan op1 = default_conversion (orig_op1); 7794132718Skan } 7795132718Skan else 7796132718Skan { 7797132718Skan op0 = orig_op0; 7798132718Skan op1 = orig_op1; 7799132718Skan } 7800132718Skan 7801132718Skan type0 = TREE_TYPE (op0); 7802132718Skan type1 = TREE_TYPE (op1); 7803132718Skan 7804132718Skan /* The expression codes of the data types of the arguments tell us 7805132718Skan whether the arguments are integers, floating, pointers, etc. */ 7806132718Skan code0 = TREE_CODE (type0); 7807132718Skan code1 = TREE_CODE (type1); 7808132718Skan 7809132718Skan /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */ 7810132718Skan STRIP_TYPE_NOPS (op0); 7811132718Skan STRIP_TYPE_NOPS (op1); 7812132718Skan 7813132718Skan /* If an error was already reported for one of the arguments, 7814132718Skan avoid reporting another error. */ 7815132718Skan 7816132718Skan if (code0 == ERROR_MARK || code1 == ERROR_MARK) 7817132718Skan return error_mark_node; 7818132718Skan 7819169689Skan if ((invalid_op_diag 7820169689Skan = targetm.invalid_binary_op (code, type0, type1))) 7821169689Skan { 7822169689Skan error (invalid_op_diag); 7823169689Skan return error_mark_node; 7824169689Skan } 7825169689Skan 7826169689Skan objc_ok = objc_compare_types (type0, type1, -3, NULL_TREE); 7827169689Skan 7828132718Skan switch (code) 7829132718Skan { 7830132718Skan case PLUS_EXPR: 7831132718Skan /* Handle the pointer + int case. */ 7832132718Skan if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 7833132718Skan return pointer_int_sum (PLUS_EXPR, op0, op1); 7834132718Skan else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE) 7835132718Skan return pointer_int_sum (PLUS_EXPR, op1, op0); 7836132718Skan else 7837132718Skan common = 1; 7838132718Skan break; 7839132718Skan 7840132718Skan case MINUS_EXPR: 7841132718Skan /* Subtraction of two similar pointers. 7842132718Skan We must subtract them as integers, then divide by object size. */ 7843132718Skan if (code0 == POINTER_TYPE && code1 == POINTER_TYPE 7844169689Skan && comp_target_types (type0, type1)) 7845132718Skan return pointer_diff (op0, op1); 7846132718Skan /* Handle pointer minus int. Just like pointer plus int. */ 7847132718Skan else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 7848132718Skan return pointer_int_sum (MINUS_EXPR, op0, op1); 7849132718Skan else 7850132718Skan common = 1; 7851132718Skan break; 7852132718Skan 7853132718Skan case MULT_EXPR: 7854132718Skan common = 1; 7855132718Skan break; 7856132718Skan 7857132718Skan case TRUNC_DIV_EXPR: 7858132718Skan case CEIL_DIV_EXPR: 7859132718Skan case FLOOR_DIV_EXPR: 7860132718Skan case ROUND_DIV_EXPR: 7861132718Skan case EXACT_DIV_EXPR: 7862132718Skan /* Floating point division by zero is a legitimate way to obtain 7863132718Skan infinities and NaNs. */ 7864169689Skan if (skip_evaluation == 0 && integer_zerop (op1)) 7865169689Skan warning (OPT_Wdiv_by_zero, "division by zero"); 7866132718Skan 7867132718Skan if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE 7868132718Skan || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE) 7869132718Skan && (code1 == INTEGER_TYPE || code1 == REAL_TYPE 7870132718Skan || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)) 7871132718Skan { 7872169689Skan enum tree_code tcode0 = code0, tcode1 = code1; 7873169689Skan 7874169689Skan if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE) 7875169689Skan tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0))); 7876169689Skan if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE) 7877169689Skan tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1))); 7878169689Skan 7879169689Skan if (!(tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE)) 7880132718Skan resultcode = RDIV_EXPR; 7881132718Skan else 7882132718Skan /* Although it would be tempting to shorten always here, that 7883132718Skan loses on some targets, since the modulo instruction is 7884132718Skan undefined if the quotient can't be represented in the 7885132718Skan computation mode. We shorten only if unsigned or if 7886132718Skan dividing by something we know != -1. */ 7887169689Skan shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0)) 7888132718Skan || (TREE_CODE (op1) == INTEGER_CST 7889169689Skan && !integer_all_onesp (op1))); 7890132718Skan common = 1; 7891132718Skan } 7892132718Skan break; 7893132718Skan 7894132718Skan case BIT_AND_EXPR: 7895132718Skan case BIT_IOR_EXPR: 7896132718Skan case BIT_XOR_EXPR: 7897132718Skan if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 7898132718Skan shorten = -1; 7899132718Skan else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE) 7900132718Skan common = 1; 7901132718Skan break; 7902132718Skan 7903132718Skan case TRUNC_MOD_EXPR: 7904132718Skan case FLOOR_MOD_EXPR: 7905169689Skan if (skip_evaluation == 0 && integer_zerop (op1)) 7906169689Skan warning (OPT_Wdiv_by_zero, "division by zero"); 7907132718Skan 7908132718Skan if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 7909132718Skan { 7910132718Skan /* Although it would be tempting to shorten always here, that loses 7911132718Skan on some targets, since the modulo instruction is undefined if the 7912132718Skan quotient can't be represented in the computation mode. We shorten 7913132718Skan only if unsigned or if dividing by something we know != -1. */ 7914169689Skan shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0)) 7915132718Skan || (TREE_CODE (op1) == INTEGER_CST 7916169689Skan && !integer_all_onesp (op1))); 7917132718Skan common = 1; 7918132718Skan } 7919132718Skan break; 7920132718Skan 7921132718Skan case TRUTH_ANDIF_EXPR: 7922132718Skan case TRUTH_ORIF_EXPR: 7923132718Skan case TRUTH_AND_EXPR: 7924132718Skan case TRUTH_OR_EXPR: 7925132718Skan case TRUTH_XOR_EXPR: 7926132718Skan if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE 7927132718Skan || code0 == REAL_TYPE || code0 == COMPLEX_TYPE) 7928132718Skan && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE 7929132718Skan || code1 == REAL_TYPE || code1 == COMPLEX_TYPE)) 7930132718Skan { 7931132718Skan /* Result of these operations is always an int, 7932132718Skan but that does not mean the operands should be 7933132718Skan converted to ints! */ 7934132718Skan result_type = integer_type_node; 7935132718Skan op0 = c_common_truthvalue_conversion (op0); 7936132718Skan op1 = c_common_truthvalue_conversion (op1); 7937132718Skan converted = 1; 7938132718Skan } 7939132718Skan break; 7940132718Skan 7941132718Skan /* Shift operations: result has same type as first operand; 7942132718Skan always convert second operand to int. 7943132718Skan Also set SHORT_SHIFT if shifting rightward. */ 7944132718Skan 7945132718Skan case RSHIFT_EXPR: 7946132718Skan if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 7947132718Skan { 7948132718Skan if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0) 7949132718Skan { 7950132718Skan if (tree_int_cst_sgn (op1) < 0) 7951169689Skan warning (0, "right shift count is negative"); 7952132718Skan else 7953132718Skan { 7954169689Skan if (!integer_zerop (op1)) 7955132718Skan short_shift = 1; 7956132718Skan 7957132718Skan if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0) 7958169689Skan warning (0, "right shift count >= width of type"); 7959132718Skan } 7960132718Skan } 7961132718Skan 7962132718Skan /* Use the type of the value to be shifted. */ 7963132718Skan result_type = type0; 7964132718Skan /* Convert the shift-count to an integer, regardless of size 7965132718Skan of value being shifted. */ 7966132718Skan if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node) 7967132718Skan op1 = convert (integer_type_node, op1); 7968132718Skan /* Avoid converting op1 to result_type later. */ 7969132718Skan converted = 1; 7970132718Skan } 7971132718Skan break; 7972132718Skan 7973132718Skan case LSHIFT_EXPR: 7974132718Skan if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 7975132718Skan { 7976132718Skan if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0) 7977132718Skan { 7978132718Skan if (tree_int_cst_sgn (op1) < 0) 7979169689Skan warning (0, "left shift count is negative"); 7980132718Skan 7981132718Skan else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0) 7982169689Skan warning (0, "left shift count >= width of type"); 7983132718Skan } 7984132718Skan 7985132718Skan /* Use the type of the value to be shifted. */ 7986132718Skan result_type = type0; 7987132718Skan /* Convert the shift-count to an integer, regardless of size 7988132718Skan of value being shifted. */ 7989132718Skan if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node) 7990132718Skan op1 = convert (integer_type_node, op1); 7991132718Skan /* Avoid converting op1 to result_type later. */ 7992132718Skan converted = 1; 7993132718Skan } 7994132718Skan break; 7995132718Skan 7996132718Skan case EQ_EXPR: 7997132718Skan case NE_EXPR: 7998169689Skan if (code0 == REAL_TYPE || code1 == REAL_TYPE) 7999169689Skan warning (OPT_Wfloat_equal, 8000169689Skan "comparing floating point with == or != is unsafe"); 8001132718Skan /* Result of comparison is always int, 8002132718Skan but don't convert the args to int! */ 8003132718Skan build_type = integer_type_node; 8004132718Skan if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE 8005132718Skan || code0 == COMPLEX_TYPE) 8006132718Skan && (code1 == INTEGER_TYPE || code1 == REAL_TYPE 8007132718Skan || code1 == COMPLEX_TYPE)) 8008132718Skan short_compare = 1; 8009132718Skan else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE) 8010132718Skan { 8011132718Skan tree tt0 = TREE_TYPE (type0); 8012132718Skan tree tt1 = TREE_TYPE (type1); 8013132718Skan /* Anything compares with void *. void * compares with anything. 8014132718Skan Otherwise, the targets must be compatible 8015132718Skan and both must be object or both incomplete. */ 8016169689Skan if (comp_target_types (type0, type1)) 8017169689Skan result_type = common_pointer_type (type0, type1); 8018132718Skan else if (VOID_TYPE_P (tt0)) 8019132718Skan { 8020132718Skan /* op0 != orig_op0 detects the case of something 8021132718Skan whose value is 0 but which isn't a valid null ptr const. */ 8022169689Skan if (pedantic && !null_pointer_constant_p (orig_op0) 8023132718Skan && TREE_CODE (tt1) == FUNCTION_TYPE) 8024169689Skan pedwarn ("ISO C forbids comparison of %<void *%>" 8025169689Skan " with function pointer"); 8026132718Skan } 8027132718Skan else if (VOID_TYPE_P (tt1)) 8028132718Skan { 8029169689Skan if (pedantic && !null_pointer_constant_p (orig_op1) 8030132718Skan && TREE_CODE (tt0) == FUNCTION_TYPE) 8031169689Skan pedwarn ("ISO C forbids comparison of %<void *%>" 8032169689Skan " with function pointer"); 8033132718Skan } 8034132718Skan else 8035169689Skan /* Avoid warning about the volatile ObjC EH puts on decls. */ 8036169689Skan if (!objc_ok) 8037169689Skan pedwarn ("comparison of distinct pointer types lacks a cast"); 8038132718Skan 8039132718Skan if (result_type == NULL_TREE) 8040132718Skan result_type = ptr_type_node; 8041132718Skan } 8042169689Skan else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1)) 8043169689Skan { 8044169689Skan if (TREE_CODE (op0) == ADDR_EXPR 8045169689Skan && DECL_P (TREE_OPERAND (op0, 0)) 8046169689Skan && (TREE_CODE (TREE_OPERAND (op0, 0)) == PARM_DECL 8047169689Skan || TREE_CODE (TREE_OPERAND (op0, 0)) == LABEL_DECL 8048169689Skan || !DECL_WEAK (TREE_OPERAND (op0, 0)))) 8049169689Skan warning (OPT_Waddress, "the address of %qD will never be NULL", 8050169689Skan TREE_OPERAND (op0, 0)); 8051169689Skan result_type = type0; 8052169689Skan } 8053169689Skan else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0)) 8054169689Skan { 8055169689Skan if (TREE_CODE (op1) == ADDR_EXPR 8056169689Skan && DECL_P (TREE_OPERAND (op1, 0)) 8057169689Skan && (TREE_CODE (TREE_OPERAND (op1, 0)) == PARM_DECL 8058169689Skan || TREE_CODE (TREE_OPERAND (op1, 0)) == LABEL_DECL 8059169689Skan || !DECL_WEAK (TREE_OPERAND (op1, 0)))) 8060169689Skan warning (OPT_Waddress, "the address of %qD will never be NULL", 8061169689Skan TREE_OPERAND (op1, 0)); 8062169689Skan result_type = type1; 8063169689Skan } 8064132718Skan else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 8065132718Skan { 8066132718Skan result_type = type0; 8067132718Skan pedwarn ("comparison between pointer and integer"); 8068132718Skan } 8069132718Skan else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE) 8070132718Skan { 8071132718Skan result_type = type1; 8072132718Skan pedwarn ("comparison between pointer and integer"); 8073132718Skan } 8074132718Skan break; 8075132718Skan 8076132718Skan case LE_EXPR: 8077132718Skan case GE_EXPR: 8078132718Skan case LT_EXPR: 8079132718Skan case GT_EXPR: 8080132718Skan build_type = integer_type_node; 8081132718Skan if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE) 8082132718Skan && (code1 == INTEGER_TYPE || code1 == REAL_TYPE)) 8083132718Skan short_compare = 1; 8084132718Skan else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE) 8085132718Skan { 8086169689Skan if (comp_target_types (type0, type1)) 8087132718Skan { 8088169689Skan result_type = common_pointer_type (type0, type1); 8089132718Skan if (!COMPLETE_TYPE_P (TREE_TYPE (type0)) 8090132718Skan != !COMPLETE_TYPE_P (TREE_TYPE (type1))) 8091132718Skan pedwarn ("comparison of complete and incomplete pointers"); 8092132718Skan else if (pedantic 8093132718Skan && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE) 8094132718Skan pedwarn ("ISO C forbids ordered comparisons of pointers to functions"); 8095132718Skan } 8096132718Skan else 8097132718Skan { 8098132718Skan result_type = ptr_type_node; 8099132718Skan pedwarn ("comparison of distinct pointer types lacks a cast"); 8100132718Skan } 8101132718Skan } 8102169689Skan else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1)) 8103132718Skan { 8104132718Skan result_type = type0; 8105132718Skan if (pedantic || extra_warnings) 8106132718Skan pedwarn ("ordered comparison of pointer with integer zero"); 8107132718Skan } 8108169689Skan else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0)) 8109132718Skan { 8110132718Skan result_type = type1; 8111132718Skan if (pedantic) 8112132718Skan pedwarn ("ordered comparison of pointer with integer zero"); 8113132718Skan } 8114132718Skan else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 8115132718Skan { 8116132718Skan result_type = type0; 8117132718Skan pedwarn ("comparison between pointer and integer"); 8118132718Skan } 8119132718Skan else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE) 8120132718Skan { 8121132718Skan result_type = type1; 8122132718Skan pedwarn ("comparison between pointer and integer"); 8123132718Skan } 8124132718Skan break; 8125132718Skan 8126132718Skan default: 8127169689Skan gcc_unreachable (); 8128132718Skan } 8129132718Skan 8130169689Skan if (code0 == ERROR_MARK || code1 == ERROR_MARK) 8131169689Skan return error_mark_node; 8132169689Skan 8133169689Skan if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE 8134169689Skan && (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1)) 8135169689Skan || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0), 8136169689Skan TREE_TYPE (type1)))) 8137169689Skan { 8138259948Spfg binary_op_error (code, type0, type1); 8139169689Skan return error_mark_node; 8140169689Skan } 8141169689Skan 8142132718Skan if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE 8143132718Skan || code0 == VECTOR_TYPE) 8144132718Skan && 8145132718Skan (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE 8146132718Skan || code1 == VECTOR_TYPE)) 8147132718Skan { 8148132718Skan int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE); 8149132718Skan 8150132718Skan if (shorten || common || short_compare) 8151169689Skan result_type = c_common_type (type0, type1); 8152132718Skan 8153132718Skan /* For certain operations (which identify themselves by shorten != 0) 8154132718Skan if both args were extended from the same smaller type, 8155132718Skan do the arithmetic in that type and then extend. 8156132718Skan 8157132718Skan shorten !=0 and !=1 indicates a bitwise operation. 8158132718Skan For them, this optimization is safe only if 8159132718Skan both args are zero-extended or both are sign-extended. 8160132718Skan Otherwise, we might change the result. 8161132718Skan Eg, (short)-1 | (unsigned short)-1 is (int)-1 8162132718Skan but calculated in (unsigned short) it would be (unsigned short)-1. */ 8163132718Skan 8164132718Skan if (shorten && none_complex) 8165132718Skan { 8166132718Skan int unsigned0, unsigned1; 8167169689Skan tree arg0, arg1; 8168169689Skan int uns; 8169132718Skan tree type; 8170132718Skan 8171169689Skan /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents 8172169689Skan excessive narrowing when we call get_narrower below. For 8173169689Skan example, suppose that OP0 is of unsigned int extended 8174169689Skan from signed char and that RESULT_TYPE is long long int. 8175169689Skan If we explicitly cast OP0 to RESULT_TYPE, OP0 would look 8176169689Skan like 8177169689Skan 8178169689Skan (long long int) (unsigned int) signed_char 8179169689Skan 8180169689Skan which get_narrower would narrow down to 8181169689Skan 8182169689Skan (unsigned int) signed char 8183169689Skan 8184169689Skan If we do not cast OP0 first, get_narrower would return 8185169689Skan signed_char, which is inconsistent with the case of the 8186169689Skan explicit cast. */ 8187169689Skan op0 = convert (result_type, op0); 8188169689Skan op1 = convert (result_type, op1); 8189169689Skan 8190169689Skan arg0 = get_narrower (op0, &unsigned0); 8191169689Skan arg1 = get_narrower (op1, &unsigned1); 8192169689Skan 8193169689Skan /* UNS is 1 if the operation to be done is an unsigned one. */ 8194169689Skan uns = TYPE_UNSIGNED (result_type); 8195169689Skan 8196132718Skan final_type = result_type; 8197132718Skan 8198132718Skan /* Handle the case that OP0 (or OP1) does not *contain* a conversion 8199132718Skan but it *requires* conversion to FINAL_TYPE. */ 8200132718Skan 8201132718Skan if ((TYPE_PRECISION (TREE_TYPE (op0)) 8202132718Skan == TYPE_PRECISION (TREE_TYPE (arg0))) 8203132718Skan && TREE_TYPE (op0) != final_type) 8204169689Skan unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0)); 8205132718Skan if ((TYPE_PRECISION (TREE_TYPE (op1)) 8206132718Skan == TYPE_PRECISION (TREE_TYPE (arg1))) 8207132718Skan && TREE_TYPE (op1) != final_type) 8208169689Skan unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1)); 8209132718Skan 8210132718Skan /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */ 8211132718Skan 8212132718Skan /* For bitwise operations, signedness of nominal type 8213132718Skan does not matter. Consider only how operands were extended. */ 8214132718Skan if (shorten == -1) 8215132718Skan uns = unsigned0; 8216132718Skan 8217132718Skan /* Note that in all three cases below we refrain from optimizing 8218132718Skan an unsigned operation on sign-extended args. 8219132718Skan That would not be valid. */ 8220132718Skan 8221132718Skan /* Both args variable: if both extended in same way 8222132718Skan from same width, do it in that width. 8223132718Skan Do it unsigned if args were zero-extended. */ 8224132718Skan if ((TYPE_PRECISION (TREE_TYPE (arg0)) 8225132718Skan < TYPE_PRECISION (result_type)) 8226132718Skan && (TYPE_PRECISION (TREE_TYPE (arg1)) 8227132718Skan == TYPE_PRECISION (TREE_TYPE (arg0))) 8228132718Skan && unsigned0 == unsigned1 8229132718Skan && (unsigned0 || !uns)) 8230132718Skan result_type 8231132718Skan = c_common_signed_or_unsigned_type 8232132718Skan (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1))); 8233132718Skan else if (TREE_CODE (arg0) == INTEGER_CST 8234132718Skan && (unsigned1 || !uns) 8235132718Skan && (TYPE_PRECISION (TREE_TYPE (arg1)) 8236132718Skan < TYPE_PRECISION (result_type)) 8237132718Skan && (type 8238132718Skan = c_common_signed_or_unsigned_type (unsigned1, 8239132718Skan TREE_TYPE (arg1)), 8240132718Skan int_fits_type_p (arg0, type))) 8241132718Skan result_type = type; 8242132718Skan else if (TREE_CODE (arg1) == INTEGER_CST 8243132718Skan && (unsigned0 || !uns) 8244132718Skan && (TYPE_PRECISION (TREE_TYPE (arg0)) 8245132718Skan < TYPE_PRECISION (result_type)) 8246132718Skan && (type 8247132718Skan = c_common_signed_or_unsigned_type (unsigned0, 8248132718Skan TREE_TYPE (arg0)), 8249132718Skan int_fits_type_p (arg1, type))) 8250132718Skan result_type = type; 8251132718Skan } 8252132718Skan 8253132718Skan /* Shifts can be shortened if shifting right. */ 8254132718Skan 8255132718Skan if (short_shift) 8256132718Skan { 8257132718Skan int unsigned_arg; 8258132718Skan tree arg0 = get_narrower (op0, &unsigned_arg); 8259132718Skan 8260132718Skan final_type = result_type; 8261132718Skan 8262132718Skan if (arg0 == op0 && final_type == TREE_TYPE (op0)) 8263169689Skan unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0)); 8264132718Skan 8265132718Skan if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type) 8266132718Skan /* We can shorten only if the shift count is less than the 8267132718Skan number of bits in the smaller type size. */ 8268132718Skan && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0 8269132718Skan /* We cannot drop an unsigned shift after sign-extension. */ 8270169689Skan && (!TYPE_UNSIGNED (final_type) || unsigned_arg)) 8271132718Skan { 8272132718Skan /* Do an unsigned shift if the operand was zero-extended. */ 8273132718Skan result_type 8274132718Skan = c_common_signed_or_unsigned_type (unsigned_arg, 8275132718Skan TREE_TYPE (arg0)); 8276132718Skan /* Convert value-to-be-shifted to that type. */ 8277132718Skan if (TREE_TYPE (op0) != result_type) 8278132718Skan op0 = convert (result_type, op0); 8279132718Skan converted = 1; 8280132718Skan } 8281132718Skan } 8282132718Skan 8283132718Skan /* Comparison operations are shortened too but differently. 8284132718Skan They identify themselves by setting short_compare = 1. */ 8285132718Skan 8286132718Skan if (short_compare) 8287132718Skan { 8288132718Skan /* Don't write &op0, etc., because that would prevent op0 8289132718Skan from being kept in a register. 8290132718Skan Instead, make copies of the our local variables and 8291132718Skan pass the copies by reference, then copy them back afterward. */ 8292132718Skan tree xop0 = op0, xop1 = op1, xresult_type = result_type; 8293132718Skan enum tree_code xresultcode = resultcode; 8294132718Skan tree val 8295132718Skan = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode); 8296132718Skan 8297132718Skan if (val != 0) 8298132718Skan return val; 8299132718Skan 8300132718Skan op0 = xop0, op1 = xop1; 8301132718Skan converted = 1; 8302132718Skan resultcode = xresultcode; 8303132718Skan 8304132718Skan if (warn_sign_compare && skip_evaluation == 0) 8305132718Skan { 8306169689Skan int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0)); 8307169689Skan int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1)); 8308132718Skan int unsignedp0, unsignedp1; 8309132718Skan tree primop0 = get_narrower (op0, &unsignedp0); 8310132718Skan tree primop1 = get_narrower (op1, &unsignedp1); 8311132718Skan 8312132718Skan xop0 = orig_op0; 8313132718Skan xop1 = orig_op1; 8314132718Skan STRIP_TYPE_NOPS (xop0); 8315132718Skan STRIP_TYPE_NOPS (xop1); 8316132718Skan 8317132718Skan /* Give warnings for comparisons between signed and unsigned 8318132718Skan quantities that may fail. 8319132718Skan 8320132718Skan Do the checking based on the original operand trees, so that 8321132718Skan casts will be considered, but default promotions won't be. 8322132718Skan 8323132718Skan Do not warn if the comparison is being done in a signed type, 8324132718Skan since the signed type will only be chosen if it can represent 8325132718Skan all the values of the unsigned type. */ 8326169689Skan if (!TYPE_UNSIGNED (result_type)) 8327132718Skan /* OK */; 8328169689Skan /* Do not warn if both operands are the same signedness. */ 8329169689Skan else if (op0_signed == op1_signed) 8330169689Skan /* OK */; 8331132718Skan else 8332132718Skan { 8333132718Skan tree sop, uop; 8334169689Skan bool ovf; 8335132718Skan 8336132718Skan if (op0_signed) 8337132718Skan sop = xop0, uop = xop1; 8338132718Skan else 8339132718Skan sop = xop1, uop = xop0; 8340132718Skan 8341132718Skan /* Do not warn if the signed quantity is an 8342132718Skan unsuffixed integer literal (or some static 8343132718Skan constant expression involving such literals or a 8344132718Skan conditional expression involving such literals) 8345132718Skan and it is non-negative. */ 8346169689Skan if (tree_expr_nonnegative_warnv_p (sop, &ovf)) 8347132718Skan /* OK */; 8348132718Skan /* Do not warn if the comparison is an equality operation, 8349132718Skan the unsigned quantity is an integral constant, and it 8350132718Skan would fit in the result if the result were signed. */ 8351132718Skan else if (TREE_CODE (uop) == INTEGER_CST 8352132718Skan && (resultcode == EQ_EXPR || resultcode == NE_EXPR) 8353132718Skan && int_fits_type_p 8354132718Skan (uop, c_common_signed_type (result_type))) 8355132718Skan /* OK */; 8356132718Skan /* Do not warn if the unsigned quantity is an enumeration 8357132718Skan constant and its maximum value would fit in the result 8358132718Skan if the result were signed. */ 8359132718Skan else if (TREE_CODE (uop) == INTEGER_CST 8360132718Skan && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE 8361132718Skan && int_fits_type_p 8362169689Skan (TYPE_MAX_VALUE (TREE_TYPE (uop)), 8363132718Skan c_common_signed_type (result_type))) 8364132718Skan /* OK */; 8365132718Skan else 8366169689Skan warning (0, "comparison between signed and unsigned"); 8367132718Skan } 8368132718Skan 8369132718Skan /* Warn if two unsigned values are being compared in a size 8370132718Skan larger than their original size, and one (and only one) is the 8371132718Skan result of a `~' operator. This comparison will always fail. 8372132718Skan 8373132718Skan Also warn if one operand is a constant, and the constant 8374132718Skan does not have all bits set that are set in the ~ operand 8375132718Skan when it is extended. */ 8376132718Skan 8377132718Skan if ((TREE_CODE (primop0) == BIT_NOT_EXPR) 8378132718Skan != (TREE_CODE (primop1) == BIT_NOT_EXPR)) 8379132718Skan { 8380132718Skan if (TREE_CODE (primop0) == BIT_NOT_EXPR) 8381132718Skan primop0 = get_narrower (TREE_OPERAND (primop0, 0), 8382132718Skan &unsignedp0); 8383132718Skan else 8384132718Skan primop1 = get_narrower (TREE_OPERAND (primop1, 0), 8385132718Skan &unsignedp1); 8386132718Skan 8387132718Skan if (host_integerp (primop0, 0) || host_integerp (primop1, 0)) 8388132718Skan { 8389132718Skan tree primop; 8390132718Skan HOST_WIDE_INT constant, mask; 8391132718Skan int unsignedp, bits; 8392132718Skan 8393132718Skan if (host_integerp (primop0, 0)) 8394132718Skan { 8395132718Skan primop = primop1; 8396132718Skan unsignedp = unsignedp1; 8397132718Skan constant = tree_low_cst (primop0, 0); 8398132718Skan } 8399132718Skan else 8400132718Skan { 8401132718Skan primop = primop0; 8402132718Skan unsignedp = unsignedp0; 8403132718Skan constant = tree_low_cst (primop1, 0); 8404132718Skan } 8405132718Skan 8406132718Skan bits = TYPE_PRECISION (TREE_TYPE (primop)); 8407132718Skan if (bits < TYPE_PRECISION (result_type) 8408132718Skan && bits < HOST_BITS_PER_WIDE_INT && unsignedp) 8409132718Skan { 8410169689Skan mask = (~(HOST_WIDE_INT) 0) << bits; 8411132718Skan if ((mask & constant) != mask) 8412169689Skan warning (0, "comparison of promoted ~unsigned with constant"); 8413132718Skan } 8414132718Skan } 8415132718Skan else if (unsignedp0 && unsignedp1 8416132718Skan && (TYPE_PRECISION (TREE_TYPE (primop0)) 8417132718Skan < TYPE_PRECISION (result_type)) 8418132718Skan && (TYPE_PRECISION (TREE_TYPE (primop1)) 8419132718Skan < TYPE_PRECISION (result_type))) 8420169689Skan warning (0, "comparison of promoted ~unsigned with unsigned"); 8421132718Skan } 8422132718Skan } 8423132718Skan } 8424132718Skan } 8425132718Skan 8426132718Skan /* At this point, RESULT_TYPE must be nonzero to avoid an error message. 8427132718Skan If CONVERTED is zero, both args will be converted to type RESULT_TYPE. 8428132718Skan Then the expression will be built. 8429132718Skan It will be given type FINAL_TYPE if that is nonzero; 8430132718Skan otherwise, it will be given type RESULT_TYPE. */ 8431132718Skan 8432132718Skan if (!result_type) 8433132718Skan { 8434259948Spfg binary_op_error (code, TREE_TYPE (op0), TREE_TYPE (op1)); 8435132718Skan return error_mark_node; 8436132718Skan } 8437132718Skan 8438169689Skan if (!converted) 8439132718Skan { 8440132718Skan if (TREE_TYPE (op0) != result_type) 8441169689Skan op0 = convert_and_check (result_type, op0); 8442132718Skan if (TREE_TYPE (op1) != result_type) 8443169689Skan op1 = convert_and_check (result_type, op1); 8444169689Skan 8445169689Skan /* This can happen if one operand has a vector type, and the other 8446169689Skan has a different type. */ 8447169689Skan if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK) 8448169689Skan return error_mark_node; 8449132718Skan } 8450132718Skan 8451132718Skan if (build_type == NULL_TREE) 8452132718Skan build_type = result_type; 8453132718Skan 8454132718Skan { 8455169689Skan /* Treat expressions in initializers specially as they can't trap. */ 8456169689Skan tree result = require_constant_value ? fold_build2_initializer (resultcode, 8457169689Skan build_type, 8458169689Skan op0, op1) 8459169689Skan : fold_build2 (resultcode, build_type, 8460169689Skan op0, op1); 8461132718Skan 8462132718Skan if (final_type != 0) 8463169689Skan result = convert (final_type, result); 8464169689Skan return result; 8465132718Skan } 8466132718Skan} 8467169689Skan 8468169689Skan 8469169689Skan/* Convert EXPR to be a truth-value, validating its type for this 8470169689Skan purpose. */ 8471169689Skan 8472169689Skantree 8473169689Skanc_objc_common_truthvalue_conversion (tree expr) 8474169689Skan{ 8475169689Skan switch (TREE_CODE (TREE_TYPE (expr))) 8476169689Skan { 8477169689Skan case ARRAY_TYPE: 8478169689Skan error ("used array that cannot be converted to pointer where scalar is required"); 8479169689Skan return error_mark_node; 8480169689Skan 8481169689Skan case RECORD_TYPE: 8482169689Skan error ("used struct type value where scalar is required"); 8483169689Skan return error_mark_node; 8484169689Skan 8485169689Skan case UNION_TYPE: 8486169689Skan error ("used union type value where scalar is required"); 8487169689Skan return error_mark_node; 8488169689Skan 8489169689Skan case FUNCTION_TYPE: 8490169689Skan gcc_unreachable (); 8491169689Skan 8492169689Skan default: 8493169689Skan break; 8494169689Skan } 8495169689Skan 8496169689Skan /* ??? Should we also give an error for void and vectors rather than 8497169689Skan leaving those to give errors later? */ 8498169689Skan return c_common_truthvalue_conversion (expr); 8499169689Skan} 8500169689Skan 8501169689Skan 8502169689Skan/* Convert EXPR to a contained DECL, updating *TC, *TI and *SE as 8503169689Skan required. */ 8504169689Skan 8505169689Skantree 8506169689Skanc_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, 8507169689Skan bool *ti ATTRIBUTE_UNUSED, bool *se) 8508169689Skan{ 8509169689Skan if (TREE_CODE (expr) == COMPOUND_LITERAL_EXPR) 8510169689Skan { 8511169689Skan tree decl = COMPOUND_LITERAL_EXPR_DECL (expr); 8512169689Skan /* Executing a compound literal inside a function reinitializes 8513169689Skan it. */ 8514169689Skan if (!TREE_STATIC (decl)) 8515169689Skan *se = true; 8516169689Skan return decl; 8517169689Skan } 8518169689Skan else 8519169689Skan return expr; 8520169689Skan} 8521169689Skan 8522169689Skan/* Like c_begin_compound_stmt, except force the retention of the BLOCK. */ 8523169689Skan 8524169689Skantree 8525169689Skanc_begin_omp_parallel (void) 8526169689Skan{ 8527169689Skan tree block; 8528169689Skan 8529169689Skan keep_next_level (); 8530169689Skan block = c_begin_compound_stmt (true); 8531169689Skan 8532169689Skan return block; 8533169689Skan} 8534169689Skan 8535169689Skantree 8536169689Skanc_finish_omp_parallel (tree clauses, tree block) 8537169689Skan{ 8538169689Skan tree stmt; 8539169689Skan 8540169689Skan block = c_end_compound_stmt (block, true); 8541169689Skan 8542169689Skan stmt = make_node (OMP_PARALLEL); 8543169689Skan TREE_TYPE (stmt) = void_type_node; 8544169689Skan OMP_PARALLEL_CLAUSES (stmt) = clauses; 8545169689Skan OMP_PARALLEL_BODY (stmt) = block; 8546169689Skan 8547169689Skan return add_stmt (stmt); 8548169689Skan} 8549169689Skan 8550169689Skan/* For all elements of CLAUSES, validate them vs OpenMP constraints. 8551169689Skan Remove any elements from the list that are invalid. */ 8552169689Skan 8553169689Skantree 8554169689Skanc_finish_omp_clauses (tree clauses) 8555169689Skan{ 8556169689Skan bitmap_head generic_head, firstprivate_head, lastprivate_head; 8557169689Skan tree c, t, *pc = &clauses; 8558169689Skan const char *name; 8559169689Skan 8560169689Skan bitmap_obstack_initialize (NULL); 8561169689Skan bitmap_initialize (&generic_head, &bitmap_default_obstack); 8562169689Skan bitmap_initialize (&firstprivate_head, &bitmap_default_obstack); 8563169689Skan bitmap_initialize (&lastprivate_head, &bitmap_default_obstack); 8564169689Skan 8565169689Skan for (pc = &clauses, c = clauses; c ; c = *pc) 8566169689Skan { 8567169689Skan bool remove = false; 8568169689Skan bool need_complete = false; 8569169689Skan bool need_implicitly_determined = false; 8570169689Skan 8571169689Skan switch (OMP_CLAUSE_CODE (c)) 8572169689Skan { 8573169689Skan case OMP_CLAUSE_SHARED: 8574169689Skan name = "shared"; 8575169689Skan need_implicitly_determined = true; 8576169689Skan goto check_dup_generic; 8577169689Skan 8578169689Skan case OMP_CLAUSE_PRIVATE: 8579169689Skan name = "private"; 8580169689Skan need_complete = true; 8581169689Skan need_implicitly_determined = true; 8582169689Skan goto check_dup_generic; 8583169689Skan 8584169689Skan case OMP_CLAUSE_REDUCTION: 8585169689Skan name = "reduction"; 8586169689Skan need_implicitly_determined = true; 8587169689Skan t = OMP_CLAUSE_DECL (c); 8588169689Skan if (AGGREGATE_TYPE_P (TREE_TYPE (t)) 8589169689Skan || POINTER_TYPE_P (TREE_TYPE (t))) 8590169689Skan { 8591169689Skan error ("%qE has invalid type for %<reduction%>", t); 8592169689Skan remove = true; 8593169689Skan } 8594169689Skan else if (FLOAT_TYPE_P (TREE_TYPE (t))) 8595169689Skan { 8596169689Skan enum tree_code r_code = OMP_CLAUSE_REDUCTION_CODE (c); 8597169689Skan const char *r_name = NULL; 8598169689Skan 8599169689Skan switch (r_code) 8600169689Skan { 8601169689Skan case PLUS_EXPR: 8602169689Skan case MULT_EXPR: 8603169689Skan case MINUS_EXPR: 8604169689Skan break; 8605169689Skan case BIT_AND_EXPR: 8606169689Skan r_name = "&"; 8607169689Skan break; 8608169689Skan case BIT_XOR_EXPR: 8609169689Skan r_name = "^"; 8610169689Skan break; 8611169689Skan case BIT_IOR_EXPR: 8612169689Skan r_name = "|"; 8613169689Skan break; 8614169689Skan case TRUTH_ANDIF_EXPR: 8615169689Skan r_name = "&&"; 8616169689Skan break; 8617169689Skan case TRUTH_ORIF_EXPR: 8618169689Skan r_name = "||"; 8619169689Skan break; 8620169689Skan default: 8621169689Skan gcc_unreachable (); 8622169689Skan } 8623169689Skan if (r_name) 8624169689Skan { 8625169689Skan error ("%qE has invalid type for %<reduction(%s)%>", 8626169689Skan t, r_name); 8627169689Skan remove = true; 8628169689Skan } 8629169689Skan } 8630169689Skan goto check_dup_generic; 8631169689Skan 8632169689Skan case OMP_CLAUSE_COPYPRIVATE: 8633169689Skan name = "copyprivate"; 8634169689Skan goto check_dup_generic; 8635169689Skan 8636169689Skan case OMP_CLAUSE_COPYIN: 8637169689Skan name = "copyin"; 8638169689Skan t = OMP_CLAUSE_DECL (c); 8639169689Skan if (TREE_CODE (t) != VAR_DECL || !DECL_THREAD_LOCAL_P (t)) 8640169689Skan { 8641169689Skan error ("%qE must be %<threadprivate%> for %<copyin%>", t); 8642169689Skan remove = true; 8643169689Skan } 8644169689Skan goto check_dup_generic; 8645169689Skan 8646169689Skan check_dup_generic: 8647169689Skan t = OMP_CLAUSE_DECL (c); 8648169689Skan if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL) 8649169689Skan { 8650169689Skan error ("%qE is not a variable in clause %qs", t, name); 8651169689Skan remove = true; 8652169689Skan } 8653169689Skan else if (bitmap_bit_p (&generic_head, DECL_UID (t)) 8654169689Skan || bitmap_bit_p (&firstprivate_head, DECL_UID (t)) 8655169689Skan || bitmap_bit_p (&lastprivate_head, DECL_UID (t))) 8656169689Skan { 8657169689Skan error ("%qE appears more than once in data clauses", t); 8658169689Skan remove = true; 8659169689Skan } 8660169689Skan else 8661169689Skan bitmap_set_bit (&generic_head, DECL_UID (t)); 8662169689Skan break; 8663169689Skan 8664169689Skan case OMP_CLAUSE_FIRSTPRIVATE: 8665169689Skan name = "firstprivate"; 8666169689Skan t = OMP_CLAUSE_DECL (c); 8667169689Skan need_complete = true; 8668169689Skan need_implicitly_determined = true; 8669169689Skan if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL) 8670169689Skan { 8671169689Skan error ("%qE is not a variable in clause %<firstprivate%>", t); 8672169689Skan remove = true; 8673169689Skan } 8674169689Skan else if (bitmap_bit_p (&generic_head, DECL_UID (t)) 8675169689Skan || bitmap_bit_p (&firstprivate_head, DECL_UID (t))) 8676169689Skan { 8677169689Skan error ("%qE appears more than once in data clauses", t); 8678169689Skan remove = true; 8679169689Skan } 8680169689Skan else 8681169689Skan bitmap_set_bit (&firstprivate_head, DECL_UID (t)); 8682169689Skan break; 8683169689Skan 8684169689Skan case OMP_CLAUSE_LASTPRIVATE: 8685169689Skan name = "lastprivate"; 8686169689Skan t = OMP_CLAUSE_DECL (c); 8687169689Skan need_complete = true; 8688169689Skan need_implicitly_determined = true; 8689169689Skan if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL) 8690169689Skan { 8691169689Skan error ("%qE is not a variable in clause %<lastprivate%>", t); 8692169689Skan remove = true; 8693169689Skan } 8694169689Skan else if (bitmap_bit_p (&generic_head, DECL_UID (t)) 8695169689Skan || bitmap_bit_p (&lastprivate_head, DECL_UID (t))) 8696169689Skan { 8697169689Skan error ("%qE appears more than once in data clauses", t); 8698169689Skan remove = true; 8699169689Skan } 8700169689Skan else 8701169689Skan bitmap_set_bit (&lastprivate_head, DECL_UID (t)); 8702169689Skan break; 8703169689Skan 8704169689Skan case OMP_CLAUSE_IF: 8705169689Skan case OMP_CLAUSE_NUM_THREADS: 8706169689Skan case OMP_CLAUSE_SCHEDULE: 8707169689Skan case OMP_CLAUSE_NOWAIT: 8708169689Skan case OMP_CLAUSE_ORDERED: 8709169689Skan case OMP_CLAUSE_DEFAULT: 8710169689Skan pc = &OMP_CLAUSE_CHAIN (c); 8711169689Skan continue; 8712169689Skan 8713169689Skan default: 8714169689Skan gcc_unreachable (); 8715169689Skan } 8716169689Skan 8717169689Skan if (!remove) 8718169689Skan { 8719169689Skan t = OMP_CLAUSE_DECL (c); 8720169689Skan 8721169689Skan if (need_complete) 8722169689Skan { 8723169689Skan t = require_complete_type (t); 8724169689Skan if (t == error_mark_node) 8725169689Skan remove = true; 8726169689Skan } 8727169689Skan 8728169689Skan if (need_implicitly_determined) 8729169689Skan { 8730169689Skan const char *share_name = NULL; 8731169689Skan 8732169689Skan if (TREE_CODE (t) == VAR_DECL && DECL_THREAD_LOCAL_P (t)) 8733169689Skan share_name = "threadprivate"; 8734169689Skan else switch (c_omp_predetermined_sharing (t)) 8735169689Skan { 8736169689Skan case OMP_CLAUSE_DEFAULT_UNSPECIFIED: 8737169689Skan break; 8738169689Skan case OMP_CLAUSE_DEFAULT_SHARED: 8739169689Skan share_name = "shared"; 8740169689Skan break; 8741169689Skan case OMP_CLAUSE_DEFAULT_PRIVATE: 8742169689Skan share_name = "private"; 8743169689Skan break; 8744169689Skan default: 8745169689Skan gcc_unreachable (); 8746169689Skan } 8747169689Skan if (share_name) 8748169689Skan { 8749169689Skan error ("%qE is predetermined %qs for %qs", 8750169689Skan t, share_name, name); 8751169689Skan remove = true; 8752169689Skan } 8753169689Skan } 8754169689Skan } 8755169689Skan 8756169689Skan if (remove) 8757169689Skan *pc = OMP_CLAUSE_CHAIN (c); 8758169689Skan else 8759169689Skan pc = &OMP_CLAUSE_CHAIN (c); 8760169689Skan } 8761169689Skan 8762169689Skan bitmap_obstack_release (NULL); 8763169689Skan return clauses; 8764169689Skan} 8765