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 1852260919Spfg /* APPLE LOCAL begin "unavailable" attribute (radar 2809697) */ 1853260919Spfg if (TREE_UNAVAILABLE (subdatum)) 1854260919Spfg error_unavailable_use (subdatum); 1855260919Spfg /* APPLE LOCAL end "unavailable" attribute (radar 2809697) */ 1856260919Spfg 185718334Speter datum = ref; 1858117395Skan 1859117395Skan field = TREE_CHAIN (field); 186018334Speter } 1861117395Skan while (field); 186218334Speter 186318334Speter return ref; 186418334Speter } 186518334Speter else if (code != ERROR_MARK) 1866169689Skan error ("request for member %qE in something not a structure or union", 1867169689Skan component); 186818334Speter 186918334Speter return error_mark_node; 187018334Speter} 187118334Speter 187218334Speter/* Given an expression PTR for a pointer, return an expression 187318334Speter for the value pointed to. 187418334Speter ERRORSTRING is the name of the operator to appear in error messages. */ 187518334Speter 187618334Spetertree 1877132718Skanbuild_indirect_ref (tree ptr, const char *errorstring) 187818334Speter{ 187990075Sobrien tree pointer = default_conversion (ptr); 188090075Sobrien tree type = TREE_TYPE (pointer); 188118334Speter 188218334Speter if (TREE_CODE (type) == POINTER_TYPE) 188318334Speter { 1884259406Spfg if (TREE_CODE (pointer) == CONVERT_EXPR 1885259406Spfg || TREE_CODE (pointer) == NOP_EXPR 1886259406Spfg || TREE_CODE (pointer) == VIEW_CONVERT_EXPR) 1887259406Spfg { 1888259406Spfg /* If a warning is issued, mark it to avoid duplicates from 1889259406Spfg the backend. This only needs to be done at 1890259406Spfg warn_strict_aliasing > 2. */ 1891259406Spfg if (warn_strict_aliasing > 2) 1892259406Spfg if (strict_aliasing_warning (TREE_TYPE (TREE_OPERAND (pointer, 0)), 1893259406Spfg type, TREE_OPERAND (pointer, 0))) 1894259406Spfg TREE_NO_WARNING (pointer) = 1; 1895259406Spfg } 1896259406Spfg 189718334Speter if (TREE_CODE (pointer) == ADDR_EXPR 189818334Speter && (TREE_TYPE (TREE_OPERAND (pointer, 0)) 189918334Speter == TREE_TYPE (type))) 190018334Speter return TREE_OPERAND (pointer, 0); 190118334Speter else 190218334Speter { 190318334Speter tree t = TREE_TYPE (type); 1904169689Skan tree ref; 190518334Speter 1906169689Skan ref = build1 (INDIRECT_REF, t, pointer); 1907169689Skan 190890075Sobrien if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE) 190918334Speter { 191018334Speter error ("dereferencing pointer to incomplete type"); 191118334Speter return error_mark_node; 191218334Speter } 191390075Sobrien if (VOID_TYPE_P (t) && skip_evaluation == 0) 1914169689Skan warning (0, "dereferencing %<void *%> pointer"); 191518334Speter 191618334Speter /* We *must* set TREE_READONLY when dereferencing a pointer to const, 191718334Speter so that we get the proper error message if the result is used 191818334Speter to assign to. Also, &* is supposed to be a no-op. 191918334Speter And ANSI C seems to specify that the type of the result 192018334Speter should be the const type. */ 192118334Speter /* A de-reference of a pointer to const is not a const. It is valid 192218334Speter to change it via some other pointer. */ 192318334Speter TREE_READONLY (ref) = TYPE_READONLY (t); 192418334Speter TREE_SIDE_EFFECTS (ref) 1925132718Skan = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer); 192618334Speter TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t); 192718334Speter return ref; 192818334Speter } 192918334Speter } 193018334Speter else if (TREE_CODE (pointer) != ERROR_MARK) 1931259948Spfg error ("invalid type argument of %qs (have %qT)", errorstring, type); 193218334Speter return error_mark_node; 193318334Speter} 193418334Speter 193518334Speter/* This handles expressions of the form "a[i]", which denotes 193618334Speter an array reference. 193718334Speter 193818334Speter This is logically equivalent in C to *(a+i), but we may do it differently. 193918334Speter If A is a variable or a member, we generate a primitive ARRAY_REF. 194018334Speter This avoids forcing the array out of registers, and can work on 194118334Speter arrays that are not lvalues (for example, members of structures returned 194218334Speter by functions). */ 194318334Speter 194418334Spetertree 1945132718Skanbuild_array_ref (tree array, tree index) 194618334Speter{ 1947169689Skan bool swapped = false; 194818334Speter if (TREE_TYPE (array) == error_mark_node 194918334Speter || TREE_TYPE (index) == error_mark_node) 195018334Speter return error_mark_node; 195118334Speter 1952169689Skan if (TREE_CODE (TREE_TYPE (array)) != ARRAY_TYPE 1953169689Skan && TREE_CODE (TREE_TYPE (array)) != POINTER_TYPE) 195418334Speter { 1955169689Skan tree temp; 1956169689Skan if (TREE_CODE (TREE_TYPE (index)) != ARRAY_TYPE 1957169689Skan && TREE_CODE (TREE_TYPE (index)) != POINTER_TYPE) 195818334Speter { 1959169689Skan error ("subscripted value is neither array nor pointer"); 196018334Speter return error_mark_node; 196118334Speter } 1962169689Skan temp = array; 1963169689Skan array = index; 1964169689Skan index = temp; 1965169689Skan swapped = true; 1966169689Skan } 196718334Speter 1968169689Skan if (!INTEGRAL_TYPE_P (TREE_TYPE (index))) 1969169689Skan { 1970169689Skan error ("array subscript is not an integer"); 1971169689Skan return error_mark_node; 1972169689Skan } 1973169689Skan 1974169689Skan if (TREE_CODE (TREE_TYPE (TREE_TYPE (array))) == FUNCTION_TYPE) 1975169689Skan { 1976169689Skan error ("subscripted value is pointer to function"); 1977169689Skan return error_mark_node; 1978169689Skan } 1979169689Skan 1980169689Skan /* ??? Existing practice has been to warn only when the char 1981169689Skan index is syntactically the index, not for char[array]. */ 1982169689Skan if (!swapped) 1983169689Skan warn_array_subscript_with_type_char (index); 1984169689Skan 1985169689Skan /* Apply default promotions *after* noticing character types. */ 1986169689Skan index = default_conversion (index); 1987169689Skan 1988169689Skan gcc_assert (TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE); 1989169689Skan 1990169689Skan if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE) 1991169689Skan { 1992169689Skan tree rval, type; 1993169689Skan 199418334Speter /* An array that is indexed by a non-constant 199518334Speter cannot be stored in a register; we must be able to do 199618334Speter address arithmetic on its address. 199718334Speter Likewise an array of elements of variable size. */ 199818334Speter if (TREE_CODE (index) != INTEGER_CST 199990075Sobrien || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array))) 200018334Speter && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST)) 200118334Speter { 2002117395Skan if (!c_mark_addressable (array)) 200318334Speter return error_mark_node; 200418334Speter } 200518334Speter /* An array that is indexed by a constant value which is not within 200618334Speter the array bounds cannot be stored in a register either; because we 200718334Speter would get a crash in store_bit_field/extract_bit_field when trying 200818334Speter to access a non-existent part of the register. */ 200918334Speter if (TREE_CODE (index) == INTEGER_CST 2010169689Skan && TYPE_DOMAIN (TREE_TYPE (array)) 2011169689Skan && !int_fits_type_p (index, TYPE_DOMAIN (TREE_TYPE (array)))) 201218334Speter { 2013117395Skan if (!c_mark_addressable (array)) 201418334Speter return error_mark_node; 201518334Speter } 201618334Speter 201718334Speter if (pedantic) 201818334Speter { 201918334Speter tree foo = array; 202018334Speter while (TREE_CODE (foo) == COMPONENT_REF) 202118334Speter foo = TREE_OPERAND (foo, 0); 2022169689Skan if (TREE_CODE (foo) == VAR_DECL && C_DECL_REGISTER (foo)) 2023169689Skan pedwarn ("ISO C forbids subscripting %<register%> array"); 2024169689Skan else if (!flag_isoc99 && !lvalue_p (foo)) 2025117395Skan pedwarn ("ISO C90 forbids subscripting non-lvalue array"); 202618334Speter } 202718334Speter 2028169689Skan type = TREE_TYPE (TREE_TYPE (array)); 2029169689Skan if (TREE_CODE (type) != ARRAY_TYPE) 2030169689Skan type = TYPE_MAIN_VARIANT (type); 2031169689Skan rval = build4 (ARRAY_REF, type, array, index, NULL_TREE, NULL_TREE); 203218334Speter /* Array ref is const/volatile if the array elements are 2033169689Skan or if the array is. */ 203418334Speter TREE_READONLY (rval) 203518334Speter |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array))) 203618334Speter | TREE_READONLY (array)); 203718334Speter TREE_SIDE_EFFECTS (rval) 203818334Speter |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array))) 203918334Speter | TREE_SIDE_EFFECTS (array)); 204018334Speter TREE_THIS_VOLATILE (rval) 204118334Speter |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array))) 204218334Speter /* This was added by rms on 16 Nov 91. 2043132718Skan It fixes vol struct foo *a; a->elts[1] 204418334Speter in an inline function. 204518334Speter Hope it doesn't break something else. */ 204618334Speter | TREE_THIS_VOLATILE (array)); 204718334Speter return require_complete_type (fold (rval)); 204818334Speter } 2049169689Skan else 2050169689Skan { 2051169689Skan tree ar = default_conversion (array); 205218334Speter 2053169689Skan if (ar == error_mark_node) 2054169689Skan return ar; 205518334Speter 2056169689Skan gcc_assert (TREE_CODE (TREE_TYPE (ar)) == POINTER_TYPE); 2057169689Skan gcc_assert (TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) != FUNCTION_TYPE); 205850397Sobrien 2059169689Skan return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, index, 0), 2060169689Skan "array indexing"); 2061169689Skan } 206218334Speter} 206318334Speter 206490075Sobrien/* Build an external reference to identifier ID. FUN indicates 2065169689Skan whether this will be used for a function call. LOC is the source 2066169689Skan location of the identifier. */ 206790075Sobrientree 2068169689Skanbuild_external_ref (tree id, int fun, location_t loc) 206990075Sobrien{ 207090075Sobrien tree ref; 207190075Sobrien tree decl = lookup_name (id); 207290075Sobrien 2073169689Skan /* In Objective-C, an instance variable (ivar) may be preferred to 2074169689Skan whatever lookup_name() found. */ 2075169689Skan decl = objc_lookup_ivar (decl, id); 2076169689Skan 2077132718Skan if (decl && decl != error_mark_node) 2078169689Skan ref = decl; 2079132718Skan else if (fun) 2080132718Skan /* Implicit function declaration. */ 2081132718Skan ref = implicitly_declare (id); 2082132718Skan else if (decl == error_mark_node) 2083132718Skan /* Don't complain about something that's already been 2084132718Skan complained about. */ 2085132718Skan return error_mark_node; 2086132718Skan else 2087132718Skan { 2088169689Skan undeclared_variable (id, loc); 2089132718Skan return error_mark_node; 2090132718Skan } 209190075Sobrien 209290075Sobrien if (TREE_TYPE (ref) == error_mark_node) 209390075Sobrien return error_mark_node; 209490075Sobrien 2095132718Skan if (TREE_DEPRECATED (ref)) 2096132718Skan warn_deprecated_use (ref); 2097132718Skan 2098260919Spfg /* APPLE LOCAL begin "unavailable" attribute (radar 2809697) */ 2099260919Spfg if (TREE_UNAVAILABLE (ref)) 2100260919Spfg error_unavailable_use (ref); 2101260919Spfg /* APPLE LOCAL end "unavailable" attribute (radar 2809697) */ 2102260919Spfg 2103103445Skan if (!skip_evaluation) 2104103445Skan assemble_external (ref); 210590075Sobrien TREE_USED (ref) = 1; 210690075Sobrien 2107169689Skan if (TREE_CODE (ref) == FUNCTION_DECL && !in_alignof) 2108169689Skan { 2109169689Skan if (!in_sizeof && !in_typeof) 2110169689Skan C_DECL_USED (ref) = 1; 2111169689Skan else if (DECL_INITIAL (ref) == 0 2112169689Skan && DECL_EXTERNAL (ref) 2113169689Skan && !TREE_PUBLIC (ref)) 2114169689Skan record_maybe_used_decl (ref); 2115169689Skan } 2116169689Skan 211790075Sobrien if (TREE_CODE (ref) == CONST_DECL) 211890075Sobrien { 2119169689Skan used_types_insert (TREE_TYPE (ref)); 212090075Sobrien ref = DECL_INITIAL (ref); 212190075Sobrien TREE_CONSTANT (ref) = 1; 2122169689Skan TREE_INVARIANT (ref) = 1; 212390075Sobrien } 2124117395Skan else if (current_function_decl != 0 2125132718Skan && !DECL_FILE_SCOPE_P (current_function_decl) 2126117395Skan && (TREE_CODE (ref) == VAR_DECL 2127117395Skan || TREE_CODE (ref) == PARM_DECL 2128117395Skan || TREE_CODE (ref) == FUNCTION_DECL)) 2129117395Skan { 2130117395Skan tree context = decl_function_context (ref); 2131132718Skan 2132117395Skan if (context != 0 && context != current_function_decl) 2133117395Skan DECL_NONLOCAL (ref) = 1; 2134117395Skan } 2135189824Sdas /* C99 6.7.4p3: An inline definition of a function with external 2136189824Sdas linkage ... shall not contain a reference to an identifier with 2137189824Sdas internal linkage. */ 2138189824Sdas else if (current_function_decl != 0 2139189824Sdas && DECL_DECLARED_INLINE_P (current_function_decl) 2140189824Sdas && DECL_EXTERNAL (current_function_decl) 2141189824Sdas && VAR_OR_FUNCTION_DECL_P (ref) 2142189824Sdas && DECL_FILE_SCOPE_P (ref) 2143189824Sdas && pedantic 2144189824Sdas && (TREE_CODE (ref) != VAR_DECL || TREE_STATIC (ref)) 2145189824Sdas && ! TREE_PUBLIC (ref)) 2146189824Sdas pedwarn ("%H%qD is static but used in inline function %qD " 2147189824Sdas "which is not static", &loc, ref, current_function_decl); 214890075Sobrien 214990075Sobrien return ref; 215090075Sobrien} 215190075Sobrien 2152169689Skan/* Record details of decls possibly used inside sizeof or typeof. */ 2153169689Skanstruct maybe_used_decl 2154169689Skan{ 2155169689Skan /* The decl. */ 2156169689Skan tree decl; 2157169689Skan /* The level seen at (in_sizeof + in_typeof). */ 2158169689Skan int level; 2159169689Skan /* The next one at this level or above, or NULL. */ 2160169689Skan struct maybe_used_decl *next; 2161169689Skan}; 2162169689Skan 2163169689Skanstatic struct maybe_used_decl *maybe_used_decls; 2164169689Skan 2165169689Skan/* Record that DECL, an undefined static function reference seen 2166169689Skan inside sizeof or typeof, might be used if the operand of sizeof is 2167169689Skan a VLA type or the operand of typeof is a variably modified 2168169689Skan type. */ 2169169689Skan 2170169689Skanstatic void 2171169689Skanrecord_maybe_used_decl (tree decl) 2172169689Skan{ 2173169689Skan struct maybe_used_decl *t = XOBNEW (&parser_obstack, struct maybe_used_decl); 2174169689Skan t->decl = decl; 2175169689Skan t->level = in_sizeof + in_typeof; 2176169689Skan t->next = maybe_used_decls; 2177169689Skan maybe_used_decls = t; 2178169689Skan} 2179169689Skan 2180169689Skan/* Pop the stack of decls possibly used inside sizeof or typeof. If 2181169689Skan USED is false, just discard them. If it is true, mark them used 2182169689Skan (if no longer inside sizeof or typeof) or move them to the next 2183169689Skan level up (if still inside sizeof or typeof). */ 2184169689Skan 2185169689Skanvoid 2186169689Skanpop_maybe_used (bool used) 2187169689Skan{ 2188169689Skan struct maybe_used_decl *p = maybe_used_decls; 2189169689Skan int cur_level = in_sizeof + in_typeof; 2190169689Skan while (p && p->level > cur_level) 2191169689Skan { 2192169689Skan if (used) 2193169689Skan { 2194169689Skan if (cur_level == 0) 2195169689Skan C_DECL_USED (p->decl) = 1; 2196169689Skan else 2197169689Skan p->level = cur_level; 2198169689Skan } 2199169689Skan p = p->next; 2200169689Skan } 2201169689Skan if (!used || cur_level == 0) 2202169689Skan maybe_used_decls = p; 2203169689Skan} 2204169689Skan 2205169689Skan/* Return the result of sizeof applied to EXPR. */ 2206169689Skan 2207169689Skanstruct c_expr 2208169689Skanc_expr_sizeof_expr (struct c_expr expr) 2209169689Skan{ 2210169689Skan struct c_expr ret; 2211169689Skan if (expr.value == error_mark_node) 2212169689Skan { 2213169689Skan ret.value = error_mark_node; 2214169689Skan ret.original_code = ERROR_MARK; 2215169689Skan pop_maybe_used (false); 2216169689Skan } 2217169689Skan else 2218169689Skan { 2219169689Skan ret.value = c_sizeof (TREE_TYPE (expr.value)); 2220169689Skan ret.original_code = ERROR_MARK; 2221169689Skan if (c_vla_type_p (TREE_TYPE (expr.value))) 2222169689Skan { 2223169689Skan /* sizeof is evaluated when given a vla (C99 6.5.3.4p2). */ 2224169689Skan ret.value = build2 (COMPOUND_EXPR, TREE_TYPE (ret.value), expr.value, ret.value); 2225169689Skan } 2226169689Skan pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (expr.value))); 2227169689Skan } 2228169689Skan return ret; 2229169689Skan} 2230169689Skan 2231169689Skan/* Return the result of sizeof applied to T, a structure for the type 2232169689Skan name passed to sizeof (rather than the type itself). */ 2233169689Skan 2234169689Skanstruct c_expr 2235169689Skanc_expr_sizeof_type (struct c_type_name *t) 2236169689Skan{ 2237169689Skan tree type; 2238169689Skan struct c_expr ret; 2239169689Skan type = groktypename (t); 2240169689Skan ret.value = c_sizeof (type); 2241169689Skan ret.original_code = ERROR_MARK; 2242169689Skan pop_maybe_used (type != error_mark_node 2243169689Skan ? C_TYPE_VARIABLE_SIZE (type) : false); 2244169689Skan return ret; 2245169689Skan} 2246169689Skan 224718334Speter/* Build a function call to function FUNCTION with parameters PARAMS. 224818334Speter PARAMS is a list--a chain of TREE_LIST nodes--in which the 224918334Speter TREE_VALUE of each node is a parameter-expression. 225018334Speter FUNCTION's data type may be a function type or a pointer-to-function. */ 225118334Speter 225218334Spetertree 2253132718Skanbuild_function_call (tree function, tree params) 225418334Speter{ 225590075Sobrien tree fntype, fundecl = 0; 225690075Sobrien tree coerced_params; 2257132718Skan tree name = NULL_TREE, result; 2258132718Skan tree tem; 225918334Speter 226018334Speter /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */ 226118334Speter STRIP_TYPE_NOPS (function); 226218334Speter 226318334Speter /* Convert anything with function type to a pointer-to-function. */ 226418334Speter if (TREE_CODE (function) == FUNCTION_DECL) 226518334Speter { 2266169689Skan /* Implement type-directed function overloading for builtins. 2267169689Skan resolve_overloaded_builtin and targetm.resolve_overloaded_builtin 2268169689Skan handle all the type checking. The result is a complete expression 2269169689Skan that implements this function call. */ 2270169689Skan tem = resolve_overloaded_builtin (function, params); 2271169689Skan if (tem) 2272169689Skan return tem; 2273169689Skan 227418334Speter name = DECL_NAME (function); 227518334Speter fundecl = function; 227618334Speter } 2277169689Skan if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE) 2278169689Skan function = function_to_pointer_conversion (function); 227918334Speter 2280169689Skan /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF 2281169689Skan expressions, like those used for ObjC messenger dispatches. */ 2282169689Skan function = objc_rewrite_function_call (function, params); 2283169689Skan 228418334Speter fntype = TREE_TYPE (function); 228518334Speter 228618334Speter if (TREE_CODE (fntype) == ERROR_MARK) 228718334Speter return error_mark_node; 228818334Speter 228918334Speter if (!(TREE_CODE (fntype) == POINTER_TYPE 229018334Speter && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE)) 229118334Speter { 2292169689Skan error ("called object %qE is not a function", function); 229318334Speter return error_mark_node; 229418334Speter } 229518334Speter 229696263Sobrien if (fundecl && TREE_THIS_VOLATILE (fundecl)) 229796263Sobrien current_function_returns_abnormally = 1; 229896263Sobrien 229918334Speter /* fntype now gets the type of function pointed to. */ 230018334Speter fntype = TREE_TYPE (fntype); 230118334Speter 2302132718Skan /* Check that the function is called through a compatible prototype. 2303132718Skan If it is not, replace the call by a trap, wrapped up in a compound 2304132718Skan expression if necessary. This has the nice side-effect to prevent 2305132718Skan the tree-inliner from generating invalid assignment trees which may 2306169689Skan blow up in the RTL expander later. */ 2307169689Skan if ((TREE_CODE (function) == NOP_EXPR 2308169689Skan || TREE_CODE (function) == CONVERT_EXPR) 2309132718Skan && TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR 2310132718Skan && TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL 2311169689Skan && !comptypes (fntype, TREE_TYPE (tem))) 2312132718Skan { 2313132718Skan tree return_type = TREE_TYPE (fntype); 2314132718Skan tree trap = build_function_call (built_in_decls[BUILT_IN_TRAP], 2315132718Skan NULL_TREE); 2316132718Skan 2317132718Skan /* This situation leads to run-time undefined behavior. We can't, 2318132718Skan therefore, simply error unless we can prove that all possible 2319132718Skan executions of the program must execute the code. */ 2320169689Skan warning (0, "function called through a non-compatible type"); 2321132718Skan 2322132718Skan /* We can, however, treat "undefined" any way we please. 2323132718Skan Call abort to encourage the user to fix the program. */ 2324132718Skan inform ("if this code is reached, the program will abort"); 2325132718Skan 2326132718Skan if (VOID_TYPE_P (return_type)) 2327132718Skan return trap; 2328132718Skan else 2329132718Skan { 2330132718Skan tree rhs; 2331132718Skan 2332132718Skan if (AGGREGATE_TYPE_P (return_type)) 2333132718Skan rhs = build_compound_literal (return_type, 2334169689Skan build_constructor (return_type, 0)); 2335132718Skan else 2336169689Skan rhs = fold_convert (return_type, integer_zero_node); 2337132718Skan 2338169689Skan return build2 (COMPOUND_EXPR, return_type, trap, rhs); 2339132718Skan } 2340132718Skan } 2341132718Skan 234218334Speter /* Convert the parameters to the types declared in the 234318334Speter function prototype, or apply default promotions. */ 234418334Speter 234518334Speter coerced_params 2346169689Skan = convert_arguments (TYPE_ARG_TYPES (fntype), params, function, fundecl); 234718334Speter 2348169689Skan if (coerced_params == error_mark_node) 2349169689Skan return error_mark_node; 2350169689Skan 2351117395Skan /* Check that the arguments to the function are valid. */ 235218334Speter 2353169689Skan check_function_arguments (TYPE_ATTRIBUTES (fntype), coerced_params, 2354169689Skan TYPE_ARG_TYPES (fntype)); 235518334Speter 2356132718Skan if (require_constant_value) 2357132718Skan { 2358169689Skan result = fold_build3_initializer (CALL_EXPR, TREE_TYPE (fntype), 2359169689Skan function, coerced_params, NULL_TREE); 2360132718Skan 2361132718Skan if (TREE_CONSTANT (result) 2362132718Skan && (name == NULL_TREE 2363132718Skan || strncmp (IDENTIFIER_POINTER (name), "__builtin_", 10) != 0)) 2364132718Skan pedwarn_init ("initializer element is not constant"); 2365132718Skan } 2366132718Skan else 2367169689Skan result = fold_build3 (CALL_EXPR, TREE_TYPE (fntype), 2368169689Skan function, coerced_params, NULL_TREE); 2369132718Skan 237090075Sobrien if (VOID_TYPE_P (TREE_TYPE (result))) 237190075Sobrien return result; 237290075Sobrien return require_complete_type (result); 237318334Speter} 237418334Speter 237518334Speter/* Convert the argument expressions in the list VALUES 237618334Speter to the types in the list TYPELIST. The result is a list of converted 2377169689Skan argument expressions, unless there are too few arguments in which 2378169689Skan case it is error_mark_node. 237918334Speter 238018334Speter If TYPELIST is exhausted, or when an element has NULL as its type, 238118334Speter perform the default conversions. 238218334Speter 238318334Speter PARMLIST is the chain of parm decls for the function being called. 238418334Speter It may be 0, if that info is not available. 238518334Speter It is used only for generating error messages. 238618334Speter 2387169689Skan FUNCTION is a tree for the called function. It is used only for 2388169689Skan error messages, where it is formatted with %qE. 238918334Speter 239018334Speter This is also where warnings about wrong number of args are generated. 239118334Speter 239218334Speter Both VALUES and the returned value are chains of TREE_LIST nodes 239318334Speter with the elements of the list in the TREE_VALUE slots of those nodes. */ 239418334Speter 239518334Speterstatic tree 2396169689Skanconvert_arguments (tree typelist, tree values, tree function, tree fundecl) 239718334Speter{ 239890075Sobrien tree typetail, valtail; 239990075Sobrien tree result = NULL; 240018334Speter int parmnum; 2401169689Skan tree selector; 240218334Speter 2403169689Skan /* Change pointer to function to the function itself for 2404169689Skan diagnostics. */ 2405169689Skan if (TREE_CODE (function) == ADDR_EXPR 2406169689Skan && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL) 2407169689Skan function = TREE_OPERAND (function, 0); 2408169689Skan 2409169689Skan /* Handle an ObjC selector specially for diagnostics. */ 2410169689Skan selector = objc_message_selector (); 2411169689Skan 241218334Speter /* Scan the given expressions and types, producing individual 241318334Speter converted arguments and pushing them on RESULT in reverse order. */ 241418334Speter 241518334Speter for (valtail = values, typetail = typelist, parmnum = 0; 241618334Speter valtail; 241718334Speter valtail = TREE_CHAIN (valtail), parmnum++) 241818334Speter { 241990075Sobrien tree type = typetail ? TREE_VALUE (typetail) : 0; 242090075Sobrien tree val = TREE_VALUE (valtail); 2421169689Skan tree rname = function; 2422169689Skan int argnum = parmnum + 1; 2423169689Skan const char *invalid_func_diag; 242418334Speter 242518334Speter if (type == void_type_node) 242618334Speter { 2427169689Skan error ("too many arguments to function %qE", function); 242818334Speter break; 242918334Speter } 243018334Speter 2431169689Skan if (selector && argnum > 2) 2432169689Skan { 2433169689Skan rname = selector; 2434169689Skan argnum -= 2; 2435169689Skan } 243618334Speter 2437169689Skan STRIP_TYPE_NOPS (val); 243818334Speter 243918334Speter val = require_complete_type (val); 244018334Speter 244118334Speter if (type != 0) 244218334Speter { 244318334Speter /* Formal parm type is specified by a function prototype. */ 244418334Speter tree parmval; 244518334Speter 2446169689Skan if (type == error_mark_node || !COMPLETE_TYPE_P (type)) 244718334Speter { 244818334Speter error ("type of formal parameter %d is incomplete", parmnum + 1); 244918334Speter parmval = val; 245018334Speter } 245118334Speter else 245218334Speter { 245318334Speter /* Optionally warn about conversions that 245418334Speter differ from the default conversions. */ 245590075Sobrien if (warn_conversion || warn_traditional) 245618334Speter { 2457169689Skan unsigned int formal_prec = TYPE_PRECISION (type); 245818334Speter 245918334Speter if (INTEGRAL_TYPE_P (type) 246018334Speter && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) 2461169689Skan warning (0, "passing argument %d of %qE as integer " 2462169689Skan "rather than floating due to prototype", 2463169689Skan argnum, rname); 246490075Sobrien if (INTEGRAL_TYPE_P (type) 246590075Sobrien && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE) 2466169689Skan warning (0, "passing argument %d of %qE as integer " 2467169689Skan "rather than complex due to prototype", 2468169689Skan argnum, rname); 246918334Speter else if (TREE_CODE (type) == COMPLEX_TYPE 247018334Speter && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) 2471169689Skan warning (0, "passing argument %d of %qE as complex " 2472169689Skan "rather than floating due to prototype", 2473169689Skan argnum, rname); 247418334Speter else if (TREE_CODE (type) == REAL_TYPE 247518334Speter && INTEGRAL_TYPE_P (TREE_TYPE (val))) 2476169689Skan warning (0, "passing argument %d of %qE as floating " 2477169689Skan "rather than integer due to prototype", 2478169689Skan argnum, rname); 247990075Sobrien else if (TREE_CODE (type) == COMPLEX_TYPE 248090075Sobrien && INTEGRAL_TYPE_P (TREE_TYPE (val))) 2481169689Skan warning (0, "passing argument %d of %qE as complex " 2482169689Skan "rather than integer due to prototype", 2483169689Skan argnum, rname); 248418334Speter else if (TREE_CODE (type) == REAL_TYPE 248518334Speter && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE) 2486169689Skan warning (0, "passing argument %d of %qE as floating " 2487169689Skan "rather than complex due to prototype", 2488169689Skan argnum, rname); 248918334Speter /* ??? At some point, messages should be written about 249018334Speter conversions between complex types, but that's too messy 249118334Speter to do now. */ 249218334Speter else if (TREE_CODE (type) == REAL_TYPE 249318334Speter && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) 249418334Speter { 249518334Speter /* Warn if any argument is passed as `float', 249618334Speter since without a prototype it would be `double'. */ 2497169689Skan if (formal_prec == TYPE_PRECISION (float_type_node) 2498169689Skan && type != dfloat32_type_node) 2499169689Skan warning (0, "passing argument %d of %qE as %<float%> " 2500169689Skan "rather than %<double%> due to prototype", 2501169689Skan argnum, rname); 2502169689Skan 2503169689Skan /* Warn if mismatch between argument and prototype 2504169689Skan for decimal float types. Warn of conversions with 2505169689Skan binary float types and of precision narrowing due to 2506169689Skan prototype. */ 2507169689Skan else if (type != TREE_TYPE (val) 2508169689Skan && (type == dfloat32_type_node 2509169689Skan || type == dfloat64_type_node 2510169689Skan || type == dfloat128_type_node 2511169689Skan || TREE_TYPE (val) == dfloat32_type_node 2512169689Skan || TREE_TYPE (val) == dfloat64_type_node 2513169689Skan || TREE_TYPE (val) == dfloat128_type_node) 2514169689Skan && (formal_prec 2515169689Skan <= TYPE_PRECISION (TREE_TYPE (val)) 2516169689Skan || (type == dfloat128_type_node 2517169689Skan && (TREE_TYPE (val) 2518169689Skan != dfloat64_type_node 2519169689Skan && (TREE_TYPE (val) 2520169689Skan != dfloat32_type_node))) 2521169689Skan || (type == dfloat64_type_node 2522169689Skan && (TREE_TYPE (val) 2523169689Skan != dfloat32_type_node)))) 2524169689Skan warning (0, "passing argument %d of %qE as %qT " 2525169689Skan "rather than %qT due to prototype", 2526169689Skan argnum, rname, type, TREE_TYPE (val)); 2527169689Skan 252818334Speter } 252990075Sobrien /* Detect integer changing in width or signedness. 253090075Sobrien These warnings are only activated with 253190075Sobrien -Wconversion, not with -Wtraditional. */ 253290075Sobrien else if (warn_conversion && INTEGRAL_TYPE_P (type) 253318334Speter && INTEGRAL_TYPE_P (TREE_TYPE (val))) 253418334Speter { 253518334Speter tree would_have_been = default_conversion (val); 253618334Speter tree type1 = TREE_TYPE (would_have_been); 253718334Speter 253818334Speter if (TREE_CODE (type) == ENUMERAL_TYPE 253990075Sobrien && (TYPE_MAIN_VARIANT (type) 254090075Sobrien == TYPE_MAIN_VARIANT (TREE_TYPE (val)))) 254118334Speter /* No warning if function asks for enum 254218334Speter and the actual arg is that enum type. */ 254318334Speter ; 254418334Speter else if (formal_prec != TYPE_PRECISION (type1)) 2545169689Skan warning (OPT_Wconversion, "passing argument %d of %qE " 2546169689Skan "with different width due to prototype", 2547169689Skan argnum, rname); 2548169689Skan else if (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (type1)) 254918334Speter ; 255018334Speter /* Don't complain if the formal parameter type 255118334Speter is an enum, because we can't tell now whether 255218334Speter the value was an enum--even the same enum. */ 255318334Speter else if (TREE_CODE (type) == ENUMERAL_TYPE) 255418334Speter ; 255518334Speter else if (TREE_CODE (val) == INTEGER_CST 255618334Speter && int_fits_type_p (val, type)) 255718334Speter /* Change in signedness doesn't matter 255818334Speter if a constant value is unaffected. */ 255918334Speter ; 256018334Speter /* If the value is extended from a narrower 256118334Speter unsigned type, it doesn't matter whether we 256218334Speter pass it as signed or unsigned; the value 256318334Speter certainly is the same either way. */ 256418334Speter else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type) 2565169689Skan && TYPE_UNSIGNED (TREE_TYPE (val))) 256618334Speter ; 2567169689Skan else if (TYPE_UNSIGNED (type)) 2568169689Skan warning (OPT_Wconversion, "passing argument %d of %qE " 2569169689Skan "as unsigned due to prototype", 2570169689Skan argnum, rname); 257118334Speter else 2572169689Skan warning (OPT_Wconversion, "passing argument %d of %qE " 2573169689Skan "as signed due to prototype", argnum, rname); 257418334Speter } 257518334Speter } 257618334Speter 2577169689Skan parmval = convert_for_assignment (type, val, ic_argpass, 2578169689Skan fundecl, function, 2579169689Skan parmnum + 1); 2580132718Skan 2581132718Skan if (targetm.calls.promote_prototypes (fundecl ? TREE_TYPE (fundecl) : 0) 258290075Sobrien && INTEGRAL_TYPE_P (type) 258318334Speter && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))) 258418334Speter parmval = default_conversion (parmval); 258518334Speter } 258618334Speter result = tree_cons (NULL_TREE, parmval, result); 258718334Speter } 258818334Speter else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE 2589169689Skan && (TYPE_PRECISION (TREE_TYPE (val)) 2590169689Skan < TYPE_PRECISION (double_type_node)) 2591169689Skan && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (val)))) 259218334Speter /* Convert `float' to `double'. */ 259318334Speter result = tree_cons (NULL_TREE, convert (double_type_node, val), result); 2594169689Skan else if ((invalid_func_diag = 2595169689Skan targetm.calls.invalid_arg_for_unprototyped_fn (typelist, fundecl, val))) 2596169689Skan { 2597260012Spfg error (invalid_func_diag, ""); 2598169689Skan return error_mark_node; 2599169689Skan } 260018334Speter else 260118334Speter /* Convert `short' and `char' to full-size `int'. */ 260218334Speter result = tree_cons (NULL_TREE, default_conversion (val), result); 260318334Speter 260418334Speter if (typetail) 260518334Speter typetail = TREE_CHAIN (typetail); 260618334Speter } 260718334Speter 260818334Speter if (typetail != 0 && TREE_VALUE (typetail) != void_type_node) 260918334Speter { 2610169689Skan error ("too few arguments to function %qE", function); 2611169689Skan return error_mark_node; 261218334Speter } 261318334Speter 261418334Speter return nreverse (result); 261518334Speter} 261618334Speter 2617169689Skan/* This is the entry point used by the parser to build unary operators 2618169689Skan in the input. CODE, a tree_code, specifies the unary operator, and 2619169689Skan ARG is the operand. For unary plus, the C parser currently uses 2620169689Skan CONVERT_EXPR for code. */ 262118334Speter 2622169689Skanstruct c_expr 2623169689Skanparser_build_unary_op (enum tree_code code, struct c_expr arg) 262418334Speter{ 2625169689Skan struct c_expr result; 262618334Speter 2627169689Skan result.original_code = ERROR_MARK; 2628169689Skan result.value = build_unary_op (code, arg.value, 0); 2629259585Spfg 2630259585Spfg if (TREE_OVERFLOW_P (result.value) && !TREE_OVERFLOW_P (arg.value)) 2631259585Spfg overflow_warning (result.value); 2632259585Spfg 2633169689Skan return result; 2634169689Skan} 263518334Speter 2636169689Skan/* This is the entry point used by the parser to build binary operators 2637169689Skan in the input. CODE, a tree_code, specifies the binary operator, and 2638169689Skan ARG1 and ARG2 are the operands. In addition to constructing the 2639169689Skan expression, we check for operands that were written with other binary 2640169689Skan operators in a way that is likely to confuse the user. */ 264190075Sobrien 2642169689Skanstruct c_expr 2643169689Skanparser_build_binary_op (enum tree_code code, struct c_expr arg1, 2644169689Skan struct c_expr arg2) 2645169689Skan{ 2646169689Skan struct c_expr result; 264718334Speter 2648169689Skan enum tree_code code1 = arg1.original_code; 2649169689Skan enum tree_code code2 = arg2.original_code; 2650169689Skan 2651169689Skan result.value = build_binary_op (code, arg1.value, arg2.value, 1); 2652169689Skan result.original_code = code; 2653169689Skan 2654169689Skan if (TREE_CODE (result.value) == ERROR_MARK) 2655169689Skan return result; 2656169689Skan 265718334Speter /* Check for cases such as x+y<<z which users are likely 2658169689Skan to misinterpret. */ 265918334Speter if (warn_parentheses) 2660259269Spfg warn_about_parentheses (code, code1, code2); 266118334Speter 2662169689Skan /* Warn about comparisons against string literals, with the exception 2663169689Skan of testing for equality or inequality of a string literal with NULL. */ 2664169689Skan if (code == EQ_EXPR || code == NE_EXPR) 266518334Speter { 2666169689Skan if ((code1 == STRING_CST && !integer_zerop (arg2.value)) 2667169689Skan || (code2 == STRING_CST && !integer_zerop (arg1.value))) 2668169689Skan warning (OPT_Waddress, 2669169689Skan "comparison with string literal results in unspecified behaviour"); 267018334Speter } 2671169689Skan else if (TREE_CODE_CLASS (code) == tcc_comparison 2672169689Skan && (code1 == STRING_CST || code2 == STRING_CST)) 2673169689Skan warning (OPT_Waddress, 2674169689Skan "comparison with string literal results in unspecified behaviour"); 267518334Speter 2676259585Spfg if (TREE_OVERFLOW_P (result.value) 2677259585Spfg && !TREE_OVERFLOW_P (arg1.value) 2678259585Spfg && !TREE_OVERFLOW_P (arg2.value)) 2679259585Spfg overflow_warning (result.value); 2680169689Skan 268118334Speter return result; 268218334Speter} 268318334Speter 268418334Speter/* Return a tree for the difference of pointers OP0 and OP1. 268518334Speter The resulting tree has type int. */ 268618334Speter 268718334Speterstatic tree 2688132718Skanpointer_diff (tree op0, tree op1) 268918334Speter{ 269018334Speter tree restype = ptrdiff_type_node; 269118334Speter 269218334Speter tree target_type = TREE_TYPE (TREE_TYPE (op0)); 269390075Sobrien tree con0, con1, lit0, lit1; 269490075Sobrien tree orig_op1 = op1; 269518334Speter 269618334Speter if (pedantic || warn_pointer_arith) 269718334Speter { 269818334Speter if (TREE_CODE (target_type) == VOID_TYPE) 2699169689Skan pedwarn ("pointer of type %<void *%> used in subtraction"); 270018334Speter if (TREE_CODE (target_type) == FUNCTION_TYPE) 270118334Speter pedwarn ("pointer to a function used in subtraction"); 270218334Speter } 270318334Speter 270490075Sobrien /* If the conversion to ptrdiff_type does anything like widening or 270590075Sobrien converting a partial to an integral mode, we get a convert_expression 270690075Sobrien that is in the way to do any simplifications. 270790075Sobrien (fold-const.c doesn't know that the extra bits won't be needed. 270890075Sobrien split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a 270990075Sobrien different mode in place.) 271090075Sobrien So first try to find a common term here 'by hand'; we want to cover 271190075Sobrien at least the cases that occur in legal static initializers. */ 2712169689Skan if ((TREE_CODE (op0) == NOP_EXPR || TREE_CODE (op0) == CONVERT_EXPR) 2713169689Skan && (TYPE_PRECISION (TREE_TYPE (op0)) 2714169689Skan == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0))))) 2715169689Skan con0 = TREE_OPERAND (op0, 0); 2716169689Skan else 2717169689Skan con0 = op0; 2718169689Skan if ((TREE_CODE (op1) == NOP_EXPR || TREE_CODE (op1) == CONVERT_EXPR) 2719169689Skan && (TYPE_PRECISION (TREE_TYPE (op1)) 2720169689Skan == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0))))) 2721169689Skan con1 = TREE_OPERAND (op1, 0); 2722169689Skan else 2723169689Skan con1 = op1; 272490075Sobrien 272590075Sobrien if (TREE_CODE (con0) == PLUS_EXPR) 272690075Sobrien { 272790075Sobrien lit0 = TREE_OPERAND (con0, 1); 272890075Sobrien con0 = TREE_OPERAND (con0, 0); 272990075Sobrien } 273090075Sobrien else 273190075Sobrien lit0 = integer_zero_node; 273290075Sobrien 273390075Sobrien if (TREE_CODE (con1) == PLUS_EXPR) 273490075Sobrien { 273590075Sobrien lit1 = TREE_OPERAND (con1, 1); 273690075Sobrien con1 = TREE_OPERAND (con1, 0); 273790075Sobrien } 273890075Sobrien else 273990075Sobrien lit1 = integer_zero_node; 274090075Sobrien 274190075Sobrien if (operand_equal_p (con0, con1, 0)) 274290075Sobrien { 274390075Sobrien op0 = lit0; 274490075Sobrien op1 = lit1; 274590075Sobrien } 274690075Sobrien 274790075Sobrien 274818334Speter /* First do the subtraction as integers; 274950397Sobrien then drop through to build the divide operator. 275050397Sobrien Do not do default conversions on the minus operator 275150397Sobrien in case restype is a short type. */ 275218334Speter 275318334Speter op0 = build_binary_op (MINUS_EXPR, convert (restype, op0), 275450397Sobrien convert (restype, op1), 0); 275518334Speter /* This generates an error if op1 is pointer to incomplete type. */ 275690075Sobrien if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1)))) 275718334Speter error ("arithmetic on pointer to an incomplete type"); 275818334Speter 275918334Speter /* This generates an error if op0 is pointer to incomplete type. */ 276018334Speter op1 = c_size_in_bytes (target_type); 276118334Speter 276218334Speter /* Divide by the size, in easiest possible way. */ 2763169689Skan return fold_build2 (EXACT_DIV_EXPR, restype, op0, convert (restype, op1)); 276418334Speter} 276518334Speter 276618334Speter/* Construct and perhaps optimize a tree representation 276718334Speter for a unary operation. CODE, a tree_code, specifies the operation 276890075Sobrien and XARG is the operand. 276990075Sobrien For any CODE other than ADDR_EXPR, FLAG nonzero suppresses 277090075Sobrien the default promotions (such as from short to int). 277190075Sobrien For ADDR_EXPR, the default promotions are not applied; FLAG nonzero 277290075Sobrien allows non-lvalues; this is only used to handle conversion of non-lvalue 277390075Sobrien arrays to pointers in C99. */ 277418334Speter 277518334Spetertree 2776132718Skanbuild_unary_op (enum tree_code code, tree xarg, int flag) 277718334Speter{ 277818334Speter /* No default_conversion here. It causes trouble for ADDR_EXPR. */ 277990075Sobrien tree arg = xarg; 278090075Sobrien tree argtype = 0; 278190075Sobrien enum tree_code typecode = TREE_CODE (TREE_TYPE (arg)); 278218334Speter tree val; 278390075Sobrien int noconvert = flag; 2784169689Skan const char *invalid_op_diag; 278518334Speter 278618334Speter if (typecode == ERROR_MARK) 278718334Speter return error_mark_node; 278890075Sobrien if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE) 278918334Speter typecode = INTEGER_TYPE; 279018334Speter 2791169689Skan if ((invalid_op_diag 2792169689Skan = targetm.invalid_unary_op (code, TREE_TYPE (xarg)))) 2793169689Skan { 2794260012Spfg error (invalid_op_diag, ""); 2795169689Skan return error_mark_node; 2796169689Skan } 2797169689Skan 279818334Speter switch (code) 279918334Speter { 280018334Speter case CONVERT_EXPR: 280118334Speter /* This is used for unary plus, because a CONVERT_EXPR 280218334Speter is enough to prevent anybody from looking inside for 280318334Speter associativity, but won't generate any code. */ 280418334Speter if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE 2805169689Skan || typecode == COMPLEX_TYPE 2806169689Skan || typecode == VECTOR_TYPE)) 280752284Sobrien { 280852284Sobrien error ("wrong type argument to unary plus"); 280952284Sobrien return error_mark_node; 281052284Sobrien } 281118334Speter else if (!noconvert) 281218334Speter arg = default_conversion (arg); 2813117395Skan arg = non_lvalue (arg); 281418334Speter break; 281518334Speter 281618334Speter case NEGATE_EXPR: 281718334Speter if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE 2818117395Skan || typecode == COMPLEX_TYPE 2819117395Skan || typecode == VECTOR_TYPE)) 282052284Sobrien { 282152284Sobrien error ("wrong type argument to unary minus"); 282252284Sobrien return error_mark_node; 282352284Sobrien } 282418334Speter else if (!noconvert) 282518334Speter arg = default_conversion (arg); 282618334Speter break; 282718334Speter 282818334Speter case BIT_NOT_EXPR: 2829117395Skan if (typecode == INTEGER_TYPE || typecode == VECTOR_TYPE) 283018334Speter { 2831117395Skan if (!noconvert) 2832117395Skan arg = default_conversion (arg); 2833117395Skan } 2834117395Skan else if (typecode == COMPLEX_TYPE) 2835117395Skan { 283618334Speter code = CONJ_EXPR; 283790075Sobrien if (pedantic) 2838169689Skan pedwarn ("ISO C does not support %<~%> for complex conjugation"); 283918334Speter if (!noconvert) 284018334Speter arg = default_conversion (arg); 284118334Speter } 2842117395Skan else 284352284Sobrien { 284452284Sobrien error ("wrong type argument to bit-complement"); 284552284Sobrien return error_mark_node; 284652284Sobrien } 284718334Speter break; 284818334Speter 284918334Speter case ABS_EXPR: 2850132718Skan if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE)) 285152284Sobrien { 285252284Sobrien error ("wrong type argument to abs"); 285352284Sobrien return error_mark_node; 285452284Sobrien } 285518334Speter else if (!noconvert) 285618334Speter arg = default_conversion (arg); 285718334Speter break; 285818334Speter 285918334Speter case CONJ_EXPR: 286018334Speter /* Conjugating a real value is a no-op, but allow it anyway. */ 286118334Speter if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE 286218334Speter || typecode == COMPLEX_TYPE)) 286352284Sobrien { 286452284Sobrien error ("wrong type argument to conjugation"); 286552284Sobrien return error_mark_node; 286652284Sobrien } 286718334Speter else if (!noconvert) 286818334Speter arg = default_conversion (arg); 286918334Speter break; 287018334Speter 287118334Speter case TRUTH_NOT_EXPR: 287218334Speter if (typecode != INTEGER_TYPE 287318334Speter && typecode != REAL_TYPE && typecode != POINTER_TYPE 2874169689Skan && typecode != COMPLEX_TYPE) 287518334Speter { 287652284Sobrien error ("wrong type argument to unary exclamation mark"); 287752284Sobrien return error_mark_node; 287818334Speter } 2879169689Skan arg = c_objc_common_truthvalue_conversion (arg); 288018334Speter return invert_truthvalue (arg); 288118334Speter 288218334Speter case REALPART_EXPR: 288318334Speter if (TREE_CODE (arg) == COMPLEX_CST) 288418334Speter return TREE_REALPART (arg); 288518334Speter else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE) 2886169689Skan return fold_build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg); 288718334Speter else 288818334Speter return arg; 288918334Speter 289018334Speter case IMAGPART_EXPR: 289118334Speter if (TREE_CODE (arg) == COMPLEX_CST) 289218334Speter return TREE_IMAGPART (arg); 289318334Speter else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE) 2894169689Skan return fold_build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg); 289518334Speter else 289618334Speter return convert (TREE_TYPE (arg), integer_zero_node); 2897132718Skan 289818334Speter case PREINCREMENT_EXPR: 289918334Speter case POSTINCREMENT_EXPR: 290018334Speter case PREDECREMENT_EXPR: 290118334Speter case POSTDECREMENT_EXPR: 290218334Speter 290318334Speter /* Increment or decrement the real part of the value, 290418334Speter and don't change the imaginary part. */ 290518334Speter if (typecode == COMPLEX_TYPE) 290618334Speter { 290718334Speter tree real, imag; 290818334Speter 290990075Sobrien if (pedantic) 2910169689Skan pedwarn ("ISO C does not support %<++%> and %<--%>" 2911169689Skan " on complex types"); 291290075Sobrien 291318334Speter arg = stabilize_reference (arg); 291418334Speter real = build_unary_op (REALPART_EXPR, arg, 1); 291518334Speter imag = build_unary_op (IMAGPART_EXPR, arg, 1); 2916169689Skan return build2 (COMPLEX_EXPR, TREE_TYPE (arg), 2917169689Skan build_unary_op (code, real, 1), imag); 291818334Speter } 291918334Speter 292018334Speter /* Report invalid types. */ 292118334Speter 292218334Speter if (typecode != POINTER_TYPE 292318334Speter && typecode != INTEGER_TYPE && typecode != REAL_TYPE) 292418334Speter { 292590075Sobrien if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) 2926169689Skan error ("wrong type argument to increment"); 2927169689Skan else 2928169689Skan error ("wrong type argument to decrement"); 292990075Sobrien 293052284Sobrien return error_mark_node; 293118334Speter } 293218334Speter 293318334Speter { 293490075Sobrien tree inc; 293518334Speter tree result_type = TREE_TYPE (arg); 293618334Speter 2937117395Skan arg = get_unwidened (arg, 0); 2938117395Skan argtype = TREE_TYPE (arg); 2939117395Skan 294018334Speter /* Compute the increment. */ 294118334Speter 294218334Speter if (typecode == POINTER_TYPE) 294318334Speter { 294418334Speter /* If pointer target is an undefined struct, 294518334Speter we just cannot know how to do the arithmetic. */ 294690075Sobrien if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type))) 294790075Sobrien { 294890075Sobrien if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) 294990075Sobrien error ("increment of pointer to unknown structure"); 295090075Sobrien else 295190075Sobrien error ("decrement of pointer to unknown structure"); 295290075Sobrien } 295318334Speter else if ((pedantic || warn_pointer_arith) 295418334Speter && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE 295518334Speter || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)) 2956169689Skan { 295790075Sobrien if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) 295890075Sobrien pedwarn ("wrong type argument to increment"); 295990075Sobrien else 296090075Sobrien pedwarn ("wrong type argument to decrement"); 296190075Sobrien } 296290075Sobrien 296318334Speter inc = c_size_in_bytes (TREE_TYPE (result_type)); 296418334Speter } 296518334Speter else 296618334Speter inc = integer_one_node; 296718334Speter 296818334Speter inc = convert (argtype, inc); 296918334Speter 297018334Speter /* Complain about anything else that is not a true lvalue. */ 297118334Speter if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR 297218334Speter || code == POSTINCREMENT_EXPR) 2973169689Skan ? lv_increment 2974169689Skan : lv_decrement))) 297518334Speter return error_mark_node; 297618334Speter 297718334Speter /* Report a read-only lvalue. */ 297818334Speter if (TREE_READONLY (arg)) 2979169689Skan { 2980169689Skan readonly_error (arg, 2981169689Skan ((code == PREINCREMENT_EXPR 2982169689Skan || code == POSTINCREMENT_EXPR) 2983169689Skan ? lv_increment : lv_decrement)); 2984169689Skan return error_mark_node; 2985169689Skan } 298618334Speter 298790075Sobrien if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE) 298890075Sobrien val = boolean_increment (code, arg); 298990075Sobrien else 2990169689Skan val = build2 (code, TREE_TYPE (arg), arg, inc); 299118334Speter TREE_SIDE_EFFECTS (val) = 1; 299218334Speter val = convert (result_type, val); 299318334Speter if (TREE_CODE (val) != code) 2994169689Skan TREE_NO_WARNING (val) = 1; 299518334Speter return val; 299618334Speter } 299718334Speter 299818334Speter case ADDR_EXPR: 299990075Sobrien /* Note that this operation never does default_conversion. */ 300018334Speter 300118334Speter /* Let &* cancel out to simplify resulting code. */ 300218334Speter if (TREE_CODE (arg) == INDIRECT_REF) 300318334Speter { 300418334Speter /* Don't let this be an lvalue. */ 300518334Speter if (lvalue_p (TREE_OPERAND (arg, 0))) 300618334Speter return non_lvalue (TREE_OPERAND (arg, 0)); 300718334Speter return TREE_OPERAND (arg, 0); 300818334Speter } 300918334Speter 301018334Speter /* For &x[y], return x+y */ 301118334Speter if (TREE_CODE (arg) == ARRAY_REF) 301218334Speter { 3013169689Skan tree op0 = TREE_OPERAND (arg, 0); 3014169689Skan if (!c_mark_addressable (op0)) 301518334Speter return error_mark_node; 3016169689Skan return build_binary_op (PLUS_EXPR, 3017169689Skan (TREE_CODE (TREE_TYPE (op0)) == ARRAY_TYPE 3018169689Skan ? array_to_pointer_conversion (op0) 3019169689Skan : op0), 302018334Speter TREE_OPERAND (arg, 1), 1); 302118334Speter } 302218334Speter 302318334Speter /* Anything not already handled and not a true memory reference 302490075Sobrien or a non-lvalue array is an error. */ 302590075Sobrien else if (typecode != FUNCTION_TYPE && !flag 3026169689Skan && !lvalue_or_else (arg, lv_addressof)) 302718334Speter return error_mark_node; 302818334Speter 302918334Speter /* Ordinary case; arg is a COMPONENT_REF or a decl. */ 303018334Speter argtype = TREE_TYPE (arg); 303190075Sobrien 303252284Sobrien /* If the lvalue is const or volatile, merge that into the type 3033169689Skan to which the address will point. Note that you can't get a 303452284Sobrien restricted pointer by taking the address of something, so we 303552284Sobrien only have to deal with `const' and `volatile' here. */ 3036169689Skan if ((DECL_P (arg) || REFERENCE_CLASS_P (arg)) 303790075Sobrien && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg))) 303890075Sobrien argtype = c_build_type_variant (argtype, 303990075Sobrien TREE_READONLY (arg), 304090075Sobrien TREE_THIS_VOLATILE (arg)); 304118334Speter 3042117395Skan if (!c_mark_addressable (arg)) 304318334Speter return error_mark_node; 304418334Speter 3045169689Skan gcc_assert (TREE_CODE (arg) != COMPONENT_REF 3046169689Skan || !DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1))); 304718334Speter 3048169689Skan argtype = build_pointer_type (argtype); 304918334Speter 3050169689Skan /* ??? Cope with user tricks that amount to offsetof. Delete this 3051169689Skan when we have proper support for integer constant expressions. */ 3052169689Skan val = get_base_address (arg); 3053169689Skan if (val && TREE_CODE (val) == INDIRECT_REF 3054169689Skan && TREE_CONSTANT (TREE_OPERAND (val, 0))) 3055169689Skan { 3056169689Skan tree op0 = fold_convert (argtype, fold_offsetof (arg, val)), op1; 305718334Speter 3058169689Skan op1 = fold_convert (argtype, TREE_OPERAND (val, 0)); 3059169689Skan return fold_build2 (PLUS_EXPR, argtype, op0, op1); 3060169689Skan } 306118334Speter 3062169689Skan val = build1 (ADDR_EXPR, argtype, arg); 306318334Speter 3064169689Skan return val; 306550397Sobrien 306650397Sobrien default: 3067169689Skan gcc_unreachable (); 306818334Speter } 306918334Speter 307052284Sobrien if (argtype == 0) 307152284Sobrien argtype = TREE_TYPE (arg); 3072169689Skan return require_constant_value ? fold_build1_initializer (code, argtype, arg) 3073169689Skan : fold_build1 (code, argtype, arg); 307418334Speter} 307518334Speter 307618334Speter/* Return nonzero if REF is an lvalue valid for this language. 307718334Speter Lvalues can be assigned, unless their type has TYPE_READONLY. 3078169689Skan Lvalues can have their address taken, unless they have C_DECL_REGISTER. */ 307918334Speter 3080169689Skanstatic int 3081132718Skanlvalue_p (tree ref) 308218334Speter{ 308390075Sobrien enum tree_code code = TREE_CODE (ref); 308418334Speter 308518334Speter switch (code) 308618334Speter { 308718334Speter case REALPART_EXPR: 308818334Speter case IMAGPART_EXPR: 308918334Speter case COMPONENT_REF: 309018334Speter return lvalue_p (TREE_OPERAND (ref, 0)); 309118334Speter 309290075Sobrien case COMPOUND_LITERAL_EXPR: 309318334Speter case STRING_CST: 309418334Speter return 1; 309518334Speter 309618334Speter case INDIRECT_REF: 309718334Speter case ARRAY_REF: 309818334Speter case VAR_DECL: 309918334Speter case PARM_DECL: 310018334Speter case RESULT_DECL: 310118334Speter case ERROR_MARK: 310250397Sobrien return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE 310350397Sobrien && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE); 310450397Sobrien 310550397Sobrien case BIND_EXPR: 310650397Sobrien return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE; 310750397Sobrien 310850397Sobrien default: 310950397Sobrien return 0; 311018334Speter } 311118334Speter} 3112169689Skan 3113169689Skan/* Give an error for storing in something that is 'const'. */ 311418334Speter 311518334Speterstatic void 3116169689Skanreadonly_error (tree arg, enum lvalue_use use) 311718334Speter{ 3118169689Skan gcc_assert (use == lv_assign || use == lv_increment || use == lv_decrement 3119169689Skan || use == lv_asm); 3120169689Skan /* Using this macro rather than (for example) arrays of messages 3121169689Skan ensures that all the format strings are checked at compile 3122169689Skan time. */ 3123169689Skan#define READONLY_MSG(A, I, D, AS) (use == lv_assign ? (A) \ 3124169689Skan : (use == lv_increment ? (I) \ 3125169689Skan : (use == lv_decrement ? (D) : (AS)))) 312618334Speter if (TREE_CODE (arg) == COMPONENT_REF) 312718334Speter { 312818334Speter if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0)))) 3129169689Skan readonly_error (TREE_OPERAND (arg, 0), use); 313018334Speter else 3131169689Skan error (READONLY_MSG (G_("assignment of read-only member %qD"), 3132169689Skan G_("increment of read-only member %qD"), 3133169689Skan G_("decrement of read-only member %qD"), 3134169689Skan G_("read-only member %qD used as %<asm%> output")), 3135169689Skan TREE_OPERAND (arg, 1)); 313618334Speter } 313718334Speter else if (TREE_CODE (arg) == VAR_DECL) 3138169689Skan error (READONLY_MSG (G_("assignment of read-only variable %qD"), 3139169689Skan G_("increment of read-only variable %qD"), 3140169689Skan G_("decrement of read-only variable %qD"), 3141169689Skan G_("read-only variable %qD used as %<asm%> output")), 3142169689Skan arg); 314318334Speter else 3144169689Skan error (READONLY_MSG (G_("assignment of read-only location"), 3145169689Skan G_("increment of read-only location"), 3146169689Skan G_("decrement of read-only location"), 3147169689Skan G_("read-only location used as %<asm%> output"))); 314818334Speter} 3149169689Skan 3150169689Skan 3151169689Skan/* Return nonzero if REF is an lvalue valid for this language; 3152169689Skan otherwise, print an error message and return zero. USE says 3153169689Skan how the lvalue is being used and so selects the error message. */ 3154169689Skan 3155169689Skanstatic int 3156169689Skanlvalue_or_else (tree ref, enum lvalue_use use) 3157169689Skan{ 3158169689Skan int win = lvalue_p (ref); 3159169689Skan 3160169689Skan if (!win) 3161169689Skan lvalue_error (use); 3162169689Skan 3163169689Skan return win; 3164169689Skan} 316518334Speter 316618334Speter/* Mark EXP saying that we need to be able to take the 316718334Speter address of it; it should not be allocated in a register. 3168117395Skan Returns true if successful. */ 316918334Speter 3170117395Skanbool 3171132718Skanc_mark_addressable (tree exp) 317218334Speter{ 317390075Sobrien tree x = exp; 3174117395Skan 317518334Speter while (1) 317618334Speter switch (TREE_CODE (x)) 317718334Speter { 317850397Sobrien case COMPONENT_REF: 317950397Sobrien if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1))) 318050397Sobrien { 3181169689Skan error 3182169689Skan ("cannot take address of bit-field %qD", TREE_OPERAND (x, 1)); 3183117395Skan return false; 318450397Sobrien } 318550397Sobrien 318650397Sobrien /* ... fall through ... */ 318750397Sobrien 318818334Speter case ADDR_EXPR: 318918334Speter case ARRAY_REF: 319018334Speter case REALPART_EXPR: 319118334Speter case IMAGPART_EXPR: 319218334Speter x = TREE_OPERAND (x, 0); 319318334Speter break; 319418334Speter 319590075Sobrien case COMPOUND_LITERAL_EXPR: 319618334Speter case CONSTRUCTOR: 319718334Speter TREE_ADDRESSABLE (x) = 1; 3198117395Skan return true; 319918334Speter 320018334Speter case VAR_DECL: 320118334Speter case CONST_DECL: 320218334Speter case PARM_DECL: 320318334Speter case RESULT_DECL: 3204169689Skan if (C_DECL_REGISTER (x) 320518334Speter && DECL_NONLOCAL (x)) 320618334Speter { 3207132718Skan if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x)) 320818334Speter { 3209169689Skan error 3210169689Skan ("global register variable %qD used in nested function", x); 3211117395Skan return false; 321218334Speter } 3213169689Skan pedwarn ("register variable %qD used in nested function", x); 321418334Speter } 3215169689Skan else if (C_DECL_REGISTER (x)) 321618334Speter { 3217132718Skan if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x)) 3218169689Skan error ("address of global register variable %qD requested", x); 3219169689Skan else 3220169689Skan error ("address of register variable %qD requested", x); 3221169689Skan return false; 322218334Speter } 322318334Speter 322418334Speter /* drops in */ 322518334Speter case FUNCTION_DECL: 322618334Speter TREE_ADDRESSABLE (x) = 1; 3227132718Skan /* drops out */ 322818334Speter default: 3229117395Skan return true; 323018334Speter } 323118334Speter} 323218334Speter 323318334Speter/* Build and return a conditional expression IFEXP ? OP1 : OP2. */ 323418334Speter 323518334Spetertree 3236132718Skanbuild_conditional_expr (tree ifexp, tree op1, tree op2) 323718334Speter{ 323890075Sobrien tree type1; 323990075Sobrien tree type2; 324090075Sobrien enum tree_code code1; 324190075Sobrien enum tree_code code2; 324290075Sobrien tree result_type = NULL; 324318334Speter tree orig_op1 = op1, orig_op2 = op2; 324418334Speter 324518334Speter /* Promote both alternatives. */ 324618334Speter 324718334Speter if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE) 324818334Speter op1 = default_conversion (op1); 324918334Speter if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE) 325018334Speter op2 = default_conversion (op2); 325118334Speter 325218334Speter if (TREE_CODE (ifexp) == ERROR_MARK 325318334Speter || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK 325418334Speter || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK) 325518334Speter return error_mark_node; 325618334Speter 325718334Speter type1 = TREE_TYPE (op1); 325818334Speter code1 = TREE_CODE (type1); 325918334Speter type2 = TREE_TYPE (op2); 326018334Speter code2 = TREE_CODE (type2); 3261132718Skan 3262169689Skan /* C90 does not permit non-lvalue arrays in conditional expressions. 3263169689Skan In C99 they will be pointers by now. */ 3264169689Skan if (code1 == ARRAY_TYPE || code2 == ARRAY_TYPE) 3265169689Skan { 3266169689Skan error ("non-lvalue array in conditional expression"); 3267169689Skan return error_mark_node; 3268169689Skan } 3269169689Skan 327018334Speter /* Quickly detect the usual case where op1 and op2 have the same type 327118334Speter after promotion. */ 327218334Speter if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2)) 327318334Speter { 327418334Speter if (type1 == type2) 327518334Speter result_type = type1; 327618334Speter else 327718334Speter result_type = TYPE_MAIN_VARIANT (type1); 327818334Speter } 327990075Sobrien else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE 3280169689Skan || code1 == COMPLEX_TYPE) 3281169689Skan && (code2 == INTEGER_TYPE || code2 == REAL_TYPE 3282169689Skan || code2 == COMPLEX_TYPE)) 328318334Speter { 3284169689Skan result_type = c_common_type (type1, type2); 328590075Sobrien 328690075Sobrien /* If -Wsign-compare, warn here if type1 and type2 have 328790075Sobrien different signedness. We'll promote the signed to unsigned 328890075Sobrien and later code won't know it used to be different. 328990075Sobrien Do this check on the original types, so that explicit casts 329090075Sobrien will be considered, but default promotions won't. */ 3291132718Skan if (warn_sign_compare && !skip_evaluation) 329290075Sobrien { 3293169689Skan int unsigned_op1 = TYPE_UNSIGNED (TREE_TYPE (orig_op1)); 3294169689Skan int unsigned_op2 = TYPE_UNSIGNED (TREE_TYPE (orig_op2)); 329590075Sobrien 329690075Sobrien if (unsigned_op1 ^ unsigned_op2) 329790075Sobrien { 3298169689Skan bool ovf; 3299169689Skan 330090075Sobrien /* Do not warn if the result type is signed, since the 330190075Sobrien signed type will only be chosen if it can represent 330290075Sobrien all the values of the unsigned type. */ 3303169689Skan if (!TYPE_UNSIGNED (result_type)) 330490075Sobrien /* OK */; 330590075Sobrien /* Do not warn if the signed quantity is an unsuffixed 330690075Sobrien integer literal (or some static constant expression 330790075Sobrien involving such literals) and it is non-negative. */ 3308169689Skan else if ((unsigned_op2 3309169689Skan && tree_expr_nonnegative_warnv_p (op1, &ovf)) 3310169689Skan || (unsigned_op1 3311169689Skan && tree_expr_nonnegative_warnv_p (op2, &ovf))) 331290075Sobrien /* OK */; 331390075Sobrien else 3314169689Skan warning (0, "signed and unsigned type in conditional expression"); 331590075Sobrien } 331690075Sobrien } 331718334Speter } 331818334Speter else if (code1 == VOID_TYPE || code2 == VOID_TYPE) 331918334Speter { 332018334Speter if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE)) 332190075Sobrien pedwarn ("ISO C forbids conditional expr with only one void side"); 332218334Speter result_type = void_type_node; 332318334Speter } 332418334Speter else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE) 332518334Speter { 3326169689Skan if (comp_target_types (type1, type2)) 3327169689Skan result_type = common_pointer_type (type1, type2); 3328169689Skan else if (null_pointer_constant_p (orig_op1)) 332918334Speter result_type = qualify_type (type2, type1); 3330169689Skan else if (null_pointer_constant_p (orig_op2)) 333118334Speter result_type = qualify_type (type1, type2); 333290075Sobrien else if (VOID_TYPE_P (TREE_TYPE (type1))) 333318334Speter { 333418334Speter if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE) 3335169689Skan pedwarn ("ISO C forbids conditional expr between " 3336169689Skan "%<void *%> and function pointer"); 333790075Sobrien result_type = build_pointer_type (qualify_type (TREE_TYPE (type1), 333890075Sobrien TREE_TYPE (type2))); 333918334Speter } 334090075Sobrien else if (VOID_TYPE_P (TREE_TYPE (type2))) 334118334Speter { 334218334Speter if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE) 3343169689Skan pedwarn ("ISO C forbids conditional expr between " 3344169689Skan "%<void *%> and function pointer"); 334590075Sobrien result_type = build_pointer_type (qualify_type (TREE_TYPE (type2), 334690075Sobrien TREE_TYPE (type1))); 334718334Speter } 334818334Speter else 334918334Speter { 335018334Speter pedwarn ("pointer type mismatch in conditional expression"); 335118334Speter result_type = build_pointer_type (void_type_node); 335218334Speter } 335318334Speter } 335418334Speter else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE) 335518334Speter { 3356169689Skan if (!null_pointer_constant_p (orig_op2)) 335718334Speter pedwarn ("pointer/integer type mismatch in conditional expression"); 335818334Speter else 335918334Speter { 336018334Speter op2 = null_pointer_node; 336118334Speter } 336218334Speter result_type = type1; 336318334Speter } 336418334Speter else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE) 336518334Speter { 3366169689Skan if (!null_pointer_constant_p (orig_op1)) 336718334Speter pedwarn ("pointer/integer type mismatch in conditional expression"); 336818334Speter else 336918334Speter { 337018334Speter op1 = null_pointer_node; 337118334Speter } 337218334Speter result_type = type2; 337318334Speter } 337418334Speter 337518334Speter if (!result_type) 337618334Speter { 337718334Speter if (flag_cond_mismatch) 337818334Speter result_type = void_type_node; 337918334Speter else 338018334Speter { 338118334Speter error ("type mismatch in conditional expression"); 338218334Speter return error_mark_node; 338318334Speter } 338418334Speter } 338518334Speter 338618334Speter /* Merge const and volatile flags of the incoming types. */ 338718334Speter result_type 338818334Speter = build_type_variant (result_type, 338918334Speter TREE_READONLY (op1) || TREE_READONLY (op2), 339018334Speter TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2)); 339118334Speter 339218334Speter if (result_type != TREE_TYPE (op1)) 339318334Speter op1 = convert_and_check (result_type, op1); 339418334Speter if (result_type != TREE_TYPE (op2)) 339518334Speter op2 = convert_and_check (result_type, op2); 3396132718Skan 3397169689Skan return fold_build3 (COND_EXPR, result_type, ifexp, op1, op2); 339818334Speter} 339918334Speter 3400169689Skan/* Return a compound expression that performs two expressions and 3401169689Skan returns the value of the second of them. */ 340218334Speter 340318334Spetertree 3404169689Skanbuild_compound_expr (tree expr1, tree expr2) 340518334Speter{ 3406169689Skan if (!TREE_SIDE_EFFECTS (expr1)) 340718334Speter { 340818334Speter /* The left-hand operand of a comma expression is like an expression 3409169689Skan statement: with -Wextra or -Wunused, we should warn if it doesn't have 341018334Speter any side-effects, unless it was explicitly cast to (void). */ 3411169689Skan if (warn_unused_value) 3412169689Skan { 3413169689Skan if (VOID_TYPE_P (TREE_TYPE (expr1)) 3414169689Skan && (TREE_CODE (expr1) == NOP_EXPR 3415169689Skan || TREE_CODE (expr1) == CONVERT_EXPR)) 3416169689Skan ; /* (void) a, b */ 3417169689Skan else if (VOID_TYPE_P (TREE_TYPE (expr1)) 3418169689Skan && TREE_CODE (expr1) == COMPOUND_EXPR 3419169689Skan && (TREE_CODE (TREE_OPERAND (expr1, 1)) == CONVERT_EXPR 3420169689Skan || TREE_CODE (TREE_OPERAND (expr1, 1)) == NOP_EXPR)) 3421169689Skan ; /* (void) a, (void) b, c */ 3422169689Skan else 3423169689Skan warning (0, "left-hand operand of comma expression has no effect"); 3424169689Skan } 342518334Speter } 342618334Speter 342718334Speter /* With -Wunused, we should also warn if the left-hand operand does have 342818334Speter side-effects, but computes a value which is not used. For example, in 342918334Speter `foo() + bar(), baz()' the result of the `+' operator is not used, 343018334Speter so we should issue a warning. */ 343190075Sobrien else if (warn_unused_value) 3432169689Skan warn_if_unused_value (expr1, input_location); 343318334Speter 3434169689Skan if (expr2 == error_mark_node) 3435169689Skan return error_mark_node; 3436169689Skan 3437169689Skan return build2 (COMPOUND_EXPR, TREE_TYPE (expr2), expr1, expr2); 343818334Speter} 343918334Speter 344018334Speter/* Build an expression representing a cast to type TYPE of expression EXPR. */ 344118334Speter 344218334Spetertree 3443132718Skanbuild_c_cast (tree type, tree expr) 344418334Speter{ 344590075Sobrien tree value = expr; 3446132718Skan 344718334Speter if (type == error_mark_node || expr == error_mark_node) 344818334Speter return error_mark_node; 344918334Speter 3450117395Skan /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing 3451117395Skan only in <protocol> qualifications. But when constructing cast expressions, 3452117395Skan the protocols do matter and must be kept around. */ 3453169689Skan if (objc_is_object_ptr (type) && objc_is_object_ptr (TREE_TYPE (expr))) 3454169689Skan return build1 (NOP_EXPR, type, expr); 3455117395Skan 3456169689Skan type = TYPE_MAIN_VARIANT (type); 3457169689Skan 345818334Speter if (TREE_CODE (type) == ARRAY_TYPE) 345918334Speter { 346018334Speter error ("cast specifies array type"); 346118334Speter return error_mark_node; 346218334Speter } 346318334Speter 346418334Speter if (TREE_CODE (type) == FUNCTION_TYPE) 346518334Speter { 346618334Speter error ("cast specifies function type"); 346718334Speter return error_mark_node; 346818334Speter } 346918334Speter 347090075Sobrien if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value))) 347118334Speter { 347218334Speter if (pedantic) 347318334Speter { 347418334Speter if (TREE_CODE (type) == RECORD_TYPE 347518334Speter || TREE_CODE (type) == UNION_TYPE) 347690075Sobrien pedwarn ("ISO C forbids casting nonscalar to the same type"); 347718334Speter } 347818334Speter } 347918334Speter else if (TREE_CODE (type) == UNION_TYPE) 348018334Speter { 348118334Speter tree field; 348218334Speter 348318334Speter for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 348418334Speter if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)), 3485169689Skan TYPE_MAIN_VARIANT (TREE_TYPE (value)))) 348618334Speter break; 348718334Speter 348818334Speter if (field) 348918334Speter { 349018334Speter tree t; 349118334Speter 349218334Speter if (pedantic) 349390075Sobrien pedwarn ("ISO C forbids casts to union type"); 3494132718Skan t = digest_init (type, 3495169689Skan build_constructor_single (type, field, value), 3496169689Skan true, 0); 349718334Speter TREE_CONSTANT (t) = TREE_CONSTANT (value); 3498169689Skan TREE_INVARIANT (t) = TREE_INVARIANT (value); 349918334Speter return t; 350018334Speter } 350118334Speter error ("cast to union type from type not present in union"); 350218334Speter return error_mark_node; 350318334Speter } 350418334Speter else 350518334Speter { 350618334Speter tree otype, ovalue; 350718334Speter 350818334Speter if (type == void_type_node) 350918334Speter return build1 (CONVERT_EXPR, type, value); 351018334Speter 351118334Speter otype = TREE_TYPE (value); 351218334Speter 351318334Speter /* Optionally warn about potentially worrisome casts. */ 351418334Speter 351518334Speter if (warn_cast_qual 351618334Speter && TREE_CODE (type) == POINTER_TYPE 351718334Speter && TREE_CODE (otype) == POINTER_TYPE) 351818334Speter { 351950397Sobrien tree in_type = type; 352050397Sobrien tree in_otype = otype; 352196263Sobrien int added = 0; 352296263Sobrien int discarded = 0; 352350397Sobrien 352490075Sobrien /* Check that the qualifiers on IN_TYPE are a superset of 352590075Sobrien the qualifiers of IN_OTYPE. The outermost level of 352690075Sobrien POINTER_TYPE nodes is uninteresting and we stop as soon 352790075Sobrien as we hit a non-POINTER_TYPE node on either type. */ 352890075Sobrien do 352990075Sobrien { 353090075Sobrien in_otype = TREE_TYPE (in_otype); 353190075Sobrien in_type = TREE_TYPE (in_type); 353296263Sobrien 353396263Sobrien /* GNU C allows cv-qualified function types. 'const' 353496263Sobrien means the function is very pure, 'volatile' means it 353596263Sobrien can't return. We need to warn when such qualifiers 353696263Sobrien are added, not when they're taken away. */ 353796263Sobrien if (TREE_CODE (in_otype) == FUNCTION_TYPE 353896263Sobrien && TREE_CODE (in_type) == FUNCTION_TYPE) 353996263Sobrien added |= (TYPE_QUALS (in_type) & ~TYPE_QUALS (in_otype)); 354096263Sobrien else 354196263Sobrien discarded |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type)); 354290075Sobrien } 354390075Sobrien while (TREE_CODE (in_type) == POINTER_TYPE 354490075Sobrien && TREE_CODE (in_otype) == POINTER_TYPE); 354590075Sobrien 354696263Sobrien if (added) 3547169689Skan warning (0, "cast adds new qualifiers to function type"); 354896263Sobrien 354996263Sobrien if (discarded) 355052284Sobrien /* There are qualifiers present in IN_OTYPE that are not 355152284Sobrien present in IN_TYPE. */ 3552169689Skan warning (0, "cast discards qualifiers from pointer target type"); 355318334Speter } 355418334Speter 355518334Speter /* Warn about possible alignment problems. */ 3556169689Skan if (STRICT_ALIGNMENT 355718334Speter && TREE_CODE (type) == POINTER_TYPE 355818334Speter && TREE_CODE (otype) == POINTER_TYPE 355918334Speter && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE 356018334Speter && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE 356150397Sobrien /* Don't warn about opaque types, where the actual alignment 356250397Sobrien restriction is unknown. */ 356350397Sobrien && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE 356450397Sobrien || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE) 356550397Sobrien && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode) 356618334Speter && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype))) 3567169689Skan warning (OPT_Wcast_align, 3568169689Skan "cast increases required alignment of target type"); 356918334Speter 357018334Speter if (TREE_CODE (type) == INTEGER_TYPE 357118334Speter && TREE_CODE (otype) == POINTER_TYPE 3572169689Skan && TYPE_PRECISION (type) != TYPE_PRECISION (otype)) 3573169689Skan /* Unlike conversion of integers to pointers, where the 3574169689Skan warning is disabled for converting constants because 3575169689Skan of cases such as SIG_*, warn about converting constant 3576169689Skan pointers to integers. In some cases it may cause unwanted 3577169689Skan sign extension, and a warning is appropriate. */ 3578169689Skan warning (OPT_Wpointer_to_int_cast, 3579169689Skan "cast from pointer to integer of different size"); 358018334Speter 3581169689Skan if (TREE_CODE (value) == CALL_EXPR 358218334Speter && TREE_CODE (type) != TREE_CODE (otype)) 3583169689Skan warning (OPT_Wbad_function_cast, "cast from function call of type %qT " 3584169689Skan "to non-matching type %qT", otype, type); 358518334Speter 358618334Speter if (TREE_CODE (type) == POINTER_TYPE 358718334Speter && TREE_CODE (otype) == INTEGER_TYPE 358818334Speter && TYPE_PRECISION (type) != TYPE_PRECISION (otype) 358918334Speter /* Don't warn about converting any constant. */ 359018334Speter && !TREE_CONSTANT (value)) 3591169689Skan warning (OPT_Wint_to_pointer_cast, "cast to pointer from integer " 3592169689Skan "of different size"); 359318334Speter 3594259406Spfg if (warn_strict_aliasing <= 2) 3595259406Spfg strict_aliasing_warning (otype, type, expr); 3596132718Skan 3597132718Skan /* If pedantic, warn for conversions between function and object 3598132718Skan pointer types, except for converting a null pointer constant 3599132718Skan to function pointer type. */ 3600132718Skan if (pedantic 3601132718Skan && TREE_CODE (type) == POINTER_TYPE 3602132718Skan && TREE_CODE (otype) == POINTER_TYPE 3603132718Skan && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE 3604132718Skan && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE) 3605132718Skan pedwarn ("ISO C forbids conversion of function pointer to object pointer type"); 3606132718Skan 3607132718Skan if (pedantic 3608132718Skan && TREE_CODE (type) == POINTER_TYPE 3609132718Skan && TREE_CODE (otype) == POINTER_TYPE 3610132718Skan && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE 3611132718Skan && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE 3612169689Skan && !null_pointer_constant_p (value)) 3613132718Skan pedwarn ("ISO C forbids conversion of object pointer to function pointer type"); 3614132718Skan 361518334Speter ovalue = value; 361618334Speter value = convert (type, value); 361718334Speter 361818334Speter /* Ignore any integer overflow caused by the cast. */ 361918334Speter if (TREE_CODE (value) == INTEGER_CST) 362018334Speter { 3621169689Skan if (CONSTANT_CLASS_P (ovalue) 3622169689Skan && (TREE_OVERFLOW (ovalue) || TREE_CONSTANT_OVERFLOW (ovalue))) 3623169689Skan { 3624169689Skan /* Avoid clobbering a shared constant. */ 3625169689Skan value = copy_node (value); 3626169689Skan TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue); 3627169689Skan TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue); 3628169689Skan } 3629169689Skan else if (TREE_OVERFLOW (value) || TREE_CONSTANT_OVERFLOW (value)) 3630169689Skan /* Reset VALUE's overflow flags, ensuring constant sharing. */ 3631169689Skan value = build_int_cst_wide (TREE_TYPE (value), 3632169689Skan TREE_INT_CST_LOW (value), 3633169689Skan TREE_INT_CST_HIGH (value)); 363418334Speter } 363518334Speter } 363618334Speter 3637169689Skan /* Don't let a cast be an lvalue. */ 3638169689Skan if (value == expr) 363918334Speter value = non_lvalue (value); 364018334Speter 364118334Speter return value; 364218334Speter} 364390075Sobrien 364490075Sobrien/* Interpret a cast of expression EXPR to type TYPE. */ 364590075Sobrientree 3646169689Skanc_cast_expr (struct c_type_name *type_name, tree expr) 364790075Sobrien{ 3648169689Skan tree type; 364990075Sobrien int saved_wsp = warn_strict_prototypes; 365090075Sobrien 365190075Sobrien /* This avoids warnings about unprototyped casts on 365290075Sobrien integers. E.g. "#define SIG_DFL (void(*)())0". */ 365390075Sobrien if (TREE_CODE (expr) == INTEGER_CST) 365490075Sobrien warn_strict_prototypes = 0; 3655169689Skan type = groktypename (type_name); 365690075Sobrien warn_strict_prototypes = saved_wsp; 365790075Sobrien 365890075Sobrien return build_c_cast (type, expr); 365990075Sobrien} 366018334Speter 366118334Speter/* Build an assignment expression of lvalue LHS from value RHS. 366218334Speter MODIFYCODE is the code for a binary operator that we use 366318334Speter to combine the old value of LHS with RHS to get the new value. 366418334Speter Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. */ 366518334Speter 366618334Spetertree 3667132718Skanbuild_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) 366818334Speter{ 366990075Sobrien tree result; 367018334Speter tree newrhs; 367118334Speter tree lhstype = TREE_TYPE (lhs); 367218334Speter tree olhstype = lhstype; 367318334Speter 367418334Speter /* Types that aren't fully specified cannot be used in assignments. */ 367518334Speter lhs = require_complete_type (lhs); 367618334Speter 367718334Speter /* Avoid duplicate error messages from operands that had errors. */ 367818334Speter if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK) 367918334Speter return error_mark_node; 368018334Speter 3681169689Skan if (!lvalue_or_else (lhs, lv_assign)) 3682169689Skan return error_mark_node; 368318334Speter 3684169689Skan STRIP_TYPE_NOPS (rhs); 3685169689Skan 368618334Speter newrhs = rhs; 368718334Speter 368818334Speter /* If a binary op has been requested, combine the old LHS value with the RHS 368918334Speter producing the value we should actually store into the LHS. */ 369018334Speter 369118334Speter if (modifycode != NOP_EXPR) 369218334Speter { 369318334Speter lhs = stabilize_reference (lhs); 369418334Speter newrhs = build_binary_op (modifycode, lhs, rhs, 1); 369518334Speter } 369618334Speter 3697169689Skan /* Give an error for storing in something that is 'const'. */ 369818334Speter 369918334Speter if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype) 370018334Speter || ((TREE_CODE (lhstype) == RECORD_TYPE 370118334Speter || TREE_CODE (lhstype) == UNION_TYPE) 370218334Speter && C_TYPE_FIELDS_READONLY (lhstype))) 3703169689Skan { 3704169689Skan readonly_error (lhs, lv_assign); 3705169689Skan return error_mark_node; 3706169689Skan } 370718334Speter 370818334Speter /* If storing into a structure or union member, 370918334Speter it has probably been given type `int'. 371018334Speter Compute the type that would go with 371118334Speter the actual amount of storage the member occupies. */ 371218334Speter 371318334Speter if (TREE_CODE (lhs) == COMPONENT_REF 371418334Speter && (TREE_CODE (lhstype) == INTEGER_TYPE 371590075Sobrien || TREE_CODE (lhstype) == BOOLEAN_TYPE 371618334Speter || TREE_CODE (lhstype) == REAL_TYPE 371718334Speter || TREE_CODE (lhstype) == ENUMERAL_TYPE)) 371818334Speter lhstype = TREE_TYPE (get_unwidened (lhs, 0)); 371918334Speter 372018334Speter /* If storing in a field that is in actuality a short or narrower than one, 372118334Speter we must store in the field in its actual type. */ 372218334Speter 372318334Speter if (lhstype != TREE_TYPE (lhs)) 372418334Speter { 372518334Speter lhs = copy_node (lhs); 372618334Speter TREE_TYPE (lhs) = lhstype; 372718334Speter } 372818334Speter 372918334Speter /* Convert new value to destination type. */ 373018334Speter 3731169689Skan newrhs = convert_for_assignment (lhstype, newrhs, ic_assign, 373218334Speter NULL_TREE, NULL_TREE, 0); 373318334Speter if (TREE_CODE (newrhs) == ERROR_MARK) 373418334Speter return error_mark_node; 373518334Speter 3736169689Skan /* Emit ObjC write barrier, if necessary. */ 3737169689Skan if (c_dialect_objc () && flag_objc_gc) 3738169689Skan { 3739169689Skan result = objc_generate_write_barrier (lhs, modifycode, newrhs); 3740169689Skan if (result) 3741169689Skan return result; 3742169689Skan } 374390075Sobrien 3744169689Skan /* Scan operands. */ 3745169689Skan 3746169689Skan result = build2 (MODIFY_EXPR, lhstype, lhs, newrhs); 374718334Speter TREE_SIDE_EFFECTS (result) = 1; 374818334Speter 374918334Speter /* If we got the LHS in a different type for storing in, 375018334Speter convert the result back to the nominal type of LHS 375118334Speter so that the value we return always has the same type 375218334Speter as the LHS argument. */ 375318334Speter 375418334Speter if (olhstype == TREE_TYPE (result)) 375518334Speter return result; 3756169689Skan return convert_for_assignment (olhstype, result, ic_assign, 375718334Speter NULL_TREE, NULL_TREE, 0); 375818334Speter} 375918334Speter 376018334Speter/* Convert value RHS to type TYPE as preparation for an assignment 376118334Speter to an lvalue of type TYPE. 376218334Speter The real work of conversion is done by `convert'. 376318334Speter The purpose of this function is to generate error messages 376418334Speter for assignments that are not allowed in C. 3765169689Skan ERRTYPE says whether it is argument passing, assignment, 3766169689Skan initialization or return. 376718334Speter 3768169689Skan FUNCTION is a tree for the function being called. 376918334Speter PARMNUM is the number of the argument, for printing in error messages. */ 377018334Speter 377118334Speterstatic tree 3772169689Skanconvert_for_assignment (tree type, tree rhs, enum impl_conv errtype, 3773169689Skan tree fundecl, tree function, int parmnum) 377418334Speter{ 377590075Sobrien enum tree_code codel = TREE_CODE (type); 377690075Sobrien tree rhstype; 377790075Sobrien enum tree_code coder; 3778169689Skan tree rname = NULL_TREE; 3779169689Skan bool objc_ok = false; 378018334Speter 3781169689Skan if (errtype == ic_argpass || errtype == ic_argpass_nonproto) 3782169689Skan { 3783169689Skan tree selector; 3784169689Skan /* Change pointer to function to the function itself for 3785169689Skan diagnostics. */ 3786169689Skan if (TREE_CODE (function) == ADDR_EXPR 3787169689Skan && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL) 3788169689Skan function = TREE_OPERAND (function, 0); 378918334Speter 3790169689Skan /* Handle an ObjC selector specially for diagnostics. */ 3791169689Skan selector = objc_message_selector (); 3792169689Skan rname = function; 3793169689Skan if (selector && parmnum > 2) 3794169689Skan { 3795169689Skan rname = selector; 3796169689Skan parmnum -= 2; 3797169689Skan } 3798169689Skan } 3799169689Skan 3800169689Skan /* This macro is used to emit diagnostics to ensure that all format 3801169689Skan strings are complete sentences, visible to gettext and checked at 3802169689Skan compile time. */ 3803169689Skan#define WARN_FOR_ASSIGNMENT(AR, AS, IN, RE) \ 3804169689Skan do { \ 3805169689Skan switch (errtype) \ 3806169689Skan { \ 3807169689Skan case ic_argpass: \ 3808169689Skan pedwarn (AR, parmnum, rname); \ 3809169689Skan break; \ 3810169689Skan case ic_argpass_nonproto: \ 3811169689Skan warning (0, AR, parmnum, rname); \ 3812169689Skan break; \ 3813169689Skan case ic_assign: \ 3814169689Skan pedwarn (AS); \ 3815169689Skan break; \ 3816169689Skan case ic_init: \ 3817169689Skan pedwarn (IN); \ 3818169689Skan break; \ 3819169689Skan case ic_return: \ 3820169689Skan pedwarn (RE); \ 3821169689Skan break; \ 3822169689Skan default: \ 3823169689Skan gcc_unreachable (); \ 3824169689Skan } \ 3825169689Skan } while (0) 3826169689Skan 3827169689Skan STRIP_TYPE_NOPS (rhs); 3828169689Skan 3829169689Skan if (optimize && TREE_CODE (rhs) == VAR_DECL 3830169689Skan && TREE_CODE (TREE_TYPE (rhs)) != ARRAY_TYPE) 383190075Sobrien rhs = decl_constant_value_for_broken_optimization (rhs); 383218334Speter 383318334Speter rhstype = TREE_TYPE (rhs); 383418334Speter coder = TREE_CODE (rhstype); 383518334Speter 383618334Speter if (coder == ERROR_MARK) 383718334Speter return error_mark_node; 383818334Speter 3839169689Skan if (c_dialect_objc ()) 3840169689Skan { 3841169689Skan int parmno; 3842169689Skan 3843169689Skan switch (errtype) 3844169689Skan { 3845169689Skan case ic_return: 3846169689Skan parmno = 0; 3847169689Skan break; 3848169689Skan 3849169689Skan case ic_assign: 3850169689Skan parmno = -1; 3851169689Skan break; 3852169689Skan 3853169689Skan case ic_init: 3854169689Skan parmno = -2; 3855169689Skan break; 3856169689Skan 3857169689Skan default: 3858169689Skan parmno = parmnum; 3859169689Skan break; 3860169689Skan } 3861169689Skan 3862169689Skan objc_ok = objc_compare_types (type, rhstype, parmno, rname); 3863169689Skan } 3864169689Skan 386518334Speter if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype)) 3866259585Spfg return rhs; 386718334Speter 386818334Speter if (coder == VOID_TYPE) 386918334Speter { 3870169689Skan /* Except for passing an argument to an unprototyped function, 3871169689Skan this is a constraint violation. When passing an argument to 3872169689Skan an unprototyped function, it is compile-time undefined; 3873169689Skan making it a constraint in that case was rejected in 3874169689Skan DR#252. */ 387518334Speter error ("void value not ignored as it ought to be"); 387618334Speter return error_mark_node; 387718334Speter } 3878132718Skan /* A type converts to a reference to it. 387990075Sobrien This code doesn't fully support references, it's just for the 388090075Sobrien special case of va_start and va_copy. */ 388190075Sobrien if (codel == REFERENCE_TYPE 3882169689Skan && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1) 388390075Sobrien { 3884117395Skan if (!lvalue_p (rhs)) 3885117395Skan { 3886117395Skan error ("cannot pass rvalue to reference parameter"); 3887117395Skan return error_mark_node; 3888117395Skan } 3889117395Skan if (!c_mark_addressable (rhs)) 389090075Sobrien return error_mark_node; 389190075Sobrien rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs); 389290075Sobrien 389390075Sobrien /* We already know that these two types are compatible, but they 389490075Sobrien may not be exactly identical. In fact, `TREE_TYPE (type)' is 389590075Sobrien likely to be __builtin_va_list and `TREE_TYPE (rhs)' is 389690075Sobrien likely to be va_list, a typedef to __builtin_va_list, which 389790075Sobrien is different enough that it will cause problems later. */ 389890075Sobrien if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type)) 389990075Sobrien rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs); 390090075Sobrien 390190075Sobrien rhs = build1 (NOP_EXPR, type, rhs); 390290075Sobrien return rhs; 390390075Sobrien } 3904132718Skan /* Some types can interconvert without explicit casts. */ 3905132718Skan else if (codel == VECTOR_TYPE && coder == VECTOR_TYPE 3906260075Spfg && vector_types_convertible_p (type, TREE_TYPE (rhs), true)) 3907132718Skan return convert (type, rhs); 390818334Speter /* Arithmetic types all interconvert, and enum is treated like int. */ 3909132718Skan else if ((codel == INTEGER_TYPE || codel == REAL_TYPE 391090075Sobrien || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE 391190075Sobrien || codel == BOOLEAN_TYPE) 3912117395Skan && (coder == INTEGER_TYPE || coder == REAL_TYPE 391390075Sobrien || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE 391490075Sobrien || coder == BOOLEAN_TYPE)) 391518334Speter return convert_and_check (type, rhs); 391618334Speter 3917169689Skan /* Aggregates in different TUs might need conversion. */ 3918169689Skan if ((codel == RECORD_TYPE || codel == UNION_TYPE) 3919169689Skan && codel == coder 3920169689Skan && comptypes (type, rhstype)) 3921169689Skan return convert_and_check (type, rhs); 3922169689Skan 392350397Sobrien /* Conversion to a transparent union from its member types. 392450397Sobrien This applies only to function arguments. */ 3925169689Skan if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) 3926169689Skan && (errtype == ic_argpass || errtype == ic_argpass_nonproto)) 392718334Speter { 3928169689Skan tree memb, marginal_memb = NULL_TREE; 392918334Speter 3930169689Skan for (memb = TYPE_FIELDS (type); memb ; memb = TREE_CHAIN (memb)) 393118334Speter { 3932169689Skan tree memb_type = TREE_TYPE (memb); 393318334Speter 393450397Sobrien if (comptypes (TYPE_MAIN_VARIANT (memb_type), 3935169689Skan TYPE_MAIN_VARIANT (rhstype))) 393650397Sobrien break; 393750397Sobrien 393850397Sobrien if (TREE_CODE (memb_type) != POINTER_TYPE) 393950397Sobrien continue; 394050397Sobrien 394150397Sobrien if (coder == POINTER_TYPE) 394218334Speter { 394390075Sobrien tree ttl = TREE_TYPE (memb_type); 394490075Sobrien tree ttr = TREE_TYPE (rhstype); 394518334Speter 394618334Speter /* Any non-function converts to a [const][volatile] void * 394718334Speter and vice versa; otherwise, targets must be the same. 394818334Speter Meanwhile, the lhs target must have all the qualifiers of 394918334Speter the rhs. */ 395090075Sobrien if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr) 3951169689Skan || comp_target_types (memb_type, rhstype)) 395218334Speter { 395350397Sobrien /* If this type won't generate any warnings, use it. */ 395452284Sobrien if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr) 395552284Sobrien || ((TREE_CODE (ttr) == FUNCTION_TYPE 395652284Sobrien && TREE_CODE (ttl) == FUNCTION_TYPE) 395752284Sobrien ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr)) 395852284Sobrien == TYPE_QUALS (ttr)) 395952284Sobrien : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr)) 396052284Sobrien == TYPE_QUALS (ttl)))) 396150397Sobrien break; 396218334Speter 396350397Sobrien /* Keep looking for a better type, but remember this one. */ 3964169689Skan if (!marginal_memb) 3965169689Skan marginal_memb = memb; 396618334Speter } 396718334Speter } 396818334Speter 396918334Speter /* Can convert integer zero to any pointer type. */ 3970169689Skan if (null_pointer_constant_p (rhs)) 397150397Sobrien { 397250397Sobrien rhs = null_pointer_node; 397350397Sobrien break; 397450397Sobrien } 397518334Speter } 397650397Sobrien 3977169689Skan if (memb || marginal_memb) 397850397Sobrien { 3979169689Skan if (!memb) 398050397Sobrien { 398150397Sobrien /* We have only a marginally acceptable member type; 398250397Sobrien it needs a warning. */ 3983169689Skan tree ttl = TREE_TYPE (TREE_TYPE (marginal_memb)); 398490075Sobrien tree ttr = TREE_TYPE (rhstype); 398550397Sobrien 398650397Sobrien /* Const and volatile mean something different for function 398750397Sobrien types, so the usual warnings are not appropriate. */ 398850397Sobrien if (TREE_CODE (ttr) == FUNCTION_TYPE 398950397Sobrien && TREE_CODE (ttl) == FUNCTION_TYPE) 399050397Sobrien { 399150397Sobrien /* Because const and volatile on functions are 399250397Sobrien restrictions that say the function will not do 399350397Sobrien certain things, it is okay to use a const or volatile 399450397Sobrien function where an ordinary one is wanted, but not 399550397Sobrien vice-versa. */ 399652284Sobrien if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr)) 3997169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE " 3998169689Skan "makes qualified function " 3999169689Skan "pointer from unqualified"), 4000169689Skan G_("assignment makes qualified " 4001169689Skan "function pointer from " 4002169689Skan "unqualified"), 4003169689Skan G_("initialization makes qualified " 4004169689Skan "function pointer from " 4005169689Skan "unqualified"), 4006169689Skan G_("return makes qualified function " 4007169689Skan "pointer from unqualified")); 400850397Sobrien } 400952284Sobrien else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl)) 4010169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE discards " 4011169689Skan "qualifiers from pointer target type"), 4012169689Skan G_("assignment discards qualifiers " 4013169689Skan "from pointer target type"), 4014169689Skan G_("initialization discards qualifiers " 4015169689Skan "from pointer target type"), 4016169689Skan G_("return discards qualifiers from " 4017169689Skan "pointer target type")); 4018169689Skan 4019169689Skan memb = marginal_memb; 402050397Sobrien } 4021132718Skan 4022169689Skan if (pedantic && (!fundecl || !DECL_IN_SYSTEM_HEADER (fundecl))) 402390075Sobrien pedwarn ("ISO C prohibits argument conversion to union type"); 402450397Sobrien 4025169689Skan return build_constructor_single (type, memb, rhs); 402650397Sobrien } 402718334Speter } 402818334Speter 402918334Speter /* Conversions among pointers */ 403090075Sobrien else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE) 4031117395Skan && (coder == codel)) 403218334Speter { 403390075Sobrien tree ttl = TREE_TYPE (type); 403490075Sobrien tree ttr = TREE_TYPE (rhstype); 4035169689Skan tree mvl = ttl; 4036169689Skan tree mvr = ttr; 4037132718Skan bool is_opaque_pointer; 4038132718Skan int target_cmp = 0; /* Cache comp_target_types () result. */ 403918334Speter 4040169689Skan if (TREE_CODE (mvl) != ARRAY_TYPE) 4041169689Skan mvl = TYPE_MAIN_VARIANT (mvl); 4042169689Skan if (TREE_CODE (mvr) != ARRAY_TYPE) 4043169689Skan mvr = TYPE_MAIN_VARIANT (mvr); 4044132718Skan /* Opaque pointers are treated like void pointers. */ 4045169689Skan is_opaque_pointer = (targetm.vector_opaque_p (type) 4046169689Skan || targetm.vector_opaque_p (rhstype)) 4047169689Skan && TREE_CODE (ttl) == VECTOR_TYPE 4048169689Skan && TREE_CODE (ttr) == VECTOR_TYPE; 4049132718Skan 4050169689Skan /* C++ does not allow the implicit conversion void* -> T*. However, 4051169689Skan for the purpose of reducing the number of false positives, we 4052169689Skan tolerate the special case of 4053169689Skan 4054169689Skan int *p = NULL; 4055169689Skan 4056169689Skan where NULL is typically defined in C to be '(void *) 0'. */ 4057169689Skan if (VOID_TYPE_P (ttr) && rhs != null_pointer_node && !VOID_TYPE_P (ttl)) 4058169689Skan warning (OPT_Wc___compat, "request for implicit conversion from " 4059169689Skan "%qT to %qT not permitted in C++", rhstype, type); 4060169689Skan 4061169689Skan /* Check if the right-hand side has a format attribute but the 4062169689Skan left-hand side doesn't. */ 4063169689Skan if (warn_missing_format_attribute 4064169689Skan && check_missing_format_attribute (type, rhstype)) 4065169689Skan { 4066169689Skan switch (errtype) 4067169689Skan { 4068169689Skan case ic_argpass: 4069169689Skan case ic_argpass_nonproto: 4070169689Skan warning (OPT_Wmissing_format_attribute, 4071169689Skan "argument %d of %qE might be " 4072169689Skan "a candidate for a format attribute", 4073169689Skan parmnum, rname); 4074169689Skan break; 4075169689Skan case ic_assign: 4076169689Skan warning (OPT_Wmissing_format_attribute, 4077169689Skan "assignment left-hand side might be " 4078169689Skan "a candidate for a format attribute"); 4079169689Skan break; 4080169689Skan case ic_init: 4081169689Skan warning (OPT_Wmissing_format_attribute, 4082169689Skan "initialization left-hand side might be " 4083169689Skan "a candidate for a format attribute"); 4084169689Skan break; 4085169689Skan case ic_return: 4086169689Skan warning (OPT_Wmissing_format_attribute, 4087169689Skan "return type might be " 4088169689Skan "a candidate for a format attribute"); 4089169689Skan break; 4090169689Skan default: 4091169689Skan gcc_unreachable (); 4092169689Skan } 4093169689Skan } 4094169689Skan 409518334Speter /* Any non-function converts to a [const][volatile] void * 409618334Speter and vice versa; otherwise, targets must be the same. 409718334Speter Meanwhile, the lhs target must have all the qualifiers of the rhs. */ 409890075Sobrien if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr) 4099169689Skan || (target_cmp = comp_target_types (type, rhstype)) 4100132718Skan || is_opaque_pointer 4101169689Skan || (c_common_unsigned_type (mvl) 4102169689Skan == c_common_unsigned_type (mvr))) 410318334Speter { 410418334Speter if (pedantic 410590075Sobrien && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE) 410618334Speter || 410790075Sobrien (VOID_TYPE_P (ttr) 4108169689Skan && !null_pointer_constant_p (rhs) 410918334Speter && TREE_CODE (ttl) == FUNCTION_TYPE))) 4110169689Skan WARN_FOR_ASSIGNMENT (G_("ISO C forbids passing argument %d of " 4111169689Skan "%qE between function pointer " 4112169689Skan "and %<void *%>"), 4113169689Skan G_("ISO C forbids assignment between " 4114169689Skan "function pointer and %<void *%>"), 4115169689Skan G_("ISO C forbids initialization between " 4116169689Skan "function pointer and %<void *%>"), 4117169689Skan G_("ISO C forbids return between function " 4118169689Skan "pointer and %<void *%>")); 411918334Speter /* Const and volatile mean something different for function types, 412018334Speter so the usual warnings are not appropriate. */ 412118334Speter else if (TREE_CODE (ttr) != FUNCTION_TYPE 412218334Speter && TREE_CODE (ttl) != FUNCTION_TYPE) 412318334Speter { 412452284Sobrien if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl)) 4125169689Skan { 4126169689Skan /* Types differing only by the presence of the 'volatile' 4127169689Skan qualifier are acceptable if the 'volatile' has been added 4128169689Skan in by the Objective-C EH machinery. */ 4129169689Skan if (!objc_type_quals_match (ttl, ttr)) 4130169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE discards " 4131169689Skan "qualifiers from pointer target type"), 4132169689Skan G_("assignment discards qualifiers " 4133169689Skan "from pointer target type"), 4134169689Skan G_("initialization discards qualifiers " 4135169689Skan "from pointer target type"), 4136169689Skan G_("return discards qualifiers from " 4137169689Skan "pointer target type")); 4138169689Skan } 413918334Speter /* If this is not a case of ignoring a mismatch in signedness, 414018334Speter no warning. */ 414190075Sobrien else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr) 4142132718Skan || target_cmp) 414318334Speter ; 414418334Speter /* If there is a mismatch, do warn. */ 4145169689Skan else if (warn_pointer_sign) 4146169689Skan WARN_FOR_ASSIGNMENT (G_("pointer targets in passing argument " 4147169689Skan "%d of %qE differ in signedness"), 4148169689Skan G_("pointer targets in assignment " 4149169689Skan "differ in signedness"), 4150169689Skan G_("pointer targets in initialization " 4151169689Skan "differ in signedness"), 4152169689Skan G_("pointer targets in return differ " 4153169689Skan "in signedness")); 415418334Speter } 415518334Speter else if (TREE_CODE (ttl) == FUNCTION_TYPE 415618334Speter && TREE_CODE (ttr) == FUNCTION_TYPE) 415718334Speter { 415818334Speter /* Because const and volatile on functions are restrictions 415918334Speter that say the function will not do certain things, 416018334Speter it is okay to use a const or volatile function 416118334Speter where an ordinary one is wanted, but not vice-versa. */ 416252284Sobrien if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr)) 4163169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes " 4164169689Skan "qualified function pointer " 4165169689Skan "from unqualified"), 4166169689Skan G_("assignment makes qualified function " 4167169689Skan "pointer from unqualified"), 4168169689Skan G_("initialization makes qualified " 4169169689Skan "function pointer from unqualified"), 4170169689Skan G_("return makes qualified function " 4171169689Skan "pointer from unqualified")); 417218334Speter } 417318334Speter } 417418334Speter else 4175169689Skan /* Avoid warning about the volatile ObjC EH puts on decls. */ 4176169689Skan if (!objc_ok) 4177169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE from " 4178169689Skan "incompatible pointer type"), 4179169689Skan G_("assignment from incompatible pointer type"), 4180169689Skan G_("initialization from incompatible " 4181169689Skan "pointer type"), 4182169689Skan G_("return from incompatible pointer type")); 4183169689Skan 418418334Speter return convert (type, rhs); 418518334Speter } 4186122180Skan else if (codel == POINTER_TYPE && coder == ARRAY_TYPE) 4187122180Skan { 4188169689Skan /* ??? This should not be an error when inlining calls to 4189169689Skan unprototyped functions. */ 4190122180Skan error ("invalid use of non-lvalue array"); 4191122180Skan return error_mark_node; 4192122180Skan } 419318334Speter else if (codel == POINTER_TYPE && coder == INTEGER_TYPE) 419418334Speter { 419518334Speter /* An explicit constant 0 can convert to a pointer, 419618334Speter or one that results from arithmetic, even including 419718334Speter a cast to integer type. */ 4198169689Skan if (!null_pointer_constant_p (rhs)) 4199169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes " 4200169689Skan "pointer from integer without a cast"), 4201169689Skan G_("assignment makes pointer from integer " 4202169689Skan "without a cast"), 4203169689Skan G_("initialization makes pointer from " 4204169689Skan "integer without a cast"), 4205169689Skan G_("return makes pointer from integer " 4206169689Skan "without a cast")); 4207132718Skan 4208132718Skan return convert (type, rhs); 420918334Speter } 421018334Speter else if (codel == INTEGER_TYPE && coder == POINTER_TYPE) 421118334Speter { 4212169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes integer " 4213169689Skan "from pointer without a cast"), 4214169689Skan G_("assignment makes integer from pointer " 4215169689Skan "without a cast"), 4216169689Skan G_("initialization makes integer from pointer " 4217169689Skan "without a cast"), 4218169689Skan G_("return makes integer from pointer " 4219169689Skan "without a cast")); 422018334Speter return convert (type, rhs); 422118334Speter } 422290075Sobrien else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE) 422390075Sobrien return convert (type, rhs); 422418334Speter 4225169689Skan switch (errtype) 422618334Speter { 4227169689Skan case ic_argpass: 4228169689Skan case ic_argpass_nonproto: 4229169689Skan /* ??? This should not be an error when inlining calls to 4230169689Skan unprototyped functions. */ 4231169689Skan error ("incompatible type for argument %d of %qE", parmnum, rname); 4232169689Skan break; 4233169689Skan case ic_assign: 4234169689Skan error ("incompatible types in assignment"); 4235169689Skan break; 4236169689Skan case ic_init: 4237169689Skan error ("incompatible types in initialization"); 4238169689Skan break; 4239169689Skan case ic_return: 4240169689Skan error ("incompatible types in return"); 4241169689Skan break; 4242169689Skan default: 4243169689Skan gcc_unreachable (); 424418334Speter } 424518334Speter 424618334Speter return error_mark_node; 424718334Speter} 424818334Speter 4249132718Skan/* Convert VALUE for assignment into inlined parameter PARM. ARGNUM 4250169689Skan is used for error and warning reporting and indicates which argument 4251132718Skan is being processed. */ 425296263Sobrien 425396263Sobrientree 4254132718Skanc_convert_parm_for_inlining (tree parm, tree value, tree fn, int argnum) 425596263Sobrien{ 425696263Sobrien tree ret, type; 425796263Sobrien 4258169689Skan /* If FN was prototyped at the call site, the value has been converted 4259169689Skan already in convert_arguments. 4260169689Skan However, we might see a prototype now that was not in place when 4261169689Skan the function call was seen, so check that the VALUE actually matches 4262169689Skan PARM before taking an early exit. */ 4263169689Skan if (!value 4264169689Skan || (TYPE_ARG_TYPES (TREE_TYPE (fn)) 4265169689Skan && (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) 4266169689Skan == TYPE_MAIN_VARIANT (TREE_TYPE (value))))) 426796263Sobrien return value; 426896263Sobrien 426996263Sobrien type = TREE_TYPE (parm); 4270132718Skan ret = convert_for_assignment (type, value, 4271169689Skan ic_argpass_nonproto, fn, 4272169689Skan fn, argnum); 4273132718Skan if (targetm.calls.promote_prototypes (TREE_TYPE (fn)) 427496263Sobrien && INTEGRAL_TYPE_P (type) 427596263Sobrien && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))) 427696263Sobrien ret = default_conversion (ret); 427796263Sobrien return ret; 427896263Sobrien} 427918334Speter 428018334Speter/* If VALUE is a compound expr all of whose expressions are constant, then 428118334Speter return its value. Otherwise, return error_mark_node. 428218334Speter 428318334Speter This is for handling COMPOUND_EXPRs as initializer elements 428418334Speter which is allowed with a warning when -pedantic is specified. */ 428518334Speter 428618334Speterstatic tree 4287132718Skanvalid_compound_expr_initializer (tree value, tree endtype) 428818334Speter{ 428918334Speter if (TREE_CODE (value) == COMPOUND_EXPR) 429018334Speter { 429118334Speter if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype) 429218334Speter == error_mark_node) 429318334Speter return error_mark_node; 429418334Speter return valid_compound_expr_initializer (TREE_OPERAND (value, 1), 429518334Speter endtype); 429618334Speter } 4297169689Skan else if (!initializer_constant_valid_p (value, endtype)) 429818334Speter return error_mark_node; 429918334Speter else 430018334Speter return value; 430118334Speter} 430218334Speter 430318334Speter/* Perform appropriate conversions on the initial value of a variable, 430418334Speter store it in the declaration DECL, 430518334Speter and print any error messages that are appropriate. 430618334Speter If the init is invalid, store an ERROR_MARK. */ 430718334Speter 430818334Spetervoid 4309132718Skanstore_init_value (tree decl, tree init) 431018334Speter{ 431190075Sobrien tree value, type; 431218334Speter 431318334Speter /* If variable's type was invalidly declared, just ignore it. */ 431418334Speter 431518334Speter type = TREE_TYPE (decl); 431618334Speter if (TREE_CODE (type) == ERROR_MARK) 431718334Speter return; 431818334Speter 431918334Speter /* Digest the specified initializer into an expression. */ 432018334Speter 4321169689Skan value = digest_init (type, init, true, TREE_STATIC (decl)); 432218334Speter 432318334Speter /* Store the expression if valid; else report error. */ 432418334Speter 4325169689Skan if (!in_system_header 4326169689Skan && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && !TREE_STATIC (decl)) 4327169689Skan warning (OPT_Wtraditional, "traditional C rejects automatic " 4328169689Skan "aggregate initialization"); 432990075Sobrien 433018334Speter DECL_INITIAL (decl) = value; 433118334Speter 433218334Speter /* ANSI wants warnings about out-of-range constant initializers. */ 433318334Speter STRIP_TYPE_NOPS (value); 433418334Speter constant_expression_warning (value); 433590075Sobrien 433690075Sobrien /* Check if we need to set array size from compound literal size. */ 433790075Sobrien if (TREE_CODE (type) == ARRAY_TYPE 433890075Sobrien && TYPE_DOMAIN (type) == 0 433990075Sobrien && value != error_mark_node) 434090075Sobrien { 434190075Sobrien tree inside_init = init; 434290075Sobrien 4343169689Skan STRIP_TYPE_NOPS (inside_init); 434490075Sobrien inside_init = fold (inside_init); 434590075Sobrien 434690075Sobrien if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR) 434790075Sobrien { 4348169689Skan tree cldecl = COMPOUND_LITERAL_EXPR_DECL (inside_init); 434990075Sobrien 4350169689Skan if (TYPE_DOMAIN (TREE_TYPE (cldecl))) 435190075Sobrien { 435290075Sobrien /* For int foo[] = (int [3]){1}; we need to set array size 435390075Sobrien now since later on array initializer will be just the 435490075Sobrien brace enclosed list of the compound literal. */ 4355169689Skan type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type)); 4356169689Skan TREE_TYPE (decl) = type; 4357169689Skan TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (cldecl)); 435890075Sobrien layout_type (type); 4359169689Skan layout_decl (cldecl, 0); 436090075Sobrien } 436190075Sobrien } 436290075Sobrien } 436318334Speter} 436418334Speter 436518334Speter/* Methods for storing and printing names for error messages. */ 436618334Speter 436718334Speter/* Implement a spelling stack that allows components of a name to be pushed 436818334Speter and popped. Each element on the stack is this structure. */ 436918334Speter 437018334Speterstruct spelling 437118334Speter{ 437218334Speter int kind; 437318334Speter union 437418334Speter { 4375169689Skan unsigned HOST_WIDE_INT i; 437652284Sobrien const char *s; 437718334Speter } u; 437818334Speter}; 437918334Speter 438018334Speter#define SPELLING_STRING 1 438118334Speter#define SPELLING_MEMBER 2 438218334Speter#define SPELLING_BOUNDS 3 438318334Speter 438418334Speterstatic struct spelling *spelling; /* Next stack element (unused). */ 438518334Speterstatic struct spelling *spelling_base; /* Spelling stack base. */ 438618334Speterstatic int spelling_size; /* Size of the spelling stack. */ 438718334Speter 438818334Speter/* Macros to save and restore the spelling stack around push_... functions. 438918334Speter Alternative to SAVE_SPELLING_STACK. */ 439018334Speter 439118334Speter#define SPELLING_DEPTH() (spelling - spelling_base) 439290075Sobrien#define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH)) 439318334Speter 439418334Speter/* Push an element on the spelling stack with type KIND and assign VALUE 439518334Speter to MEMBER. */ 439618334Speter 439718334Speter#define PUSH_SPELLING(KIND, VALUE, MEMBER) \ 439818334Speter{ \ 439918334Speter int depth = SPELLING_DEPTH (); \ 440018334Speter \ 440118334Speter if (depth >= spelling_size) \ 440218334Speter { \ 440318334Speter spelling_size += 10; \ 4404169689Skan spelling_base = XRESIZEVEC (struct spelling, spelling_base, \ 4405169689Skan spelling_size); \ 440618334Speter RESTORE_SPELLING_DEPTH (depth); \ 440718334Speter } \ 440818334Speter \ 440918334Speter spelling->kind = (KIND); \ 441018334Speter spelling->MEMBER = (VALUE); \ 441118334Speter spelling++; \ 441218334Speter} 441318334Speter 441418334Speter/* Push STRING on the stack. Printed literally. */ 441518334Speter 441618334Speterstatic void 4417132718Skanpush_string (const char *string) 441818334Speter{ 441918334Speter PUSH_SPELLING (SPELLING_STRING, string, u.s); 442018334Speter} 442118334Speter 442218334Speter/* Push a member name on the stack. Printed as '.' STRING. */ 442318334Speter 442418334Speterstatic void 4425132718Skanpush_member_name (tree decl) 442618334Speter{ 442790075Sobrien const char *const string 442818334Speter = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>"; 442918334Speter PUSH_SPELLING (SPELLING_MEMBER, string, u.s); 443018334Speter} 443118334Speter 443218334Speter/* Push an array bounds on the stack. Printed as [BOUNDS]. */ 443318334Speter 443418334Speterstatic void 4435169689Skanpush_array_bounds (unsigned HOST_WIDE_INT bounds) 443618334Speter{ 443718334Speter PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i); 443818334Speter} 443918334Speter 444018334Speter/* Compute the maximum size in bytes of the printed spelling. */ 444118334Speter 444218334Speterstatic int 4443132718Skanspelling_length (void) 444418334Speter{ 444590075Sobrien int size = 0; 444690075Sobrien struct spelling *p; 444718334Speter 444818334Speter for (p = spelling_base; p < spelling; p++) 444918334Speter { 445018334Speter if (p->kind == SPELLING_BOUNDS) 445118334Speter size += 25; 445218334Speter else 445318334Speter size += strlen (p->u.s) + 1; 445418334Speter } 445518334Speter 445618334Speter return size; 445718334Speter} 445818334Speter 445918334Speter/* Print the spelling to BUFFER and return it. */ 446018334Speter 446118334Speterstatic char * 4462132718Skanprint_spelling (char *buffer) 446318334Speter{ 446490075Sobrien char *d = buffer; 446590075Sobrien struct spelling *p; 446618334Speter 446718334Speter for (p = spelling_base; p < spelling; p++) 446818334Speter if (p->kind == SPELLING_BOUNDS) 446918334Speter { 4470169689Skan sprintf (d, "[" HOST_WIDE_INT_PRINT_UNSIGNED "]", p->u.i); 447118334Speter d += strlen (d); 447218334Speter } 447318334Speter else 447418334Speter { 447590075Sobrien const char *s; 447618334Speter if (p->kind == SPELLING_MEMBER) 447718334Speter *d++ = '.'; 447850397Sobrien for (s = p->u.s; (*d = *s++); d++) 447918334Speter ; 448018334Speter } 448118334Speter *d++ = '\0'; 448218334Speter return buffer; 448318334Speter} 448418334Speter 448518334Speter/* Issue an error message for a bad initializer component. 448652284Sobrien MSGID identifies the message. 448752284Sobrien The component name is taken from the spelling stack. */ 448818334Speter 448918334Spetervoid 4490132718Skanerror_init (const char *msgid) 449118334Speter{ 449252284Sobrien char *ofwhat; 449318334Speter 449490075Sobrien error ("%s", _(msgid)); 4495169689Skan ofwhat = print_spelling ((char *) alloca (spelling_length () + 1)); 449618334Speter if (*ofwhat) 4497169689Skan error ("(near initialization for %qs)", ofwhat); 449818334Speter} 449918334Speter 450018334Speter/* Issue a pedantic warning for a bad initializer component. 450152284Sobrien MSGID identifies the message. 450252284Sobrien The component name is taken from the spelling stack. */ 450318334Speter 450418334Spetervoid 4505132718Skanpedwarn_init (const char *msgid) 450618334Speter{ 450752284Sobrien char *ofwhat; 450818334Speter 450990075Sobrien pedwarn ("%s", _(msgid)); 4510169689Skan ofwhat = print_spelling ((char *) alloca (spelling_length () + 1)); 451118334Speter if (*ofwhat) 4512169689Skan pedwarn ("(near initialization for %qs)", ofwhat); 451318334Speter} 451418334Speter 451518334Speter/* Issue a warning for a bad initializer component. 451652284Sobrien MSGID identifies the message. 451752284Sobrien The component name is taken from the spelling stack. */ 451818334Speter 451918334Speterstatic void 4520132718Skanwarning_init (const char *msgid) 452118334Speter{ 452252284Sobrien char *ofwhat; 452318334Speter 4524169689Skan warning (0, "%s", _(msgid)); 4525169689Skan ofwhat = print_spelling ((char *) alloca (spelling_length () + 1)); 452618334Speter if (*ofwhat) 4527169689Skan warning (0, "(near initialization for %qs)", ofwhat); 452818334Speter} 452918334Speter 4530169689Skan/* If TYPE is an array type and EXPR is a parenthesized string 4531169689Skan constant, warn if pedantic that EXPR is being used to initialize an 4532169689Skan object of type TYPE. */ 4533169689Skan 4534169689Skanvoid 4535169689Skanmaybe_warn_string_init (tree type, struct c_expr expr) 4536169689Skan{ 4537169689Skan if (pedantic 4538169689Skan && TREE_CODE (type) == ARRAY_TYPE 4539169689Skan && TREE_CODE (expr.value) == STRING_CST 4540169689Skan && expr.original_code != STRING_CST) 4541169689Skan pedwarn_init ("array initialized from parenthesized string constant"); 4542169689Skan} 4543169689Skan 454418334Speter/* Digest the parser output INIT as an initializer for type TYPE. 454518334Speter Return a C expression of type TYPE to represent the initial value. 454618334Speter 4547169689Skan If INIT is a string constant, STRICT_STRING is true if it is 4548169689Skan unparenthesized or we should not warn here for it being parenthesized. 4549169689Skan For other types of INIT, STRICT_STRING is not used. 4550169689Skan 4551117395Skan REQUIRE_CONSTANT requests an error if non-constant initializers or 4552117395Skan elements are seen. */ 455318334Speter 455418334Speterstatic tree 4555169689Skandigest_init (tree type, tree init, bool strict_string, int require_constant) 455618334Speter{ 455718334Speter enum tree_code code = TREE_CODE (type); 455818334Speter tree inside_init = init; 455918334Speter 456090075Sobrien if (type == error_mark_node 4561169689Skan || !init 456290075Sobrien || init == error_mark_node 456390075Sobrien || TREE_TYPE (init) == error_mark_node) 456490075Sobrien return error_mark_node; 456518334Speter 4566169689Skan STRIP_TYPE_NOPS (inside_init); 456718334Speter 456890075Sobrien inside_init = fold (inside_init); 456990075Sobrien 457018334Speter /* Initialization of an array of chars from a string constant 457118334Speter optionally enclosed in braces. */ 457218334Speter 4573169689Skan if (code == ARRAY_TYPE && inside_init 4574169689Skan && TREE_CODE (inside_init) == STRING_CST) 457518334Speter { 457618334Speter tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type)); 4577169689Skan /* Note that an array could be both an array of character type 4578169689Skan and an array of wchar_t if wchar_t is signed char or unsigned 4579169689Skan char. */ 4580169689Skan bool char_array = (typ1 == char_type_node 4581169689Skan || typ1 == signed_char_type_node 4582169689Skan || typ1 == unsigned_char_type_node); 4583169689Skan bool wchar_array = !!comptypes (typ1, wchar_type_node); 4584169689Skan if (char_array || wchar_array) 458518334Speter { 4586169689Skan struct c_expr expr; 4587169689Skan bool char_string; 4588169689Skan expr.value = inside_init; 4589169689Skan expr.original_code = (strict_string ? STRING_CST : ERROR_MARK); 4590169689Skan maybe_warn_string_init (type, expr); 4591169689Skan 4592169689Skan char_string 4593169689Skan = (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init))) 4594169689Skan == char_type_node); 4595169689Skan 459618334Speter if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), 4597169689Skan TYPE_MAIN_VARIANT (type))) 459818334Speter return inside_init; 459918334Speter 4600169689Skan if (!wchar_array && !char_string) 460118334Speter { 460252284Sobrien error_init ("char-array initialized from wide string"); 460318334Speter return error_mark_node; 460418334Speter } 4605169689Skan if (char_string && !char_array) 460618334Speter { 4607169689Skan error_init ("wchar_t-array initialized from non-wide string"); 460818334Speter return error_mark_node; 460918334Speter } 461018334Speter 461118334Speter TREE_TYPE (inside_init) = type; 461218334Speter if (TYPE_DOMAIN (type) != 0 461390075Sobrien && TYPE_SIZE (type) != 0 461490075Sobrien && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST 461518334Speter /* Subtract 1 (or sizeof (wchar_t)) 461618334Speter because it's ok to ignore the terminating null char 461718334Speter that is counted in the length of the constant. */ 461890075Sobrien && 0 > compare_tree_int (TYPE_SIZE_UNIT (type), 461990075Sobrien TREE_STRING_LENGTH (inside_init) 462090075Sobrien - ((TYPE_PRECISION (typ1) 462190075Sobrien != TYPE_PRECISION (char_type_node)) 462290075Sobrien ? (TYPE_PRECISION (wchar_type_node) 462390075Sobrien / BITS_PER_UNIT) 462490075Sobrien : 1))) 462590075Sobrien pedwarn_init ("initializer-string for array of chars is too long"); 462690075Sobrien 462718334Speter return inside_init; 462818334Speter } 4629169689Skan else if (INTEGRAL_TYPE_P (typ1)) 4630169689Skan { 4631169689Skan error_init ("array of inappropriate type initialized " 4632169689Skan "from string constant"); 4633169689Skan return error_mark_node; 4634169689Skan } 463518334Speter } 4636132718Skan 4637119256Skan /* Build a VECTOR_CST from a *constant* vector constructor. If the 4638119256Skan vector constructor is not constant (e.g. {1,2,3,foo()}) then punt 4639119256Skan below and handle as a constructor. */ 4640146895Skan if (code == VECTOR_TYPE 4641161651Skan && TREE_CODE (TREE_TYPE (inside_init)) == VECTOR_TYPE 4642260075Spfg && vector_types_convertible_p (TREE_TYPE (inside_init), type, true) 4643146895Skan && TREE_CONSTANT (inside_init)) 4644146895Skan { 4645146895Skan if (TREE_CODE (inside_init) == VECTOR_CST 4646146895Skan && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), 4647169689Skan TYPE_MAIN_VARIANT (type))) 4648146895Skan return inside_init; 464918334Speter 4650146895Skan if (TREE_CODE (inside_init) == CONSTRUCTOR) 4651146895Skan { 4652169689Skan unsigned HOST_WIDE_INT ix; 4653169689Skan tree value; 4654169689Skan bool constant_p = true; 4655169689Skan 4656169689Skan /* Iterate through elements and check if all constructor 4657169689Skan elements are *_CSTs. */ 4658169689Skan FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (inside_init), ix, value) 4659169689Skan if (!CONSTANT_CLASS_P (value)) 4660169689Skan { 4661169689Skan constant_p = false; 4662169689Skan break; 4663169689Skan } 4664169689Skan 4665169689Skan if (constant_p) 4666169689Skan return build_vector_from_ctor (type, 4667169689Skan CONSTRUCTOR_ELTS (inside_init)); 4668169689Skan } 4669146895Skan } 4670146895Skan 467118334Speter /* Any type can be initialized 467218334Speter from an expression of the same type, optionally with braces. */ 467318334Speter 467418334Speter if (inside_init && TREE_TYPE (inside_init) != 0 467518334Speter && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), 4676169689Skan TYPE_MAIN_VARIANT (type)) 467718334Speter || (code == ARRAY_TYPE 4678169689Skan && comptypes (TREE_TYPE (inside_init), type)) 467996263Sobrien || (code == VECTOR_TYPE 4680169689Skan && comptypes (TREE_TYPE (inside_init), type)) 468118334Speter || (code == POINTER_TYPE 4682132718Skan && TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE 468318334Speter && comptypes (TREE_TYPE (TREE_TYPE (inside_init)), 4684169689Skan TREE_TYPE (type))))) 468518334Speter { 468690075Sobrien if (code == POINTER_TYPE) 4687122180Skan { 4688122180Skan if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE) 4689122180Skan { 4690169689Skan if (TREE_CODE (inside_init) == STRING_CST 4691169689Skan || TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR) 4692169689Skan inside_init = array_to_pointer_conversion (inside_init); 4693169689Skan else 4694169689Skan { 4695169689Skan error_init ("invalid use of non-lvalue array"); 4696169689Skan return error_mark_node; 4697169689Skan } 4698122180Skan } 4699169689Skan } 4700132718Skan 4701132718Skan if (code == VECTOR_TYPE) 4702132718Skan /* Although the types are compatible, we may require a 4703132718Skan conversion. */ 4704132718Skan inside_init = convert (type, inside_init); 4705132718Skan 4706169689Skan if (require_constant 4707169689Skan && (code == VECTOR_TYPE || !flag_isoc99) 470890075Sobrien && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR) 470918334Speter { 471090075Sobrien /* As an extension, allow initializing objects with static storage 471190075Sobrien duration with compound literals (which are then treated just as 4712169689Skan the brace enclosed list they contain). Also allow this for 4713169689Skan vectors, as we can only assign them with compound literals. */ 471490075Sobrien tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init); 471590075Sobrien inside_init = DECL_INITIAL (decl); 471690075Sobrien } 471790075Sobrien 471890075Sobrien if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST 471990075Sobrien && TREE_CODE (inside_init) != CONSTRUCTOR) 472090075Sobrien { 472152284Sobrien error_init ("array initialized from non-constant array expression"); 472218334Speter return error_mark_node; 472318334Speter } 472418334Speter 472518334Speter if (optimize && TREE_CODE (inside_init) == VAR_DECL) 472690075Sobrien inside_init = decl_constant_value_for_broken_optimization (inside_init); 472718334Speter 472818334Speter /* Compound expressions can only occur here if -pedantic or 472918334Speter -pedantic-errors is specified. In the later case, we always want 473018334Speter an error. In the former case, we simply want a warning. */ 473118334Speter if (require_constant && pedantic 473218334Speter && TREE_CODE (inside_init) == COMPOUND_EXPR) 473318334Speter { 473418334Speter inside_init 473518334Speter = valid_compound_expr_initializer (inside_init, 473618334Speter TREE_TYPE (inside_init)); 473718334Speter if (inside_init == error_mark_node) 473852284Sobrien error_init ("initializer element is not constant"); 473918334Speter else 474052284Sobrien pedwarn_init ("initializer element is not constant"); 474118334Speter if (flag_pedantic_errors) 474218334Speter inside_init = error_mark_node; 474318334Speter } 4744132718Skan else if (require_constant 4745169689Skan && !initializer_constant_valid_p (inside_init, 4746169689Skan TREE_TYPE (inside_init))) 474718334Speter { 474852284Sobrien error_init ("initializer element is not constant"); 474918334Speter inside_init = error_mark_node; 475018334Speter } 475118334Speter 4752169689Skan /* Added to enable additional -Wmissing-format-attribute warnings. */ 4753169689Skan if (TREE_CODE (TREE_TYPE (inside_init)) == POINTER_TYPE) 4754169689Skan inside_init = convert_for_assignment (type, inside_init, ic_init, NULL_TREE, 4755169689Skan NULL_TREE, 0); 475618334Speter return inside_init; 475718334Speter } 475818334Speter 475918334Speter /* Handle scalar types, including conversions. */ 476018334Speter 476118334Speter if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE 4762169689Skan || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE 4763169689Skan || code == VECTOR_TYPE) 476418334Speter { 4765169689Skan if (TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE 4766169689Skan && (TREE_CODE (init) == STRING_CST 4767169689Skan || TREE_CODE (init) == COMPOUND_LITERAL_EXPR)) 4768169689Skan init = array_to_pointer_conversion (init); 476918334Speter inside_init 4770169689Skan = convert_for_assignment (type, init, ic_init, 477118334Speter NULL_TREE, NULL_TREE, 0); 477218334Speter 4773169689Skan /* Check to see if we have already given an error message. */ 4774169689Skan if (inside_init == error_mark_node) 4775169689Skan ; 4776169689Skan else if (require_constant && !TREE_CONSTANT (inside_init)) 477718334Speter { 477852284Sobrien error_init ("initializer element is not constant"); 477918334Speter inside_init = error_mark_node; 478018334Speter } 478118334Speter else if (require_constant 4782169689Skan && !initializer_constant_valid_p (inside_init, 4783169689Skan TREE_TYPE (inside_init))) 478418334Speter { 478552284Sobrien error_init ("initializer element is not computable at load time"); 478618334Speter inside_init = error_mark_node; 478718334Speter } 478818334Speter 478918334Speter return inside_init; 479018334Speter } 479118334Speter 479218334Speter /* Come here only for records and arrays. */ 479318334Speter 479490075Sobrien if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) 479518334Speter { 479652284Sobrien error_init ("variable-sized object may not be initialized"); 479718334Speter return error_mark_node; 479818334Speter } 479918334Speter 480052284Sobrien error_init ("invalid initializer"); 480118334Speter return error_mark_node; 480218334Speter} 480318334Speter 480418334Speter/* Handle initializers that use braces. */ 480518334Speter 480618334Speter/* Type of object we are accumulating a constructor for. 480718334Speter This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */ 480818334Speterstatic tree constructor_type; 480918334Speter 481018334Speter/* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields 481118334Speter left to fill. */ 481218334Speterstatic tree constructor_fields; 481318334Speter 481418334Speter/* For an ARRAY_TYPE, this is the specified index 481590075Sobrien at which to store the next element we get. */ 481618334Speterstatic tree constructor_index; 481718334Speter 481818334Speter/* For an ARRAY_TYPE, this is the maximum index. */ 481918334Speterstatic tree constructor_max_index; 482018334Speter 482118334Speter/* For a RECORD_TYPE, this is the first field not yet written out. */ 482218334Speterstatic tree constructor_unfilled_fields; 482318334Speter 482418334Speter/* For an ARRAY_TYPE, this is the index of the first element 482590075Sobrien not yet written out. */ 482618334Speterstatic tree constructor_unfilled_index; 482718334Speter 482818334Speter/* In a RECORD_TYPE, the byte index of the next consecutive field. 482990075Sobrien This is so we can generate gaps between fields, when appropriate. */ 483018334Speterstatic tree constructor_bit_index; 483118334Speter 483218334Speter/* If we are saving up the elements rather than allocating them, 483318334Speter this is the list of elements so far (in reverse order, 483418334Speter most recent first). */ 4835169689Skanstatic VEC(constructor_elt,gc) *constructor_elements; 483618334Speter 483790075Sobrien/* 1 if constructor should be incrementally stored into a constructor chain, 483890075Sobrien 0 if all the elements should be kept in AVL tree. */ 483990075Sobrienstatic int constructor_incremental; 484090075Sobrien 484118334Speter/* 1 if so far this constructor's elements are all compile-time constants. */ 484218334Speterstatic int constructor_constant; 484318334Speter 484418334Speter/* 1 if so far this constructor's elements are all valid address constants. */ 484518334Speterstatic int constructor_simple; 484618334Speter 484718334Speter/* 1 if this constructor is erroneous so far. */ 484818334Speterstatic int constructor_erroneous; 484918334Speter 485050397Sobrien/* Structure for managing pending initializer elements, organized as an 485150397Sobrien AVL tree. */ 485250397Sobrien 485350397Sobrienstruct init_node 485450397Sobrien{ 485550397Sobrien struct init_node *left, *right; 485650397Sobrien struct init_node *parent; 485750397Sobrien int balance; 485850397Sobrien tree purpose; 485950397Sobrien tree value; 486050397Sobrien}; 486150397Sobrien 486250397Sobrien/* Tree of pending elements at this constructor level. 486318334Speter These are elements encountered out of order 486418334Speter which belong at places we haven't reached yet in actually 486590075Sobrien writing the output. 486690075Sobrien Will never hold tree nodes across GC runs. */ 486750397Sobrienstatic struct init_node *constructor_pending_elts; 486818334Speter 486918334Speter/* The SPELLING_DEPTH of this constructor. */ 487018334Speterstatic int constructor_depth; 487118334Speter 487218334Speter/* DECL node for which an initializer is being read. 487318334Speter 0 means we are reading a constructor expression 487418334Speter such as (struct foo) {...}. */ 487518334Speterstatic tree constructor_decl; 487618334Speter 487718334Speter/* Nonzero if this is an initializer for a top-level decl. */ 487818334Speterstatic int constructor_top_level; 487918334Speter 488090075Sobrien/* Nonzero if there were any member designators in this initializer. */ 488190075Sobrienstatic int constructor_designated; 488290075Sobrien 488390075Sobrien/* Nesting depth of designator list. */ 488490075Sobrienstatic int designator_depth; 488590075Sobrien 488690075Sobrien/* Nonzero if there were diagnosed errors in this designator list. */ 4887169689Skanstatic int designator_erroneous; 488890075Sobrien 488918334Speter 489018334Speter/* This stack has a level for each implicit or explicit level of 489118334Speter structuring in the initializer, including the outermost one. It 489218334Speter saves the values of most of the variables above. */ 489318334Speter 489490075Sobrienstruct constructor_range_stack; 489590075Sobrien 489618334Speterstruct constructor_stack 489718334Speter{ 489818334Speter struct constructor_stack *next; 489918334Speter tree type; 490018334Speter tree fields; 490118334Speter tree index; 490218334Speter tree max_index; 490318334Speter tree unfilled_index; 490418334Speter tree unfilled_fields; 490518334Speter tree bit_index; 4906169689Skan VEC(constructor_elt,gc) *elements; 490790075Sobrien struct init_node *pending_elts; 490818334Speter int offset; 490918334Speter int depth; 4910169689Skan /* If value nonzero, this value should replace the entire 491118334Speter constructor at this level. */ 4912169689Skan struct c_expr replacement_value; 491390075Sobrien struct constructor_range_stack *range_stack; 491418334Speter char constant; 491518334Speter char simple; 491618334Speter char implicit; 491718334Speter char erroneous; 491818334Speter char outer; 491990075Sobrien char incremental; 492090075Sobrien char designated; 492118334Speter}; 492218334Speter 4923169689Skanstatic struct constructor_stack *constructor_stack; 492418334Speter 492590075Sobrien/* This stack represents designators from some range designator up to 492690075Sobrien the last designator in the list. */ 492790075Sobrien 492890075Sobrienstruct constructor_range_stack 492990075Sobrien{ 493090075Sobrien struct constructor_range_stack *next, *prev; 493190075Sobrien struct constructor_stack *stack; 493290075Sobrien tree range_start; 493390075Sobrien tree index; 493490075Sobrien tree range_end; 493590075Sobrien tree fields; 493690075Sobrien}; 493790075Sobrien 4938169689Skanstatic struct constructor_range_stack *constructor_range_stack; 493990075Sobrien 494018334Speter/* This stack records separate initializers that are nested. 494118334Speter Nested initializers can't happen in ANSI C, but GNU C allows them 494218334Speter in cases like { ... (struct foo) { ... } ... }. */ 494318334Speter 494418334Speterstruct initializer_stack 494518334Speter{ 494618334Speter struct initializer_stack *next; 494718334Speter tree decl; 494818334Speter struct constructor_stack *constructor_stack; 494990075Sobrien struct constructor_range_stack *constructor_range_stack; 4950169689Skan VEC(constructor_elt,gc) *elements; 495118334Speter struct spelling *spelling; 495218334Speter struct spelling *spelling_base; 495318334Speter int spelling_size; 495418334Speter char top_level; 495518334Speter char require_constant_value; 495618334Speter char require_constant_elements; 495718334Speter}; 495818334Speter 4959169689Skanstatic struct initializer_stack *initializer_stack; 496018334Speter 496118334Speter/* Prepare to parse and output the initializer for variable DECL. */ 496218334Speter 496318334Spetervoid 4964169689Skanstart_init (tree decl, tree asmspec_tree ATTRIBUTE_UNUSED, int top_level) 496518334Speter{ 496652284Sobrien const char *locus; 4967169689Skan struct initializer_stack *p = XNEW (struct initializer_stack); 496818334Speter 496918334Speter p->decl = constructor_decl; 497018334Speter p->require_constant_value = require_constant_value; 497118334Speter p->require_constant_elements = require_constant_elements; 497218334Speter p->constructor_stack = constructor_stack; 497390075Sobrien p->constructor_range_stack = constructor_range_stack; 497418334Speter p->elements = constructor_elements; 497518334Speter p->spelling = spelling; 497618334Speter p->spelling_base = spelling_base; 497718334Speter p->spelling_size = spelling_size; 497818334Speter p->top_level = constructor_top_level; 497918334Speter p->next = initializer_stack; 498018334Speter initializer_stack = p; 498118334Speter 498218334Speter constructor_decl = decl; 498390075Sobrien constructor_designated = 0; 498418334Speter constructor_top_level = top_level; 498518334Speter 4986169689Skan if (decl != 0 && decl != error_mark_node) 498718334Speter { 498818334Speter require_constant_value = TREE_STATIC (decl); 498918334Speter require_constant_elements 499090075Sobrien = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99)) 499118334Speter /* For a scalar, you can always use any value to initialize, 499218334Speter even within braces. */ 499318334Speter && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE 499418334Speter || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE 499518334Speter || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE 499618334Speter || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE)); 499718334Speter locus = IDENTIFIER_POINTER (DECL_NAME (decl)); 499818334Speter } 499918334Speter else 500018334Speter { 500118334Speter require_constant_value = 0; 500218334Speter require_constant_elements = 0; 500318334Speter locus = "(anonymous)"; 500418334Speter } 500518334Speter 500618334Speter constructor_stack = 0; 500790075Sobrien constructor_range_stack = 0; 500818334Speter 500918334Speter missing_braces_mentioned = 0; 501018334Speter 501118334Speter spelling_base = 0; 501218334Speter spelling_size = 0; 501318334Speter RESTORE_SPELLING_DEPTH (0); 501418334Speter 501518334Speter if (locus) 501618334Speter push_string (locus); 501718334Speter} 501818334Speter 501918334Spetervoid 5020132718Skanfinish_init (void) 502118334Speter{ 502218334Speter struct initializer_stack *p = initializer_stack; 502318334Speter 502418334Speter /* Free the whole constructor stack of this initializer. */ 502518334Speter while (constructor_stack) 502618334Speter { 502718334Speter struct constructor_stack *q = constructor_stack; 502818334Speter constructor_stack = q->next; 502918334Speter free (q); 503018334Speter } 503118334Speter 5032169689Skan gcc_assert (!constructor_range_stack); 503390075Sobrien 503418334Speter /* Pop back to the data of the outer initializer (if any). */ 5035132718Skan free (spelling_base); 5036132718Skan 503718334Speter constructor_decl = p->decl; 503818334Speter require_constant_value = p->require_constant_value; 503918334Speter require_constant_elements = p->require_constant_elements; 504018334Speter constructor_stack = p->constructor_stack; 504190075Sobrien constructor_range_stack = p->constructor_range_stack; 504218334Speter constructor_elements = p->elements; 504318334Speter spelling = p->spelling; 504418334Speter spelling_base = p->spelling_base; 504518334Speter spelling_size = p->spelling_size; 504618334Speter constructor_top_level = p->top_level; 504718334Speter initializer_stack = p->next; 504818334Speter free (p); 504918334Speter} 505018334Speter 505118334Speter/* Call here when we see the initializer is surrounded by braces. 505218334Speter This is instead of a call to push_init_level; 505318334Speter it is matched by a call to pop_init_level. 505418334Speter 505518334Speter TYPE is the type to initialize, for a constructor expression. 505618334Speter For an initializer for a decl, TYPE is zero. */ 505718334Speter 505818334Spetervoid 5059132718Skanreally_start_incremental_init (tree type) 506018334Speter{ 5061169689Skan struct constructor_stack *p = XNEW (struct constructor_stack); 506218334Speter 506318334Speter if (type == 0) 506418334Speter type = TREE_TYPE (constructor_decl); 506518334Speter 5066169689Skan if (targetm.vector_opaque_p (type)) 5067132718Skan error ("opaque vector types cannot be initialized"); 5068132718Skan 506918334Speter p->type = constructor_type; 507018334Speter p->fields = constructor_fields; 507118334Speter p->index = constructor_index; 507218334Speter p->max_index = constructor_max_index; 507318334Speter p->unfilled_index = constructor_unfilled_index; 507418334Speter p->unfilled_fields = constructor_unfilled_fields; 507518334Speter p->bit_index = constructor_bit_index; 507618334Speter p->elements = constructor_elements; 507718334Speter p->constant = constructor_constant; 507818334Speter p->simple = constructor_simple; 507918334Speter p->erroneous = constructor_erroneous; 508018334Speter p->pending_elts = constructor_pending_elts; 508118334Speter p->depth = constructor_depth; 5082169689Skan p->replacement_value.value = 0; 5083169689Skan p->replacement_value.original_code = ERROR_MARK; 508418334Speter p->implicit = 0; 508590075Sobrien p->range_stack = 0; 508690075Sobrien p->outer = 0; 508718334Speter p->incremental = constructor_incremental; 508890075Sobrien p->designated = constructor_designated; 508918334Speter p->next = 0; 509018334Speter constructor_stack = p; 509118334Speter 509218334Speter constructor_constant = 1; 509318334Speter constructor_simple = 1; 509418334Speter constructor_depth = SPELLING_DEPTH (); 509518334Speter constructor_elements = 0; 509618334Speter constructor_pending_elts = 0; 509718334Speter constructor_type = type; 509890075Sobrien constructor_incremental = 1; 509990075Sobrien constructor_designated = 0; 510090075Sobrien designator_depth = 0; 5101169689Skan designator_erroneous = 0; 510218334Speter 510318334Speter if (TREE_CODE (constructor_type) == RECORD_TYPE 510418334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 510518334Speter { 510618334Speter constructor_fields = TYPE_FIELDS (constructor_type); 510718334Speter /* Skip any nameless bit fields at the beginning. */ 510850397Sobrien while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields) 510918334Speter && DECL_NAME (constructor_fields) == 0) 511018334Speter constructor_fields = TREE_CHAIN (constructor_fields); 511190075Sobrien 511218334Speter constructor_unfilled_fields = constructor_fields; 511390075Sobrien constructor_bit_index = bitsize_zero_node; 511418334Speter } 511518334Speter else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 511618334Speter { 511718334Speter if (TYPE_DOMAIN (constructor_type)) 511818334Speter { 511918334Speter constructor_max_index 512018334Speter = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)); 512190075Sobrien 512290075Sobrien /* Detect non-empty initializations of zero-length arrays. */ 512390075Sobrien if (constructor_max_index == NULL_TREE 512490075Sobrien && TYPE_SIZE (constructor_type)) 5125169689Skan constructor_max_index = build_int_cst (NULL_TREE, -1); 512690075Sobrien 512790075Sobrien /* constructor_max_index needs to be an INTEGER_CST. Attempts 5128117395Skan to initialize VLAs will cause a proper error; avoid tree 512990075Sobrien checking errors as well by setting a safe value. */ 513090075Sobrien if (constructor_max_index 513190075Sobrien && TREE_CODE (constructor_max_index) != INTEGER_CST) 5132169689Skan constructor_max_index = build_int_cst (NULL_TREE, -1); 513390075Sobrien 513418334Speter constructor_index 513590075Sobrien = convert (bitsizetype, 513690075Sobrien TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type))); 513718334Speter } 513818334Speter else 5139169689Skan { 5140169689Skan constructor_index = bitsize_zero_node; 5141169689Skan constructor_max_index = NULL_TREE; 5142169689Skan } 514390075Sobrien 514490075Sobrien constructor_unfilled_index = constructor_index; 514518334Speter } 514696263Sobrien else if (TREE_CODE (constructor_type) == VECTOR_TYPE) 514796263Sobrien { 514896263Sobrien /* Vectors are like simple fixed-size arrays. */ 514996263Sobrien constructor_max_index = 5150169689Skan build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1); 5151169689Skan constructor_index = bitsize_zero_node; 515296263Sobrien constructor_unfilled_index = constructor_index; 515396263Sobrien } 515418334Speter else 515518334Speter { 515618334Speter /* Handle the case of int x = {5}; */ 515718334Speter constructor_fields = constructor_type; 515818334Speter constructor_unfilled_fields = constructor_type; 515918334Speter } 516018334Speter} 516118334Speter 516218334Speter/* Push down into a subobject, for initialization. 516318334Speter If this is for an explicit set of braces, IMPLICIT is 0. 516418334Speter If it is because the next element belongs at a lower level, 516590075Sobrien IMPLICIT is 1 (or 2 if the push is because of designator list). */ 516618334Speter 516718334Spetervoid 5168132718Skanpush_init_level (int implicit) 516918334Speter{ 517018334Speter struct constructor_stack *p; 517190075Sobrien tree value = NULL_TREE; 517218334Speter 517318334Speter /* If we've exhausted any levels that didn't have braces, 5174161651Skan pop them now. If implicit == 1, this will have been done in 5175161651Skan process_init_element; do not repeat it here because in the case 5176161651Skan of excess initializers for an empty aggregate this leads to an 5177161651Skan infinite cycle of popping a level and immediately recreating 5178161651Skan it. */ 5179161651Skan if (implicit != 1) 518018334Speter { 5181161651Skan while (constructor_stack->implicit) 5182161651Skan { 5183161651Skan if ((TREE_CODE (constructor_type) == RECORD_TYPE 5184161651Skan || TREE_CODE (constructor_type) == UNION_TYPE) 5185161651Skan && constructor_fields == 0) 5186161651Skan process_init_element (pop_init_level (1)); 5187161651Skan else if (TREE_CODE (constructor_type) == ARRAY_TYPE 5188161651Skan && constructor_max_index 5189161651Skan && tree_int_cst_lt (constructor_max_index, 5190161651Skan constructor_index)) 5191161651Skan process_init_element (pop_init_level (1)); 5192161651Skan else 5193161651Skan break; 5194161651Skan } 519518334Speter } 519618334Speter 519790075Sobrien /* Unless this is an explicit brace, we need to preserve previous 519890075Sobrien content if any. */ 519990075Sobrien if (implicit) 520018334Speter { 520190075Sobrien if ((TREE_CODE (constructor_type) == RECORD_TYPE 520290075Sobrien || TREE_CODE (constructor_type) == UNION_TYPE) 520390075Sobrien && constructor_fields) 520490075Sobrien value = find_init_member (constructor_fields); 520590075Sobrien else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 520690075Sobrien value = find_init_member (constructor_index); 520718334Speter } 520818334Speter 5209169689Skan p = XNEW (struct constructor_stack); 521018334Speter p->type = constructor_type; 521118334Speter p->fields = constructor_fields; 521218334Speter p->index = constructor_index; 521318334Speter p->max_index = constructor_max_index; 521418334Speter p->unfilled_index = constructor_unfilled_index; 521518334Speter p->unfilled_fields = constructor_unfilled_fields; 521618334Speter p->bit_index = constructor_bit_index; 521718334Speter p->elements = constructor_elements; 521818334Speter p->constant = constructor_constant; 521918334Speter p->simple = constructor_simple; 522018334Speter p->erroneous = constructor_erroneous; 522118334Speter p->pending_elts = constructor_pending_elts; 522218334Speter p->depth = constructor_depth; 5223169689Skan p->replacement_value.value = 0; 5224169689Skan p->replacement_value.original_code = ERROR_MARK; 522518334Speter p->implicit = implicit; 522690075Sobrien p->outer = 0; 522718334Speter p->incremental = constructor_incremental; 522890075Sobrien p->designated = constructor_designated; 522918334Speter p->next = constructor_stack; 523090075Sobrien p->range_stack = 0; 523118334Speter constructor_stack = p; 523218334Speter 523318334Speter constructor_constant = 1; 523418334Speter constructor_simple = 1; 523518334Speter constructor_depth = SPELLING_DEPTH (); 523618334Speter constructor_elements = 0; 523790075Sobrien constructor_incremental = 1; 523890075Sobrien constructor_designated = 0; 523918334Speter constructor_pending_elts = 0; 524090075Sobrien if (!implicit) 524190075Sobrien { 524290075Sobrien p->range_stack = constructor_range_stack; 524390075Sobrien constructor_range_stack = 0; 524490075Sobrien designator_depth = 0; 5245169689Skan designator_erroneous = 0; 524690075Sobrien } 524718334Speter 524818334Speter /* Don't die if an entire brace-pair level is superfluous 524918334Speter in the containing level. */ 525018334Speter if (constructor_type == 0) 525118334Speter ; 525218334Speter else if (TREE_CODE (constructor_type) == RECORD_TYPE 525318334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 525418334Speter { 525518334Speter /* Don't die if there are extra init elts at the end. */ 525618334Speter if (constructor_fields == 0) 525718334Speter constructor_type = 0; 525818334Speter else 525918334Speter { 526018334Speter constructor_type = TREE_TYPE (constructor_fields); 526118334Speter push_member_name (constructor_fields); 526218334Speter constructor_depth++; 526318334Speter } 526418334Speter } 526518334Speter else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 526618334Speter { 526718334Speter constructor_type = TREE_TYPE (constructor_type); 5268169689Skan push_array_bounds (tree_low_cst (constructor_index, 1)); 526918334Speter constructor_depth++; 527018334Speter } 527118334Speter 527218334Speter if (constructor_type == 0) 527318334Speter { 527452284Sobrien error_init ("extra brace group at end of initializer"); 527518334Speter constructor_fields = 0; 527618334Speter constructor_unfilled_fields = 0; 527718334Speter return; 527818334Speter } 527918334Speter 528090075Sobrien if (value && TREE_CODE (value) == CONSTRUCTOR) 528190075Sobrien { 528290075Sobrien constructor_constant = TREE_CONSTANT (value); 528390075Sobrien constructor_simple = TREE_STATIC (value); 5284132718Skan constructor_elements = CONSTRUCTOR_ELTS (value); 5285169689Skan if (!VEC_empty (constructor_elt, constructor_elements) 528690075Sobrien && (TREE_CODE (constructor_type) == RECORD_TYPE 528790075Sobrien || TREE_CODE (constructor_type) == ARRAY_TYPE)) 528890075Sobrien set_nonincremental_init (); 528990075Sobrien } 529018334Speter 529190075Sobrien if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned) 529218334Speter { 529318334Speter missing_braces_mentioned = 1; 529452284Sobrien warning_init ("missing braces around initializer"); 529518334Speter } 529618334Speter 529718334Speter if (TREE_CODE (constructor_type) == RECORD_TYPE 529818334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 529918334Speter { 530018334Speter constructor_fields = TYPE_FIELDS (constructor_type); 530118334Speter /* Skip any nameless bit fields at the beginning. */ 530250397Sobrien while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields) 530318334Speter && DECL_NAME (constructor_fields) == 0) 530418334Speter constructor_fields = TREE_CHAIN (constructor_fields); 530590075Sobrien 530618334Speter constructor_unfilled_fields = constructor_fields; 530790075Sobrien constructor_bit_index = bitsize_zero_node; 530818334Speter } 530996263Sobrien else if (TREE_CODE (constructor_type) == VECTOR_TYPE) 531096263Sobrien { 531196263Sobrien /* Vectors are like simple fixed-size arrays. */ 531296263Sobrien constructor_max_index = 5313169689Skan build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1); 531496263Sobrien constructor_index = convert (bitsizetype, integer_zero_node); 531596263Sobrien constructor_unfilled_index = constructor_index; 531696263Sobrien } 531718334Speter else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 531818334Speter { 531918334Speter if (TYPE_DOMAIN (constructor_type)) 532018334Speter { 532118334Speter constructor_max_index 532218334Speter = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)); 532390075Sobrien 532490075Sobrien /* Detect non-empty initializations of zero-length arrays. */ 532590075Sobrien if (constructor_max_index == NULL_TREE 532690075Sobrien && TYPE_SIZE (constructor_type)) 5327169689Skan constructor_max_index = build_int_cst (NULL_TREE, -1); 532890075Sobrien 532990075Sobrien /* constructor_max_index needs to be an INTEGER_CST. Attempts 5330117395Skan to initialize VLAs will cause a proper error; avoid tree 533190075Sobrien checking errors as well by setting a safe value. */ 533290075Sobrien if (constructor_max_index 533390075Sobrien && TREE_CODE (constructor_max_index) != INTEGER_CST) 5334169689Skan constructor_max_index = build_int_cst (NULL_TREE, -1); 533590075Sobrien 533618334Speter constructor_index 5337132718Skan = convert (bitsizetype, 533890075Sobrien TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type))); 533918334Speter } 534018334Speter else 534190075Sobrien constructor_index = bitsize_zero_node; 534290075Sobrien 534390075Sobrien constructor_unfilled_index = constructor_index; 534490075Sobrien if (value && TREE_CODE (value) == STRING_CST) 534590075Sobrien { 534690075Sobrien /* We need to split the char/wchar array into individual 534790075Sobrien characters, so that we don't have to special case it 534890075Sobrien everywhere. */ 534990075Sobrien set_nonincremental_init_from_string (value); 535090075Sobrien } 535118334Speter } 535218334Speter else 535318334Speter { 5354169689Skan if (constructor_type != error_mark_node) 5355169689Skan warning_init ("braces around scalar initializer"); 535618334Speter constructor_fields = constructor_type; 535718334Speter constructor_unfilled_fields = constructor_type; 535818334Speter } 535918334Speter} 536018334Speter 5361132718Skan/* At the end of an implicit or explicit brace level, 5362169689Skan finish up that level of constructor. If a single expression 5363169689Skan with redundant braces initialized that level, return the 5364169689Skan c_expr structure for that expression. Otherwise, the original_code 5365169689Skan element is set to ERROR_MARK. 5366169689Skan If we were outputting the elements as they are read, return 0 as the value 536718334Speter from inner levels (process_init_element ignores that), 5368169689Skan but return error_mark_node as the value from the outermost level 536918334Speter (that's what we want to put in DECL_INITIAL). 5370169689Skan Otherwise, return a CONSTRUCTOR expression as the value. */ 537118334Speter 5372169689Skanstruct c_expr 5373132718Skanpop_init_level (int implicit) 537418334Speter{ 537518334Speter struct constructor_stack *p; 5376169689Skan struct c_expr ret; 5377169689Skan ret.value = 0; 5378169689Skan ret.original_code = ERROR_MARK; 537918334Speter 538018334Speter if (implicit == 0) 538118334Speter { 538218334Speter /* When we come to an explicit close brace, 538318334Speter pop any inner levels that didn't have explicit braces. */ 538418334Speter while (constructor_stack->implicit) 538518334Speter process_init_element (pop_init_level (1)); 538690075Sobrien 5387169689Skan gcc_assert (!constructor_range_stack); 538818334Speter } 538918334Speter 5390132718Skan /* Now output all pending elements. */ 5391132718Skan constructor_incremental = 1; 5392132718Skan output_pending_init_elements (1); 5393132718Skan 539418334Speter p = constructor_stack; 539518334Speter 539690075Sobrien /* Error for initializing a flexible array member, or a zero-length 539790075Sobrien array member in an inappropriate context. */ 539890075Sobrien if (constructor_type && constructor_fields 539990075Sobrien && TREE_CODE (constructor_type) == ARRAY_TYPE 540090075Sobrien && TYPE_DOMAIN (constructor_type) 5401169689Skan && !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type))) 540290075Sobrien { 540390075Sobrien /* Silently discard empty initializations. The parser will 540490075Sobrien already have pedwarned for empty brackets. */ 540590075Sobrien if (integer_zerop (constructor_unfilled_index)) 540690075Sobrien constructor_type = NULL_TREE; 5407169689Skan else 540890075Sobrien { 5409169689Skan gcc_assert (!TYPE_SIZE (constructor_type)); 5410169689Skan 541190075Sobrien if (constructor_depth > 2) 541290075Sobrien error_init ("initialization of flexible array member in a nested context"); 541390075Sobrien else if (pedantic) 541490075Sobrien pedwarn_init ("initialization of a flexible array member"); 541518334Speter 541690075Sobrien /* We have already issued an error message for the existence 541790075Sobrien of a flexible array member not at the end of the structure. 5418169689Skan Discard the initializer so that we do not die later. */ 541990075Sobrien if (TREE_CHAIN (constructor_fields) != NULL_TREE) 542090075Sobrien constructor_type = NULL_TREE; 542190075Sobrien } 542290075Sobrien } 542390075Sobrien 542450397Sobrien /* Warn when some struct elements are implicitly initialized to zero. */ 5425169689Skan if (warn_missing_field_initializers 542650397Sobrien && constructor_type 542750397Sobrien && TREE_CODE (constructor_type) == RECORD_TYPE 542850397Sobrien && constructor_unfilled_fields) 542950397Sobrien { 543090075Sobrien /* Do not warn for flexible array members or zero-length arrays. */ 543190075Sobrien while (constructor_unfilled_fields 5432169689Skan && (!DECL_SIZE (constructor_unfilled_fields) 543390075Sobrien || integer_zerop (DECL_SIZE (constructor_unfilled_fields)))) 543490075Sobrien constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields); 543590075Sobrien 543690075Sobrien /* Do not warn if this level of the initializer uses member 543790075Sobrien designators; it is likely to be deliberate. */ 543890075Sobrien if (constructor_unfilled_fields && !constructor_designated) 543990075Sobrien { 544090075Sobrien push_member_name (constructor_unfilled_fields); 544190075Sobrien warning_init ("missing initializer"); 544290075Sobrien RESTORE_SPELLING_DEPTH (constructor_depth); 544390075Sobrien } 544450397Sobrien } 544550397Sobrien 544618334Speter /* Pad out the end of the structure. */ 5447169689Skan if (p->replacement_value.value) 544890075Sobrien /* If this closes a superfluous brace pair, 544990075Sobrien just pass out the element between them. */ 5450169689Skan ret = p->replacement_value; 545118334Speter else if (constructor_type == 0) 545218334Speter ; 545318334Speter else if (TREE_CODE (constructor_type) != RECORD_TYPE 545418334Speter && TREE_CODE (constructor_type) != UNION_TYPE 545596263Sobrien && TREE_CODE (constructor_type) != ARRAY_TYPE 545696263Sobrien && TREE_CODE (constructor_type) != VECTOR_TYPE) 545718334Speter { 545818334Speter /* A nonincremental scalar initializer--just return 545918334Speter the element, after verifying there is just one. */ 5460169689Skan if (VEC_empty (constructor_elt,constructor_elements)) 546118334Speter { 546290075Sobrien if (!constructor_erroneous) 546390075Sobrien error_init ("empty scalar initializer"); 5464169689Skan ret.value = error_mark_node; 546518334Speter } 5466169689Skan else if (VEC_length (constructor_elt,constructor_elements) != 1) 546718334Speter { 546852284Sobrien error_init ("extra elements in scalar initializer"); 5469169689Skan ret.value = VEC_index (constructor_elt,constructor_elements,0)->value; 547018334Speter } 547118334Speter else 5472169689Skan ret.value = VEC_index (constructor_elt,constructor_elements,0)->value; 547318334Speter } 547490075Sobrien else 547518334Speter { 547618334Speter if (constructor_erroneous) 5477169689Skan ret.value = error_mark_node; 547818334Speter else 547918334Speter { 5480169689Skan ret.value = build_constructor (constructor_type, 5481169689Skan constructor_elements); 548218334Speter if (constructor_constant) 5483169689Skan TREE_CONSTANT (ret.value) = TREE_INVARIANT (ret.value) = 1; 548418334Speter if (constructor_constant && constructor_simple) 5485169689Skan TREE_STATIC (ret.value) = 1; 548618334Speter } 548718334Speter } 548818334Speter 548918334Speter constructor_type = p->type; 549018334Speter constructor_fields = p->fields; 549118334Speter constructor_index = p->index; 549218334Speter constructor_max_index = p->max_index; 549318334Speter constructor_unfilled_index = p->unfilled_index; 549418334Speter constructor_unfilled_fields = p->unfilled_fields; 549518334Speter constructor_bit_index = p->bit_index; 549618334Speter constructor_elements = p->elements; 549718334Speter constructor_constant = p->constant; 549818334Speter constructor_simple = p->simple; 549918334Speter constructor_erroneous = p->erroneous; 550090075Sobrien constructor_incremental = p->incremental; 550190075Sobrien constructor_designated = p->designated; 550218334Speter constructor_pending_elts = p->pending_elts; 550318334Speter constructor_depth = p->depth; 550490075Sobrien if (!p->implicit) 550590075Sobrien constructor_range_stack = p->range_stack; 550618334Speter RESTORE_SPELLING_DEPTH (constructor_depth); 550718334Speter 550818334Speter constructor_stack = p->next; 550918334Speter free (p); 551018334Speter 5511169689Skan if (ret.value == 0 && constructor_stack == 0) 5512169689Skan ret.value = error_mark_node; 5513169689Skan return ret; 551418334Speter} 551518334Speter 551690075Sobrien/* Common handling for both array range and field name designators. 5517117395Skan ARRAY argument is nonzero for array ranges. Returns zero for success. */ 551890075Sobrien 551990075Sobrienstatic int 5520132718Skanset_designator (int array) 552190075Sobrien{ 552290075Sobrien tree subtype; 552390075Sobrien enum tree_code subcode; 552490075Sobrien 552590075Sobrien /* Don't die if an entire brace-pair level is superfluous 552690075Sobrien in the containing level. */ 552790075Sobrien if (constructor_type == 0) 552890075Sobrien return 1; 552990075Sobrien 5530169689Skan /* If there were errors in this designator list already, bail out 5531169689Skan silently. */ 5532169689Skan if (designator_erroneous) 553390075Sobrien return 1; 553490075Sobrien 553590075Sobrien if (!designator_depth) 553690075Sobrien { 5537169689Skan gcc_assert (!constructor_range_stack); 553890075Sobrien 553990075Sobrien /* Designator list starts at the level of closest explicit 554090075Sobrien braces. */ 554190075Sobrien while (constructor_stack->implicit) 554290075Sobrien process_init_element (pop_init_level (1)); 554390075Sobrien constructor_designated = 1; 554490075Sobrien return 0; 554590075Sobrien } 554690075Sobrien 5547169689Skan switch (TREE_CODE (constructor_type)) 554890075Sobrien { 5549169689Skan case RECORD_TYPE: 5550169689Skan case UNION_TYPE: 555190075Sobrien subtype = TREE_TYPE (constructor_fields); 555290075Sobrien if (subtype != error_mark_node) 555390075Sobrien subtype = TYPE_MAIN_VARIANT (subtype); 5554169689Skan break; 5555169689Skan case ARRAY_TYPE: 555690075Sobrien subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type)); 5557169689Skan break; 5558169689Skan default: 5559169689Skan gcc_unreachable (); 556090075Sobrien } 556190075Sobrien 556290075Sobrien subcode = TREE_CODE (subtype); 556390075Sobrien if (array && subcode != ARRAY_TYPE) 556490075Sobrien { 556590075Sobrien error_init ("array index in non-array initializer"); 556690075Sobrien return 1; 556790075Sobrien } 556890075Sobrien else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE) 556990075Sobrien { 557090075Sobrien error_init ("field name not in record or union initializer"); 557190075Sobrien return 1; 557290075Sobrien } 557390075Sobrien 557490075Sobrien constructor_designated = 1; 557590075Sobrien push_init_level (2); 557690075Sobrien return 0; 557790075Sobrien} 557890075Sobrien 557990075Sobrien/* If there are range designators in designator list, push a new designator 558090075Sobrien to constructor_range_stack. RANGE_END is end of such stack range or 558190075Sobrien NULL_TREE if there is no range designator at this level. */ 558290075Sobrien 558390075Sobrienstatic void 5584132718Skanpush_range_stack (tree range_end) 558590075Sobrien{ 558690075Sobrien struct constructor_range_stack *p; 558790075Sobrien 5588169689Skan p = GGC_NEW (struct constructor_range_stack); 558990075Sobrien p->prev = constructor_range_stack; 559090075Sobrien p->next = 0; 559190075Sobrien p->fields = constructor_fields; 559290075Sobrien p->range_start = constructor_index; 559390075Sobrien p->index = constructor_index; 559490075Sobrien p->stack = constructor_stack; 559590075Sobrien p->range_end = range_end; 559690075Sobrien if (constructor_range_stack) 559790075Sobrien constructor_range_stack->next = p; 559890075Sobrien constructor_range_stack = p; 559990075Sobrien} 560090075Sobrien 560118334Speter/* Within an array initializer, specify the next index to be initialized. 560218334Speter FIRST is that index. If LAST is nonzero, then initialize a range 560318334Speter of indices, running from FIRST through LAST. */ 560418334Speter 560518334Spetervoid 5606132718Skanset_init_index (tree first, tree last) 560718334Speter{ 560890075Sobrien if (set_designator (1)) 560990075Sobrien return; 561090075Sobrien 5611169689Skan designator_erroneous = 1; 561290075Sobrien 5613169689Skan if (!INTEGRAL_TYPE_P (TREE_TYPE (first)) 5614169689Skan || (last && !INTEGRAL_TYPE_P (TREE_TYPE (last)))) 5615169689Skan { 5616169689Skan error_init ("array index in initializer not of integer type"); 5617169689Skan return; 5618169689Skan } 561990075Sobrien 562018334Speter if (TREE_CODE (first) != INTEGER_CST) 562152284Sobrien error_init ("nonconstant array index in initializer"); 562218334Speter else if (last != 0 && TREE_CODE (last) != INTEGER_CST) 562352284Sobrien error_init ("nonconstant array index in initializer"); 562490075Sobrien else if (TREE_CODE (constructor_type) != ARRAY_TYPE) 562552284Sobrien error_init ("array index in non-array initializer"); 5626122180Skan else if (tree_int_cst_sgn (first) == -1) 5627122180Skan error_init ("array index in initializer exceeds array bounds"); 562890075Sobrien else if (constructor_max_index 562990075Sobrien && tree_int_cst_lt (constructor_max_index, first)) 563090075Sobrien error_init ("array index in initializer exceeds array bounds"); 563118334Speter else 563218334Speter { 563390075Sobrien constructor_index = convert (bitsizetype, first); 563418334Speter 563590075Sobrien if (last) 563618334Speter { 563790075Sobrien if (tree_int_cst_equal (first, last)) 563890075Sobrien last = 0; 563990075Sobrien else if (tree_int_cst_lt (last, first)) 564090075Sobrien { 564190075Sobrien error_init ("empty index range in initializer"); 564290075Sobrien last = 0; 564390075Sobrien } 564490075Sobrien else 564590075Sobrien { 564690075Sobrien last = convert (bitsizetype, last); 564790075Sobrien if (constructor_max_index != 0 564890075Sobrien && tree_int_cst_lt (constructor_max_index, last)) 564990075Sobrien { 565090075Sobrien error_init ("array index range in initializer exceeds array bounds"); 565190075Sobrien last = 0; 565290075Sobrien } 565390075Sobrien } 565418334Speter } 565590075Sobrien 565690075Sobrien designator_depth++; 5657169689Skan designator_erroneous = 0; 565890075Sobrien if (constructor_range_stack || last) 565990075Sobrien push_range_stack (last); 566018334Speter } 566118334Speter} 566218334Speter 566318334Speter/* Within a struct initializer, specify the next field to be initialized. */ 566418334Speter 566518334Spetervoid 5666132718Skanset_init_label (tree fieldname) 566718334Speter{ 566818334Speter tree tail; 566918334Speter 567090075Sobrien if (set_designator (0)) 567118334Speter return; 567218334Speter 5673169689Skan designator_erroneous = 1; 567490075Sobrien 567590075Sobrien if (TREE_CODE (constructor_type) != RECORD_TYPE 567690075Sobrien && TREE_CODE (constructor_type) != UNION_TYPE) 567790075Sobrien { 567890075Sobrien error_init ("field name not in record or union initializer"); 567990075Sobrien return; 568090075Sobrien } 5681132718Skan 568218334Speter for (tail = TYPE_FIELDS (constructor_type); tail; 568318334Speter tail = TREE_CHAIN (tail)) 568418334Speter { 568518334Speter if (DECL_NAME (tail) == fieldname) 568618334Speter break; 568718334Speter } 568818334Speter 568918334Speter if (tail == 0) 5690169689Skan error ("unknown field %qE specified in initializer", fieldname); 569118334Speter else 569218334Speter { 569318334Speter constructor_fields = tail; 569490075Sobrien designator_depth++; 5695169689Skan designator_erroneous = 0; 569690075Sobrien if (constructor_range_stack) 569790075Sobrien push_range_stack (NULL_TREE); 569818334Speter } 569918334Speter} 570018334Speter 570150397Sobrien/* Add a new initializer to the tree of pending initializers. PURPOSE 5702132718Skan identifies the initializer, either array index or field in a structure. 570350397Sobrien VALUE is the value of that index or field. */ 570450397Sobrien 570550397Sobrienstatic void 5706132718Skanadd_pending_init (tree purpose, tree value) 570750397Sobrien{ 570850397Sobrien struct init_node *p, **q, *r; 570950397Sobrien 571050397Sobrien q = &constructor_pending_elts; 571150397Sobrien p = 0; 571250397Sobrien 571350397Sobrien if (TREE_CODE (constructor_type) == ARRAY_TYPE) 571450397Sobrien { 571550397Sobrien while (*q != 0) 571650397Sobrien { 571750397Sobrien p = *q; 571850397Sobrien if (tree_int_cst_lt (purpose, p->purpose)) 571950397Sobrien q = &p->left; 572090075Sobrien else if (tree_int_cst_lt (p->purpose, purpose)) 572150397Sobrien q = &p->right; 572250397Sobrien else 572390075Sobrien { 572490075Sobrien if (TREE_SIDE_EFFECTS (p->value)) 572590075Sobrien warning_init ("initialized field with side-effects overwritten"); 5726169689Skan else if (warn_override_init) 5727169689Skan warning_init ("initialized field overwritten"); 572890075Sobrien p->value = value; 572990075Sobrien return; 573090075Sobrien } 573150397Sobrien } 573250397Sobrien } 573350397Sobrien else 573450397Sobrien { 573590075Sobrien tree bitpos; 573690075Sobrien 573790075Sobrien bitpos = bit_position (purpose); 573850397Sobrien while (*q != NULL) 573950397Sobrien { 574050397Sobrien p = *q; 574190075Sobrien if (tree_int_cst_lt (bitpos, bit_position (p->purpose))) 574250397Sobrien q = &p->left; 574360967Sobrien else if (p->purpose != purpose) 574450397Sobrien q = &p->right; 574550397Sobrien else 574690075Sobrien { 574790075Sobrien if (TREE_SIDE_EFFECTS (p->value)) 574890075Sobrien warning_init ("initialized field with side-effects overwritten"); 5749169689Skan else if (warn_override_init) 5750169689Skan warning_init ("initialized field overwritten"); 575190075Sobrien p->value = value; 575290075Sobrien return; 575390075Sobrien } 575450397Sobrien } 575550397Sobrien } 575650397Sobrien 5757169689Skan r = GGC_NEW (struct init_node); 575850397Sobrien r->purpose = purpose; 575950397Sobrien r->value = value; 576050397Sobrien 576150397Sobrien *q = r; 576250397Sobrien r->parent = p; 576350397Sobrien r->left = 0; 576450397Sobrien r->right = 0; 576550397Sobrien r->balance = 0; 576650397Sobrien 576750397Sobrien while (p) 576850397Sobrien { 576950397Sobrien struct init_node *s; 577050397Sobrien 577150397Sobrien if (r == p->left) 577250397Sobrien { 577350397Sobrien if (p->balance == 0) 577450397Sobrien p->balance = -1; 577550397Sobrien else if (p->balance < 0) 577650397Sobrien { 577750397Sobrien if (r->balance < 0) 577850397Sobrien { 577990075Sobrien /* L rotation. */ 578050397Sobrien p->left = r->right; 578150397Sobrien if (p->left) 578250397Sobrien p->left->parent = p; 578350397Sobrien r->right = p; 578450397Sobrien 578550397Sobrien p->balance = 0; 578650397Sobrien r->balance = 0; 578750397Sobrien 578850397Sobrien s = p->parent; 578950397Sobrien p->parent = r; 579050397Sobrien r->parent = s; 579150397Sobrien if (s) 579250397Sobrien { 579350397Sobrien if (s->left == p) 579450397Sobrien s->left = r; 579550397Sobrien else 579650397Sobrien s->right = r; 579750397Sobrien } 579850397Sobrien else 579950397Sobrien constructor_pending_elts = r; 580050397Sobrien } 580150397Sobrien else 580250397Sobrien { 580390075Sobrien /* LR rotation. */ 580450397Sobrien struct init_node *t = r->right; 580550397Sobrien 580650397Sobrien r->right = t->left; 580750397Sobrien if (r->right) 580850397Sobrien r->right->parent = r; 580950397Sobrien t->left = r; 581050397Sobrien 581150397Sobrien p->left = t->right; 581250397Sobrien if (p->left) 581350397Sobrien p->left->parent = p; 581450397Sobrien t->right = p; 581550397Sobrien 581650397Sobrien p->balance = t->balance < 0; 581750397Sobrien r->balance = -(t->balance > 0); 581850397Sobrien t->balance = 0; 581950397Sobrien 582050397Sobrien s = p->parent; 582150397Sobrien p->parent = t; 582250397Sobrien r->parent = t; 582350397Sobrien t->parent = s; 582450397Sobrien if (s) 582550397Sobrien { 582650397Sobrien if (s->left == p) 582750397Sobrien s->left = t; 582850397Sobrien else 582950397Sobrien s->right = t; 583050397Sobrien } 583150397Sobrien else 583250397Sobrien constructor_pending_elts = t; 583350397Sobrien } 583450397Sobrien break; 583550397Sobrien } 583650397Sobrien else 583750397Sobrien { 583850397Sobrien /* p->balance == +1; growth of left side balances the node. */ 583950397Sobrien p->balance = 0; 584050397Sobrien break; 584150397Sobrien } 584250397Sobrien } 584350397Sobrien else /* r == p->right */ 584450397Sobrien { 584550397Sobrien if (p->balance == 0) 584650397Sobrien /* Growth propagation from right side. */ 584750397Sobrien p->balance++; 584850397Sobrien else if (p->balance > 0) 584950397Sobrien { 585050397Sobrien if (r->balance > 0) 585150397Sobrien { 585290075Sobrien /* R rotation. */ 585350397Sobrien p->right = r->left; 585450397Sobrien if (p->right) 585550397Sobrien p->right->parent = p; 585650397Sobrien r->left = p; 585750397Sobrien 585850397Sobrien p->balance = 0; 585950397Sobrien r->balance = 0; 586050397Sobrien 586150397Sobrien s = p->parent; 586250397Sobrien p->parent = r; 586350397Sobrien r->parent = s; 586450397Sobrien if (s) 586550397Sobrien { 586650397Sobrien if (s->left == p) 586750397Sobrien s->left = r; 586850397Sobrien else 586950397Sobrien s->right = r; 587050397Sobrien } 587150397Sobrien else 587250397Sobrien constructor_pending_elts = r; 587350397Sobrien } 587450397Sobrien else /* r->balance == -1 */ 587550397Sobrien { 587650397Sobrien /* RL rotation */ 587750397Sobrien struct init_node *t = r->left; 587850397Sobrien 587950397Sobrien r->left = t->right; 588050397Sobrien if (r->left) 588150397Sobrien r->left->parent = r; 588250397Sobrien t->right = r; 588350397Sobrien 588450397Sobrien p->right = t->left; 588550397Sobrien if (p->right) 588650397Sobrien p->right->parent = p; 588750397Sobrien t->left = p; 588850397Sobrien 588950397Sobrien r->balance = (t->balance < 0); 589050397Sobrien p->balance = -(t->balance > 0); 589150397Sobrien t->balance = 0; 589250397Sobrien 589350397Sobrien s = p->parent; 589450397Sobrien p->parent = t; 589550397Sobrien r->parent = t; 589650397Sobrien t->parent = s; 589750397Sobrien if (s) 589850397Sobrien { 589950397Sobrien if (s->left == p) 590050397Sobrien s->left = t; 590150397Sobrien else 590250397Sobrien s->right = t; 590350397Sobrien } 590450397Sobrien else 590550397Sobrien constructor_pending_elts = t; 590650397Sobrien } 590750397Sobrien break; 590850397Sobrien } 590950397Sobrien else 591050397Sobrien { 591190075Sobrien /* p->balance == -1; growth of right side balances the node. */ 591250397Sobrien p->balance = 0; 591350397Sobrien break; 591450397Sobrien } 591550397Sobrien } 591650397Sobrien 591750397Sobrien r = p; 591850397Sobrien p = p->parent; 591950397Sobrien } 592050397Sobrien} 592150397Sobrien 592290075Sobrien/* Build AVL tree from a sorted chain. */ 592350397Sobrien 592490075Sobrienstatic void 5925132718Skanset_nonincremental_init (void) 592690075Sobrien{ 5927169689Skan unsigned HOST_WIDE_INT ix; 5928169689Skan tree index, value; 592990075Sobrien 593090075Sobrien if (TREE_CODE (constructor_type) != RECORD_TYPE 593190075Sobrien && TREE_CODE (constructor_type) != ARRAY_TYPE) 593290075Sobrien return; 593390075Sobrien 5934169689Skan FOR_EACH_CONSTRUCTOR_ELT (constructor_elements, ix, index, value) 5935169689Skan add_pending_init (index, value); 593690075Sobrien constructor_elements = 0; 593790075Sobrien if (TREE_CODE (constructor_type) == RECORD_TYPE) 593890075Sobrien { 593990075Sobrien constructor_unfilled_fields = TYPE_FIELDS (constructor_type); 594090075Sobrien /* Skip any nameless bit fields at the beginning. */ 594190075Sobrien while (constructor_unfilled_fields != 0 594290075Sobrien && DECL_C_BIT_FIELD (constructor_unfilled_fields) 594390075Sobrien && DECL_NAME (constructor_unfilled_fields) == 0) 594490075Sobrien constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields); 5945132718Skan 594690075Sobrien } 594790075Sobrien else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 594890075Sobrien { 594990075Sobrien if (TYPE_DOMAIN (constructor_type)) 595090075Sobrien constructor_unfilled_index 595190075Sobrien = convert (bitsizetype, 595290075Sobrien TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type))); 595390075Sobrien else 595490075Sobrien constructor_unfilled_index = bitsize_zero_node; 595590075Sobrien } 595690075Sobrien constructor_incremental = 0; 595790075Sobrien} 595890075Sobrien 595990075Sobrien/* Build AVL tree from a string constant. */ 596090075Sobrien 596190075Sobrienstatic void 5962132718Skanset_nonincremental_init_from_string (tree str) 596390075Sobrien{ 596490075Sobrien tree value, purpose, type; 596590075Sobrien HOST_WIDE_INT val[2]; 596690075Sobrien const char *p, *end; 596790075Sobrien int byte, wchar_bytes, charwidth, bitpos; 596890075Sobrien 5969169689Skan gcc_assert (TREE_CODE (constructor_type) == ARRAY_TYPE); 597090075Sobrien 597190075Sobrien if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str))) 597290075Sobrien == TYPE_PRECISION (char_type_node)) 597390075Sobrien wchar_bytes = 1; 597490075Sobrien else 5975169689Skan { 5976169689Skan gcc_assert (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str))) 5977169689Skan == TYPE_PRECISION (wchar_type_node)); 5978169689Skan wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT; 5979169689Skan } 598090075Sobrien charwidth = TYPE_PRECISION (char_type_node); 598190075Sobrien type = TREE_TYPE (constructor_type); 598290075Sobrien p = TREE_STRING_POINTER (str); 598390075Sobrien end = p + TREE_STRING_LENGTH (str); 598490075Sobrien 598590075Sobrien for (purpose = bitsize_zero_node; 598690075Sobrien p < end && !tree_int_cst_lt (constructor_max_index, purpose); 598790075Sobrien purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node)) 598890075Sobrien { 598990075Sobrien if (wchar_bytes == 1) 599090075Sobrien { 599190075Sobrien val[1] = (unsigned char) *p++; 599290075Sobrien val[0] = 0; 599390075Sobrien } 599490075Sobrien else 599590075Sobrien { 599690075Sobrien val[0] = 0; 599790075Sobrien val[1] = 0; 599890075Sobrien for (byte = 0; byte < wchar_bytes; byte++) 599990075Sobrien { 600090075Sobrien if (BYTES_BIG_ENDIAN) 600190075Sobrien bitpos = (wchar_bytes - byte - 1) * charwidth; 600290075Sobrien else 600390075Sobrien bitpos = byte * charwidth; 600490075Sobrien val[bitpos < HOST_BITS_PER_WIDE_INT] 600590075Sobrien |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++)) 600690075Sobrien << (bitpos % HOST_BITS_PER_WIDE_INT); 600790075Sobrien } 600890075Sobrien } 600990075Sobrien 6010169689Skan if (!TYPE_UNSIGNED (type)) 601190075Sobrien { 601290075Sobrien bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR; 601390075Sobrien if (bitpos < HOST_BITS_PER_WIDE_INT) 601490075Sobrien { 601590075Sobrien if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1))) 601690075Sobrien { 601790075Sobrien val[1] |= ((HOST_WIDE_INT) -1) << bitpos; 601890075Sobrien val[0] = -1; 601990075Sobrien } 602090075Sobrien } 602190075Sobrien else if (bitpos == HOST_BITS_PER_WIDE_INT) 602290075Sobrien { 602390075Sobrien if (val[1] < 0) 6024169689Skan val[0] = -1; 602590075Sobrien } 602690075Sobrien else if (val[0] & (((HOST_WIDE_INT) 1) 602790075Sobrien << (bitpos - 1 - HOST_BITS_PER_WIDE_INT))) 602890075Sobrien val[0] |= ((HOST_WIDE_INT) -1) 602990075Sobrien << (bitpos - HOST_BITS_PER_WIDE_INT); 603090075Sobrien } 603190075Sobrien 6032169689Skan value = build_int_cst_wide (type, val[1], val[0]); 603390075Sobrien add_pending_init (purpose, value); 603490075Sobrien } 603590075Sobrien 603690075Sobrien constructor_incremental = 0; 603790075Sobrien} 603890075Sobrien 603990075Sobrien/* Return value of FIELD in pending initializer or zero if the field was 604090075Sobrien not initialized yet. */ 604190075Sobrien 604290075Sobrienstatic tree 6043132718Skanfind_init_member (tree field) 604450397Sobrien{ 604550397Sobrien struct init_node *p; 604650397Sobrien 604750397Sobrien if (TREE_CODE (constructor_type) == ARRAY_TYPE) 604850397Sobrien { 604990075Sobrien if (constructor_incremental 605090075Sobrien && tree_int_cst_lt (field, constructor_unfilled_index)) 605190075Sobrien set_nonincremental_init (); 605290075Sobrien 605390075Sobrien p = constructor_pending_elts; 605450397Sobrien while (p) 605550397Sobrien { 605690075Sobrien if (tree_int_cst_lt (field, p->purpose)) 605750397Sobrien p = p->left; 605890075Sobrien else if (tree_int_cst_lt (p->purpose, field)) 605990075Sobrien p = p->right; 606050397Sobrien else 606190075Sobrien return p->value; 606250397Sobrien } 606350397Sobrien } 606490075Sobrien else if (TREE_CODE (constructor_type) == RECORD_TYPE) 606550397Sobrien { 606690075Sobrien tree bitpos = bit_position (field); 606790075Sobrien 606890075Sobrien if (constructor_incremental 606990075Sobrien && (!constructor_unfilled_fields 607090075Sobrien || tree_int_cst_lt (bitpos, 607190075Sobrien bit_position (constructor_unfilled_fields)))) 607290075Sobrien set_nonincremental_init (); 607390075Sobrien 607490075Sobrien p = constructor_pending_elts; 607550397Sobrien while (p) 607650397Sobrien { 607750397Sobrien if (field == p->purpose) 607890075Sobrien return p->value; 607990075Sobrien else if (tree_int_cst_lt (bitpos, bit_position (p->purpose))) 608050397Sobrien p = p->left; 608150397Sobrien else 608250397Sobrien p = p->right; 608350397Sobrien } 608450397Sobrien } 608590075Sobrien else if (TREE_CODE (constructor_type) == UNION_TYPE) 608690075Sobrien { 6087169689Skan if (!VEC_empty (constructor_elt, constructor_elements) 6088169689Skan && (VEC_last (constructor_elt, constructor_elements)->index 6089169689Skan == field)) 6090169689Skan return VEC_last (constructor_elt, constructor_elements)->value; 609190075Sobrien } 609250397Sobrien return 0; 609350397Sobrien} 609450397Sobrien 609518334Speter/* "Output" the next constructor element. 609618334Speter At top level, really output it to assembler code now. 609718334Speter Otherwise, collect it in a list from which we will make a CONSTRUCTOR. 609818334Speter TYPE is the data type that the containing data type wants here. 609918334Speter FIELD is the field (a FIELD_DECL) or the index that this element fills. 6100169689Skan If VALUE is a string constant, STRICT_STRING is true if it is 6101169689Skan unparenthesized or we should not warn here for it being parenthesized. 6102169689Skan For other types of VALUE, STRICT_STRING is not used. 610318334Speter 610418334Speter PENDING if non-nil means output pending elements that belong 610518334Speter right after this element. (PENDING is normally 1; 610618334Speter it is 0 while outputting pending elements, to avoid recursion.) */ 610718334Speter 610818334Speterstatic void 6109169689Skanoutput_init_element (tree value, bool strict_string, tree type, tree field, 6110169689Skan int pending) 611118334Speter{ 6112169689Skan constructor_elt *celt; 6113169689Skan 6114169689Skan if (type == error_mark_node || value == error_mark_node) 6115132718Skan { 6116132718Skan constructor_erroneous = 1; 6117132718Skan return; 6118132718Skan } 6119169689Skan if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE 6120169689Skan && (TREE_CODE (value) == STRING_CST 6121169689Skan || TREE_CODE (value) == COMPOUND_LITERAL_EXPR) 6122169689Skan && !(TREE_CODE (value) == STRING_CST 6123169689Skan && TREE_CODE (type) == ARRAY_TYPE 6124169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (type))) 6125169689Skan && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)), 6126169689Skan TYPE_MAIN_VARIANT (type))) 6127169689Skan value = array_to_pointer_conversion (value); 612818334Speter 612990075Sobrien if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR 613090075Sobrien && require_constant_value && !flag_isoc99 && pending) 613190075Sobrien { 613290075Sobrien /* As an extension, allow initializing objects with static storage 613390075Sobrien duration with compound literals (which are then treated just as 613490075Sobrien the brace enclosed list they contain). */ 613590075Sobrien tree decl = COMPOUND_LITERAL_EXPR_DECL (value); 613690075Sobrien value = DECL_INITIAL (decl); 613790075Sobrien } 613890075Sobrien 613918334Speter if (value == error_mark_node) 614018334Speter constructor_erroneous = 1; 614118334Speter else if (!TREE_CONSTANT (value)) 614218334Speter constructor_constant = 0; 6143169689Skan else if (!initializer_constant_valid_p (value, TREE_TYPE (value)) 614418334Speter || ((TREE_CODE (constructor_type) == RECORD_TYPE 614518334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 614650397Sobrien && DECL_C_BIT_FIELD (field) 614750397Sobrien && TREE_CODE (value) != INTEGER_CST)) 614818334Speter constructor_simple = 0; 614918334Speter 6150169689Skan if (!initializer_constant_valid_p (value, TREE_TYPE (value))) 615118334Speter { 6152169689Skan if (require_constant_value) 6153169689Skan { 6154169689Skan error_init ("initializer element is not constant"); 6155169689Skan value = error_mark_node; 6156169689Skan } 6157169689Skan else if (require_constant_elements) 6158169689Skan pedwarn ("initializer element is not computable at load time"); 615918334Speter } 616018334Speter 616190075Sobrien /* If this field is empty (and not at the end of structure), 616290075Sobrien don't do anything other than checking the initializer. */ 616390075Sobrien if (field 616490075Sobrien && (TREE_TYPE (field) == error_mark_node 616590075Sobrien || (COMPLETE_TYPE_P (TREE_TYPE (field)) 616690075Sobrien && integer_zerop (TYPE_SIZE (TREE_TYPE (field))) 616790075Sobrien && (TREE_CODE (constructor_type) == ARRAY_TYPE 616890075Sobrien || TREE_CHAIN (field))))) 616990075Sobrien return; 617090075Sobrien 6171169689Skan value = digest_init (type, value, strict_string, require_constant_value); 617290075Sobrien if (value == error_mark_node) 617318334Speter { 617490075Sobrien constructor_erroneous = 1; 617590075Sobrien return; 617618334Speter } 617718334Speter 617818334Speter /* If this element doesn't come next in sequence, 617918334Speter put it on constructor_pending_elts. */ 618018334Speter if (TREE_CODE (constructor_type) == ARRAY_TYPE 618190075Sobrien && (!constructor_incremental 618290075Sobrien || !tree_int_cst_equal (field, constructor_unfilled_index))) 618318334Speter { 618490075Sobrien if (constructor_incremental 618590075Sobrien && tree_int_cst_lt (field, constructor_unfilled_index)) 618690075Sobrien set_nonincremental_init (); 618790075Sobrien 618890075Sobrien add_pending_init (field, value); 618990075Sobrien return; 619018334Speter } 619118334Speter else if (TREE_CODE (constructor_type) == RECORD_TYPE 619290075Sobrien && (!constructor_incremental 619390075Sobrien || field != constructor_unfilled_fields)) 619418334Speter { 619518334Speter /* We do this for records but not for unions. In a union, 619618334Speter no matter which field is specified, it can be initialized 619718334Speter right away since it starts at the beginning of the union. */ 619890075Sobrien if (constructor_incremental) 619918334Speter { 620090075Sobrien if (!constructor_unfilled_fields) 620190075Sobrien set_nonincremental_init (); 620218334Speter else 620318334Speter { 620490075Sobrien tree bitpos, unfillpos; 620518334Speter 620690075Sobrien bitpos = bit_position (field); 620790075Sobrien unfillpos = bit_position (constructor_unfilled_fields); 620818334Speter 620990075Sobrien if (tree_int_cst_lt (bitpos, unfillpos)) 621090075Sobrien set_nonincremental_init (); 621118334Speter } 621218334Speter } 621318334Speter 621490075Sobrien add_pending_init (field, value); 621590075Sobrien return; 621690075Sobrien } 621790075Sobrien else if (TREE_CODE (constructor_type) == UNION_TYPE 6218169689Skan && !VEC_empty (constructor_elt, constructor_elements)) 621990075Sobrien { 6220169689Skan if (TREE_SIDE_EFFECTS (VEC_last (constructor_elt, 6221169689Skan constructor_elements)->value)) 622290075Sobrien warning_init ("initialized field with side-effects overwritten"); 6223169689Skan else if (warn_override_init) 6224169689Skan warning_init ("initialized field overwritten"); 622518334Speter 622690075Sobrien /* We can have just one union field set. */ 622790075Sobrien constructor_elements = 0; 622818334Speter } 622990075Sobrien 623090075Sobrien /* Otherwise, output this element either to 623190075Sobrien constructor_elements or to the assembler file. */ 623290075Sobrien 6233169689Skan celt = VEC_safe_push (constructor_elt, gc, constructor_elements, NULL); 6234169689Skan celt->index = field; 6235169689Skan celt->value = value; 623690075Sobrien 623790075Sobrien /* Advance the variable that indicates sequential elements output. */ 623890075Sobrien if (TREE_CODE (constructor_type) == ARRAY_TYPE) 623990075Sobrien constructor_unfilled_index 624090075Sobrien = size_binop (PLUS_EXPR, constructor_unfilled_index, 624190075Sobrien bitsize_one_node); 624290075Sobrien else if (TREE_CODE (constructor_type) == RECORD_TYPE) 624390075Sobrien { 624490075Sobrien constructor_unfilled_fields 624590075Sobrien = TREE_CHAIN (constructor_unfilled_fields); 624690075Sobrien 624790075Sobrien /* Skip any nameless bit fields. */ 624890075Sobrien while (constructor_unfilled_fields != 0 624990075Sobrien && DECL_C_BIT_FIELD (constructor_unfilled_fields) 625090075Sobrien && DECL_NAME (constructor_unfilled_fields) == 0) 625190075Sobrien constructor_unfilled_fields = 625290075Sobrien TREE_CHAIN (constructor_unfilled_fields); 625390075Sobrien } 625490075Sobrien else if (TREE_CODE (constructor_type) == UNION_TYPE) 625590075Sobrien constructor_unfilled_fields = 0; 625690075Sobrien 625790075Sobrien /* Now output any pending elements which have become next. */ 625890075Sobrien if (pending) 625990075Sobrien output_pending_init_elements (0); 626018334Speter} 626118334Speter 626218334Speter/* Output any pending elements which have become next. 626318334Speter As we output elements, constructor_unfilled_{fields,index} 626418334Speter advances, which may cause other elements to become next; 626518334Speter if so, they too are output. 626618334Speter 626718334Speter If ALL is 0, we return when there are 626818334Speter no more pending elements to output now. 626918334Speter 627018334Speter If ALL is 1, we output space as necessary so that 627118334Speter we can output all the pending elements. */ 627218334Speter 627318334Speterstatic void 6274132718Skanoutput_pending_init_elements (int all) 627518334Speter{ 627650397Sobrien struct init_node *elt = constructor_pending_elts; 627718334Speter tree next; 627818334Speter 627918334Speter retry: 628018334Speter 6281132718Skan /* Look through the whole pending tree. 628218334Speter If we find an element that should be output now, 628318334Speter output it. Otherwise, set NEXT to the element 628418334Speter that comes first among those still pending. */ 6285132718Skan 628618334Speter next = 0; 628750397Sobrien while (elt) 628818334Speter { 628918334Speter if (TREE_CODE (constructor_type) == ARRAY_TYPE) 629018334Speter { 629150397Sobrien if (tree_int_cst_equal (elt->purpose, 629218334Speter constructor_unfilled_index)) 6293169689Skan output_init_element (elt->value, true, 629450397Sobrien TREE_TYPE (constructor_type), 629550397Sobrien constructor_unfilled_index, 0); 629650397Sobrien else if (tree_int_cst_lt (constructor_unfilled_index, 629750397Sobrien elt->purpose)) 629818334Speter { 629950397Sobrien /* Advance to the next smaller node. */ 630050397Sobrien if (elt->left) 630150397Sobrien elt = elt->left; 630250397Sobrien else 630350397Sobrien { 630450397Sobrien /* We have reached the smallest node bigger than the 630550397Sobrien current unfilled index. Fill the space first. */ 630650397Sobrien next = elt->purpose; 630750397Sobrien break; 630850397Sobrien } 630918334Speter } 631050397Sobrien else 631150397Sobrien { 631250397Sobrien /* Advance to the next bigger node. */ 631350397Sobrien if (elt->right) 631450397Sobrien elt = elt->right; 631550397Sobrien else 631650397Sobrien { 631750397Sobrien /* We have reached the biggest node in a subtree. Find 631850397Sobrien the parent of it, which is the next bigger node. */ 631950397Sobrien while (elt->parent && elt->parent->right == elt) 632050397Sobrien elt = elt->parent; 632150397Sobrien elt = elt->parent; 632250397Sobrien if (elt && tree_int_cst_lt (constructor_unfilled_index, 632350397Sobrien elt->purpose)) 632450397Sobrien { 632550397Sobrien next = elt->purpose; 632650397Sobrien break; 632750397Sobrien } 632850397Sobrien } 632950397Sobrien } 633018334Speter } 633118334Speter else if (TREE_CODE (constructor_type) == RECORD_TYPE 633218334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 633318334Speter { 633490075Sobrien tree ctor_unfilled_bitpos, elt_bitpos; 633590075Sobrien 633650397Sobrien /* If the current record is complete we are done. */ 633750397Sobrien if (constructor_unfilled_fields == 0) 633850397Sobrien break; 633990075Sobrien 634090075Sobrien ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields); 634190075Sobrien elt_bitpos = bit_position (elt->purpose); 634290075Sobrien /* We can't compare fields here because there might be empty 634390075Sobrien fields in between. */ 634490075Sobrien if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos)) 634518334Speter { 634690075Sobrien constructor_unfilled_fields = elt->purpose; 6347169689Skan output_init_element (elt->value, true, TREE_TYPE (elt->purpose), 634890075Sobrien elt->purpose, 0); 634918334Speter } 635090075Sobrien else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos)) 635150397Sobrien { 635250397Sobrien /* Advance to the next smaller node. */ 635350397Sobrien if (elt->left) 635450397Sobrien elt = elt->left; 635550397Sobrien else 635650397Sobrien { 635750397Sobrien /* We have reached the smallest node bigger than the 635850397Sobrien current unfilled field. Fill the space first. */ 635950397Sobrien next = elt->purpose; 636050397Sobrien break; 636150397Sobrien } 636250397Sobrien } 636350397Sobrien else 636450397Sobrien { 636550397Sobrien /* Advance to the next bigger node. */ 636650397Sobrien if (elt->right) 636750397Sobrien elt = elt->right; 636850397Sobrien else 636950397Sobrien { 637050397Sobrien /* We have reached the biggest node in a subtree. Find 637150397Sobrien the parent of it, which is the next bigger node. */ 637250397Sobrien while (elt->parent && elt->parent->right == elt) 637350397Sobrien elt = elt->parent; 637450397Sobrien elt = elt->parent; 637550397Sobrien if (elt 637690075Sobrien && (tree_int_cst_lt (ctor_unfilled_bitpos, 637790075Sobrien bit_position (elt->purpose)))) 637850397Sobrien { 637950397Sobrien next = elt->purpose; 638050397Sobrien break; 638150397Sobrien } 638250397Sobrien } 638350397Sobrien } 638418334Speter } 638518334Speter } 638618334Speter 638718334Speter /* Ordinarily return, but not if we want to output all 638818334Speter and there are elements left. */ 6389169689Skan if (!(all && next != 0)) 639018334Speter return; 639118334Speter 639290075Sobrien /* If it's not incremental, just skip over the gap, so that after 639390075Sobrien jumping to retry we will output the next successive element. */ 639490075Sobrien if (TREE_CODE (constructor_type) == RECORD_TYPE 639590075Sobrien || TREE_CODE (constructor_type) == UNION_TYPE) 639690075Sobrien constructor_unfilled_fields = next; 639790075Sobrien else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 639890075Sobrien constructor_unfilled_index = next; 639918334Speter 640050397Sobrien /* ELT now points to the node in the pending tree with the next 640150397Sobrien initializer to output. */ 640218334Speter goto retry; 640318334Speter} 640418334Speter 640518334Speter/* Add one non-braced element to the current constructor level. 640618334Speter This adjusts the current position within the constructor's type. 640718334Speter This may also start or terminate implicit levels 640818334Speter to handle a partly-braced initializer. 640918334Speter 641018334Speter Once this has found the correct level for the new element, 641190075Sobrien it calls output_init_element. */ 641218334Speter 641318334Spetervoid 6414169689Skanprocess_init_element (struct c_expr value) 641518334Speter{ 6416169689Skan tree orig_value = value.value; 6417169689Skan int string_flag = orig_value != 0 && TREE_CODE (orig_value) == STRING_CST; 6418169689Skan bool strict_string = value.original_code == STRING_CST; 641918334Speter 642090075Sobrien designator_depth = 0; 6421169689Skan designator_erroneous = 0; 642290075Sobrien 642318334Speter /* Handle superfluous braces around string cst as in 642418334Speter char x[] = {"foo"}; */ 642518334Speter if (string_flag 642618334Speter && constructor_type 642718334Speter && TREE_CODE (constructor_type) == ARRAY_TYPE 6428169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type)) 642918334Speter && integer_zerop (constructor_unfilled_index)) 643018334Speter { 6431169689Skan if (constructor_stack->replacement_value.value) 6432169689Skan error_init ("excess elements in char array initializer"); 643318334Speter constructor_stack->replacement_value = value; 643418334Speter return; 643518334Speter } 643618334Speter 6437169689Skan if (constructor_stack->replacement_value.value != 0) 643818334Speter { 643952284Sobrien error_init ("excess elements in struct initializer"); 644018334Speter return; 644118334Speter } 644218334Speter 644318334Speter /* Ignore elements of a brace group if it is entirely superfluous 644418334Speter and has already been diagnosed. */ 644518334Speter if (constructor_type == 0) 644618334Speter return; 644718334Speter 644818334Speter /* If we've exhausted any levels that didn't have braces, 644918334Speter pop them now. */ 645018334Speter while (constructor_stack->implicit) 645118334Speter { 645218334Speter if ((TREE_CODE (constructor_type) == RECORD_TYPE 645318334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 645418334Speter && constructor_fields == 0) 645518334Speter process_init_element (pop_init_level (1)); 645618334Speter else if (TREE_CODE (constructor_type) == ARRAY_TYPE 645750397Sobrien && (constructor_max_index == 0 645850397Sobrien || tree_int_cst_lt (constructor_max_index, 645950397Sobrien constructor_index))) 646018334Speter process_init_element (pop_init_level (1)); 646118334Speter else 646218334Speter break; 646318334Speter } 646418334Speter 646590075Sobrien /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */ 646690075Sobrien if (constructor_range_stack) 646790075Sobrien { 646890075Sobrien /* If value is a compound literal and we'll be just using its 646990075Sobrien content, don't put it into a SAVE_EXPR. */ 6470169689Skan if (TREE_CODE (value.value) != COMPOUND_LITERAL_EXPR 647190075Sobrien || !require_constant_value 647290075Sobrien || flag_isoc99) 6473169689Skan value.value = save_expr (value.value); 647490075Sobrien } 647590075Sobrien 647618334Speter while (1) 647718334Speter { 647818334Speter if (TREE_CODE (constructor_type) == RECORD_TYPE) 647918334Speter { 648018334Speter tree fieldtype; 648118334Speter enum tree_code fieldcode; 648218334Speter 648318334Speter if (constructor_fields == 0) 648418334Speter { 648552284Sobrien pedwarn_init ("excess elements in struct initializer"); 648618334Speter break; 648718334Speter } 648818334Speter 648918334Speter fieldtype = TREE_TYPE (constructor_fields); 649018334Speter if (fieldtype != error_mark_node) 649118334Speter fieldtype = TYPE_MAIN_VARIANT (fieldtype); 649218334Speter fieldcode = TREE_CODE (fieldtype); 649318334Speter 649496263Sobrien /* Error for non-static initialization of a flexible array member. */ 649596263Sobrien if (fieldcode == ARRAY_TYPE 649696263Sobrien && !require_constant_value 649796263Sobrien && TYPE_SIZE (fieldtype) == NULL_TREE 649896263Sobrien && TREE_CHAIN (constructor_fields) == NULL_TREE) 649996263Sobrien { 650096263Sobrien error_init ("non-static initialization of a flexible array member"); 650196263Sobrien break; 650296263Sobrien } 650396263Sobrien 650418334Speter /* Accept a string constant to initialize a subarray. */ 6505169689Skan if (value.value != 0 650618334Speter && fieldcode == ARRAY_TYPE 6507169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype)) 650818334Speter && string_flag) 6509169689Skan value.value = orig_value; 651018334Speter /* Otherwise, if we have come to a subaggregate, 651118334Speter and we don't have an element of its type, push into it. */ 6512169689Skan else if (value.value != 0 6513169689Skan && value.value != error_mark_node 6514169689Skan && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype 651518334Speter && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE 651618334Speter || fieldcode == UNION_TYPE)) 651718334Speter { 651818334Speter push_init_level (1); 651918334Speter continue; 652018334Speter } 652118334Speter 6522169689Skan if (value.value) 652318334Speter { 652418334Speter push_member_name (constructor_fields); 6525169689Skan output_init_element (value.value, strict_string, 6526169689Skan fieldtype, constructor_fields, 1); 652718334Speter RESTORE_SPELLING_DEPTH (constructor_depth); 652818334Speter } 652918334Speter else 653018334Speter /* Do the bookkeeping for an element that was 653118334Speter directly output as a constructor. */ 653218334Speter { 653318334Speter /* For a record, keep track of end position of last field. */ 653490075Sobrien if (DECL_SIZE (constructor_fields)) 6535169689Skan constructor_bit_index 653690075Sobrien = size_binop (PLUS_EXPR, 6537169689Skan bit_position (constructor_fields), 6538169689Skan DECL_SIZE (constructor_fields)); 653918334Speter 6540110611Skan /* If the current field was the first one not yet written out, 6541110611Skan it isn't now, so update. */ 6542110611Skan if (constructor_unfilled_fields == constructor_fields) 6543110611Skan { 6544110611Skan constructor_unfilled_fields = TREE_CHAIN (constructor_fields); 6545110611Skan /* Skip any nameless bit fields. */ 6546110611Skan while (constructor_unfilled_fields != 0 6547110611Skan && DECL_C_BIT_FIELD (constructor_unfilled_fields) 6548110611Skan && DECL_NAME (constructor_unfilled_fields) == 0) 6549110611Skan constructor_unfilled_fields = 6550110611Skan TREE_CHAIN (constructor_unfilled_fields); 6551110611Skan } 655218334Speter } 655318334Speter 655418334Speter constructor_fields = TREE_CHAIN (constructor_fields); 655518334Speter /* Skip any nameless bit fields at the beginning. */ 655650397Sobrien while (constructor_fields != 0 655750397Sobrien && DECL_C_BIT_FIELD (constructor_fields) 655818334Speter && DECL_NAME (constructor_fields) == 0) 655918334Speter constructor_fields = TREE_CHAIN (constructor_fields); 656018334Speter } 656190075Sobrien else if (TREE_CODE (constructor_type) == UNION_TYPE) 656218334Speter { 656318334Speter tree fieldtype; 656418334Speter enum tree_code fieldcode; 656518334Speter 656618334Speter if (constructor_fields == 0) 656718334Speter { 656852284Sobrien pedwarn_init ("excess elements in union initializer"); 656918334Speter break; 657018334Speter } 657118334Speter 657218334Speter fieldtype = TREE_TYPE (constructor_fields); 657318334Speter if (fieldtype != error_mark_node) 657418334Speter fieldtype = TYPE_MAIN_VARIANT (fieldtype); 657518334Speter fieldcode = TREE_CODE (fieldtype); 657618334Speter 657790075Sobrien /* Warn that traditional C rejects initialization of unions. 657890075Sobrien We skip the warning if the value is zero. This is done 657990075Sobrien under the assumption that the zero initializer in user 658090075Sobrien code appears conditioned on e.g. __STDC__ to avoid 658190075Sobrien "missing initializer" warnings and relies on default 658290075Sobrien initialization to zero in the traditional C case. 658390075Sobrien We also skip the warning if the initializer is designated, 658490075Sobrien again on the assumption that this must be conditional on 658590075Sobrien __STDC__ anyway (and we've already complained about the 658690075Sobrien member-designator already). */ 6587169689Skan if (!in_system_header && !constructor_designated 6588169689Skan && !(value.value && (integer_zerop (value.value) 6589169689Skan || real_zerop (value.value)))) 6590169689Skan warning (OPT_Wtraditional, "traditional C rejects initialization " 6591169689Skan "of unions"); 659290075Sobrien 659318334Speter /* Accept a string constant to initialize a subarray. */ 6594169689Skan if (value.value != 0 659518334Speter && fieldcode == ARRAY_TYPE 6596169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype)) 659718334Speter && string_flag) 6598169689Skan value.value = orig_value; 659918334Speter /* Otherwise, if we have come to a subaggregate, 660018334Speter and we don't have an element of its type, push into it. */ 6601169689Skan else if (value.value != 0 6602169689Skan && value.value != error_mark_node 6603169689Skan && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype 660418334Speter && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE 660518334Speter || fieldcode == UNION_TYPE)) 660618334Speter { 660718334Speter push_init_level (1); 660818334Speter continue; 660918334Speter } 661018334Speter 6611169689Skan if (value.value) 661218334Speter { 661318334Speter push_member_name (constructor_fields); 6614169689Skan output_init_element (value.value, strict_string, 6615169689Skan fieldtype, constructor_fields, 1); 661618334Speter RESTORE_SPELLING_DEPTH (constructor_depth); 661718334Speter } 661818334Speter else 661918334Speter /* Do the bookkeeping for an element that was 662018334Speter directly output as a constructor. */ 662118334Speter { 662290075Sobrien constructor_bit_index = DECL_SIZE (constructor_fields); 662318334Speter constructor_unfilled_fields = TREE_CHAIN (constructor_fields); 662418334Speter } 662518334Speter 662618334Speter constructor_fields = 0; 662718334Speter } 662890075Sobrien else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 662918334Speter { 663018334Speter tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type)); 663118334Speter enum tree_code eltcode = TREE_CODE (elttype); 663218334Speter 663318334Speter /* Accept a string constant to initialize a subarray. */ 6634169689Skan if (value.value != 0 663518334Speter && eltcode == ARRAY_TYPE 6636169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (elttype)) 663718334Speter && string_flag) 6638169689Skan value.value = orig_value; 663918334Speter /* Otherwise, if we have come to a subaggregate, 664018334Speter and we don't have an element of its type, push into it. */ 6641169689Skan else if (value.value != 0 6642169689Skan && value.value != error_mark_node 6643169689Skan && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != elttype 664418334Speter && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE 664518334Speter || eltcode == UNION_TYPE)) 664618334Speter { 664718334Speter push_init_level (1); 664818334Speter continue; 664918334Speter } 665018334Speter 665118334Speter if (constructor_max_index != 0 665290075Sobrien && (tree_int_cst_lt (constructor_max_index, constructor_index) 665390075Sobrien || integer_all_onesp (constructor_max_index))) 665418334Speter { 665552284Sobrien pedwarn_init ("excess elements in array initializer"); 665618334Speter break; 665718334Speter } 665818334Speter 665990075Sobrien /* Now output the actual element. */ 6660169689Skan if (value.value) 666150397Sobrien { 6662169689Skan push_array_bounds (tree_low_cst (constructor_index, 1)); 6663169689Skan output_init_element (value.value, strict_string, 6664169689Skan elttype, constructor_index, 1); 666590075Sobrien RESTORE_SPELLING_DEPTH (constructor_depth); 666650397Sobrien } 666750397Sobrien 666890075Sobrien constructor_index 666990075Sobrien = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node); 667018334Speter 6671169689Skan if (!value.value) 667290075Sobrien /* If we are doing the bookkeeping for an element that was 667390075Sobrien directly output as a constructor, we must update 667490075Sobrien constructor_unfilled_index. */ 667590075Sobrien constructor_unfilled_index = constructor_index; 667618334Speter } 667796263Sobrien else if (TREE_CODE (constructor_type) == VECTOR_TYPE) 667896263Sobrien { 667996263Sobrien tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type)); 668018334Speter 6681169689Skan /* Do a basic check of initializer size. Note that vectors 6682169689Skan always have a fixed size derived from their type. */ 668396263Sobrien if (tree_int_cst_lt (constructor_max_index, constructor_index)) 668496263Sobrien { 668596263Sobrien pedwarn_init ("excess elements in vector initializer"); 668696263Sobrien break; 668796263Sobrien } 668896263Sobrien 668996263Sobrien /* Now output the actual element. */ 6690169689Skan if (value.value) 6691169689Skan output_init_element (value.value, strict_string, 6692169689Skan elttype, constructor_index, 1); 669396263Sobrien 669496263Sobrien constructor_index 669596263Sobrien = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node); 669696263Sobrien 6697169689Skan if (!value.value) 669896263Sobrien /* If we are doing the bookkeeping for an element that was 669996263Sobrien directly output as a constructor, we must update 670096263Sobrien constructor_unfilled_index. */ 670196263Sobrien constructor_unfilled_index = constructor_index; 670296263Sobrien } 670396263Sobrien 670418334Speter /* Handle the sole element allowed in a braced initializer 670518334Speter for a scalar variable. */ 6706169689Skan else if (constructor_type != error_mark_node 6707169689Skan && constructor_fields == 0) 670818334Speter { 670952284Sobrien pedwarn_init ("excess elements in scalar initializer"); 671018334Speter break; 671118334Speter } 671290075Sobrien else 671390075Sobrien { 6714169689Skan if (value.value) 6715169689Skan output_init_element (value.value, strict_string, 6716169689Skan constructor_type, NULL_TREE, 1); 671790075Sobrien constructor_fields = 0; 671890075Sobrien } 671918334Speter 672090075Sobrien /* Handle range initializers either at this level or anywhere higher 672190075Sobrien in the designator stack. */ 672290075Sobrien if (constructor_range_stack) 672390075Sobrien { 672490075Sobrien struct constructor_range_stack *p, *range_stack; 672590075Sobrien int finish = 0; 672690075Sobrien 672790075Sobrien range_stack = constructor_range_stack; 672890075Sobrien constructor_range_stack = 0; 672990075Sobrien while (constructor_stack != range_stack->stack) 673090075Sobrien { 6731169689Skan gcc_assert (constructor_stack->implicit); 673290075Sobrien process_init_element (pop_init_level (1)); 673390075Sobrien } 673490075Sobrien for (p = range_stack; 673590075Sobrien !p->range_end || tree_int_cst_equal (p->index, p->range_end); 673690075Sobrien p = p->prev) 673790075Sobrien { 6738169689Skan gcc_assert (constructor_stack->implicit); 673990075Sobrien process_init_element (pop_init_level (1)); 674090075Sobrien } 674190075Sobrien 674290075Sobrien p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node); 674390075Sobrien if (tree_int_cst_equal (p->index, p->range_end) && !p->prev) 674490075Sobrien finish = 1; 674590075Sobrien 674690075Sobrien while (1) 674790075Sobrien { 674890075Sobrien constructor_index = p->index; 674990075Sobrien constructor_fields = p->fields; 675090075Sobrien if (finish && p->range_end && p->index == p->range_start) 675190075Sobrien { 675290075Sobrien finish = 0; 675390075Sobrien p->prev = 0; 675490075Sobrien } 675590075Sobrien p = p->next; 675690075Sobrien if (!p) 675790075Sobrien break; 675890075Sobrien push_init_level (2); 675990075Sobrien p->stack = constructor_stack; 676090075Sobrien if (p->range_end && tree_int_cst_equal (p->index, p->range_end)) 676190075Sobrien p->index = p->range_start; 676290075Sobrien } 676390075Sobrien 676490075Sobrien if (!finish) 676590075Sobrien constructor_range_stack = range_stack; 676690075Sobrien continue; 676790075Sobrien } 676890075Sobrien 676918334Speter break; 677018334Speter } 677118334Speter 677290075Sobrien constructor_range_stack = 0; 677318334Speter} 677418334Speter 6775169689Skan/* Build a complete asm-statement, whose components are a CV_QUALIFIER 6776169689Skan (guaranteed to be 'volatile' or null) and ARGS (represented using 6777169689Skan an ASM_EXPR node). */ 677890075Sobrientree 6779169689Skanbuild_asm_stmt (tree cv_qualifier, tree args) 678090075Sobrien{ 6781169689Skan if (!ASM_VOLATILE_P (args) && cv_qualifier) 6782169689Skan ASM_VOLATILE_P (args) = 1; 6783169689Skan return add_stmt (args); 678490075Sobrien} 678590075Sobrien 6786169689Skan/* Build an asm-expr, whose components are a STRING, some OUTPUTS, 6787169689Skan some INPUTS, and some CLOBBERS. The latter three may be NULL. 6788169689Skan SIMPLE indicates whether there was anything at all after the 6789169689Skan string in the asm expression -- asm("blah") and asm("blah" : ) 6790169689Skan are subtly different. We use a ASM_EXPR node to represent this. */ 679190075Sobrientree 6792169689Skanbuild_asm_expr (tree string, tree outputs, tree inputs, tree clobbers, 6793169689Skan bool simple) 679490075Sobrien{ 679590075Sobrien tree tail; 6796169689Skan tree args; 6797169689Skan int i; 6798169689Skan const char *constraint; 6799169689Skan const char **oconstraints; 6800169689Skan bool allows_mem, allows_reg, is_inout; 6801169689Skan int ninputs, noutputs; 680290075Sobrien 6803169689Skan ninputs = list_length (inputs); 6804169689Skan noutputs = list_length (outputs); 6805169689Skan oconstraints = (const char **) alloca (noutputs * sizeof (const char *)); 680690075Sobrien 6807169689Skan string = resolve_asm_operand_names (string, outputs, inputs); 680890075Sobrien 6809169689Skan /* Remove output conversions that change the type but not the mode. */ 6810169689Skan for (i = 0, tail = outputs; tail; ++i, tail = TREE_CHAIN (tail)) 681190075Sobrien { 681290075Sobrien tree output = TREE_VALUE (tail); 681390075Sobrien 6814169689Skan /* ??? Really, this should not be here. Users should be using a 6815169689Skan proper lvalue, dammit. But there's a long history of using casts 6816169689Skan in the output operands. In cases like longlong.h, this becomes a 6817169689Skan primitive form of typechecking -- if the cast can be removed, then 6818169689Skan the output operand had a type of the proper width; otherwise we'll 6819169689Skan get an error. Gross, but ... */ 682090075Sobrien STRIP_NOPS (output); 682190075Sobrien 6822169689Skan if (!lvalue_or_else (output, lv_asm)) 6823169689Skan output = error_mark_node; 682490075Sobrien 6825169689Skan if (output != error_mark_node 6826169689Skan && (TREE_READONLY (output) 6827169689Skan || TYPE_READONLY (TREE_TYPE (output)) 6828169689Skan || ((TREE_CODE (TREE_TYPE (output)) == RECORD_TYPE 6829169689Skan || TREE_CODE (TREE_TYPE (output)) == UNION_TYPE) 6830169689Skan && C_TYPE_FIELDS_READONLY (TREE_TYPE (output))))) 6831169689Skan readonly_error (output, lv_asm); 6832169689Skan 6833169689Skan constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail))); 6834169689Skan oconstraints[i] = constraint; 6835169689Skan 6836169689Skan if (parse_output_constraint (&constraint, i, ninputs, noutputs, 6837169689Skan &allows_mem, &allows_reg, &is_inout)) 6838169689Skan { 6839169689Skan /* If the operand is going to end up in memory, 6840169689Skan mark it addressable. */ 6841169689Skan if (!allows_reg && !c_mark_addressable (output)) 6842169689Skan output = error_mark_node; 6843169689Skan } 6844169689Skan else 6845169689Skan output = error_mark_node; 6846169689Skan 6847169689Skan TREE_VALUE (tail) = output; 684890075Sobrien } 684990075Sobrien 6850169689Skan for (i = 0, tail = inputs; tail; ++i, tail = TREE_CHAIN (tail)) 685190075Sobrien { 6852169689Skan tree input; 6853169689Skan 6854169689Skan constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail))); 6855169689Skan input = TREE_VALUE (tail); 6856169689Skan 6857169689Skan if (parse_input_constraint (&constraint, i, ninputs, noutputs, 0, 6858169689Skan oconstraints, &allows_mem, &allows_reg)) 6859169689Skan { 6860169689Skan /* If the operand is going to end up in memory, 6861169689Skan mark it addressable. */ 6862169689Skan if (!allows_reg && allows_mem) 6863169689Skan { 6864169689Skan /* Strip the nops as we allow this case. FIXME, this really 6865169689Skan should be rejected or made deprecated. */ 6866169689Skan STRIP_NOPS (input); 6867169689Skan if (!c_mark_addressable (input)) 6868169689Skan input = error_mark_node; 6869169689Skan } 6870169689Skan } 6871169689Skan else 6872169689Skan input = error_mark_node; 6873169689Skan 6874169689Skan TREE_VALUE (tail) = input; 687590075Sobrien } 687690075Sobrien 6877169689Skan args = build_stmt (ASM_EXPR, string, outputs, inputs, clobbers); 687890075Sobrien 6879169689Skan /* asm statements without outputs, including simple ones, are treated 6880169689Skan as volatile. */ 6881169689Skan ASM_INPUT_P (args) = simple; 6882169689Skan ASM_VOLATILE_P (args) = (noutputs == 0); 6883169689Skan 6884169689Skan return args; 688590075Sobrien} 6886169689Skan 6887169689Skan/* Generate a goto statement to LABEL. */ 688890075Sobrien 6889169689Skantree 6890169689Skanc_finish_goto_label (tree label) 689118334Speter{ 6892169689Skan tree decl = lookup_label (label); 6893169689Skan if (!decl) 6894169689Skan return NULL_TREE; 689518334Speter 6896169689Skan if (C_DECL_UNJUMPABLE_STMT_EXPR (decl)) 6897117395Skan { 6898169689Skan error ("jump into statement expression"); 6899169689Skan return NULL_TREE; 6900117395Skan } 690118334Speter 6902169689Skan if (C_DECL_UNJUMPABLE_VM (decl)) 6903169689Skan { 6904169689Skan error ("jump into scope of identifier with variably modified type"); 6905169689Skan return NULL_TREE; 6906169689Skan } 690718334Speter 6908169689Skan if (!C_DECL_UNDEFINABLE_STMT_EXPR (decl)) 690918334Speter { 6910169689Skan /* No jump from outside this statement expression context, so 6911169689Skan record that there is a jump from within this context. */ 6912169689Skan struct c_label_list *nlist; 6913169689Skan nlist = XOBNEW (&parser_obstack, struct c_label_list); 6914169689Skan nlist->next = label_context_stack_se->labels_used; 6915169689Skan nlist->label = decl; 6916169689Skan label_context_stack_se->labels_used = nlist; 6917169689Skan } 691890075Sobrien 6919169689Skan if (!C_DECL_UNDEFINABLE_VM (decl)) 6920169689Skan { 6921169689Skan /* No jump from outside this context context of identifiers with 6922169689Skan variably modified type, so record that there is a jump from 6923169689Skan within this context. */ 6924169689Skan struct c_label_list *nlist; 6925169689Skan nlist = XOBNEW (&parser_obstack, struct c_label_list); 6926169689Skan nlist->next = label_context_stack_vm->labels_used; 6927169689Skan nlist->label = decl; 6928169689Skan label_context_stack_vm->labels_used = nlist; 692918334Speter } 693018334Speter 6931169689Skan TREE_USED (decl) = 1; 6932169689Skan return add_stmt (build1 (GOTO_EXPR, void_type_node, decl)); 693318334Speter} 693418334Speter 6935169689Skan/* Generate a computed goto statement to EXPR. */ 6936169689Skan 693790075Sobrientree 6938169689Skanc_finish_goto_ptr (tree expr) 693918334Speter{ 6940169689Skan if (pedantic) 6941169689Skan pedwarn ("ISO C forbids %<goto *expr;%>"); 6942169689Skan expr = convert (ptr_type_node, expr); 6943169689Skan return add_stmt (build1 (GOTO_EXPR, void_type_node, expr)); 6944169689Skan} 694518334Speter 6946169689Skan/* Generate a C `return' statement. RETVAL is the expression for what 6947169689Skan to return, or a null pointer for `return;' with no value. */ 6948169689Skan 6949169689Skantree 6950169689Skanc_finish_return (tree retval) 6951169689Skan{ 6952169689Skan tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl)), ret_stmt; 6953169689Skan bool no_warning = false; 6954169689Skan 695518334Speter if (TREE_THIS_VOLATILE (current_function_decl)) 6956169689Skan warning (0, "function declared %<noreturn%> has a %<return%> statement"); 695718334Speter 695818334Speter if (!retval) 695918334Speter { 696018334Speter current_function_returns_null = 1; 696190075Sobrien if ((warn_return_type || flag_isoc99) 696290075Sobrien && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE) 6963169689Skan { 6964169689Skan pedwarn_c99 ("%<return%> with no value, in " 6965169689Skan "function returning non-void"); 6966169689Skan no_warning = true; 6967169689Skan } 696818334Speter } 696918334Speter else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE) 697018334Speter { 697118334Speter current_function_returns_null = 1; 697218334Speter if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE) 6973169689Skan pedwarn ("%<return%> with a value, in function returning void"); 697418334Speter } 697518334Speter else 697618334Speter { 6977169689Skan tree t = convert_for_assignment (valtype, retval, ic_return, 697818334Speter NULL_TREE, NULL_TREE, 0); 697918334Speter tree res = DECL_RESULT (current_function_decl); 698018334Speter tree inner; 698118334Speter 698296263Sobrien current_function_returns_value = 1; 698318334Speter if (t == error_mark_node) 698490075Sobrien return NULL_TREE; 698518334Speter 698618334Speter inner = t = convert (TREE_TYPE (res), t); 698718334Speter 698818334Speter /* Strip any conversions, additions, and subtractions, and see if 698918334Speter we are returning the address of a local variable. Warn if so. */ 699018334Speter while (1) 699118334Speter { 699218334Speter switch (TREE_CODE (inner)) 699318334Speter { 699418334Speter case NOP_EXPR: case NON_LVALUE_EXPR: case CONVERT_EXPR: 699518334Speter case PLUS_EXPR: 699618334Speter inner = TREE_OPERAND (inner, 0); 699718334Speter continue; 699818334Speter 699918334Speter case MINUS_EXPR: 700018334Speter /* If the second operand of the MINUS_EXPR has a pointer 700118334Speter type (or is converted from it), this may be valid, so 700218334Speter don't give a warning. */ 700318334Speter { 700418334Speter tree op1 = TREE_OPERAND (inner, 1); 700518334Speter 7006169689Skan while (!POINTER_TYPE_P (TREE_TYPE (op1)) 700718334Speter && (TREE_CODE (op1) == NOP_EXPR 700818334Speter || TREE_CODE (op1) == NON_LVALUE_EXPR 700918334Speter || TREE_CODE (op1) == CONVERT_EXPR)) 701018334Speter op1 = TREE_OPERAND (op1, 0); 701118334Speter 701218334Speter if (POINTER_TYPE_P (TREE_TYPE (op1))) 701318334Speter break; 701418334Speter 701518334Speter inner = TREE_OPERAND (inner, 0); 701618334Speter continue; 701718334Speter } 7018132718Skan 701918334Speter case ADDR_EXPR: 702018334Speter inner = TREE_OPERAND (inner, 0); 702118334Speter 7022169689Skan while (REFERENCE_CLASS_P (inner) 7023169689Skan && TREE_CODE (inner) != INDIRECT_REF) 702418334Speter inner = TREE_OPERAND (inner, 0); 702518334Speter 7026169689Skan if (DECL_P (inner) 7027169689Skan && !DECL_EXTERNAL (inner) 7028169689Skan && !TREE_STATIC (inner) 702918334Speter && DECL_CONTEXT (inner) == current_function_decl) 7030169689Skan warning (0, "function returns address of local variable"); 703118334Speter break; 703250397Sobrien 703350397Sobrien default: 703450397Sobrien break; 703518334Speter } 703618334Speter 703718334Speter break; 703818334Speter } 703918334Speter 7040169689Skan retval = build2 (MODIFY_EXPR, TREE_TYPE (res), res, t); 704118334Speter } 704290075Sobrien 7043169689Skan ret_stmt = build_stmt (RETURN_EXPR, retval); 7044169689Skan TREE_NO_WARNING (ret_stmt) |= no_warning; 7045169689Skan return add_stmt (ret_stmt); 704618334Speter} 704718334Speter 704890075Sobrienstruct c_switch { 7049169689Skan /* The SWITCH_EXPR being built. */ 7050169689Skan tree switch_expr; 7051169689Skan 7052169689Skan /* The original type of the testing expression, i.e. before the 7053169689Skan default conversion is applied. */ 7054169689Skan tree orig_type; 7055169689Skan 705690075Sobrien /* A splay-tree mapping the low element of a case range to the high 705790075Sobrien element, or NULL_TREE if there is no high element. Used to 705890075Sobrien determine whether or not a new case label duplicates an old case 705990075Sobrien label. We need a tree, rather than simply a hash table, because 706090075Sobrien of the GNU case range extension. */ 706190075Sobrien splay_tree cases; 7062169689Skan 7063169689Skan /* Number of nested statement expressions within this switch 7064169689Skan statement; if nonzero, case and default labels may not 7065169689Skan appear. */ 7066169689Skan unsigned int blocked_stmt_expr; 7067169689Skan 7068169689Skan /* Scope of outermost declarations of identifiers with variably 7069169689Skan modified type within this switch statement; if nonzero, case and 7070169689Skan default labels may not appear. */ 7071169689Skan unsigned int blocked_vm; 7072169689Skan 707390075Sobrien /* The next node on the stack. */ 707490075Sobrien struct c_switch *next; 707590075Sobrien}; 707618334Speter 707790075Sobrien/* A stack of the currently active switch statements. The innermost 707890075Sobrien switch statement is on the top of the stack. There is no need to 707990075Sobrien mark the stack for garbage collection because it is only active 708090075Sobrien during the processing of the body of a function, and we never 708190075Sobrien collect at that point. */ 708290075Sobrien 7083169689Skanstruct c_switch *c_switch_stack; 708490075Sobrien 708590075Sobrien/* Start a C switch statement, testing expression EXP. Return the new 7086169689Skan SWITCH_EXPR. */ 708790075Sobrien 708818334Spetertree 7089132718Skanc_start_case (tree exp) 709018334Speter{ 7091169689Skan tree orig_type = error_mark_node; 709290075Sobrien struct c_switch *cs; 709318334Speter 709490075Sobrien if (exp != error_mark_node) 709518334Speter { 709696263Sobrien orig_type = TREE_TYPE (exp); 709790075Sobrien 7098169689Skan if (!INTEGRAL_TYPE_P (orig_type)) 709990075Sobrien { 7100169689Skan if (orig_type != error_mark_node) 7101169689Skan { 7102169689Skan error ("switch quantity not an integer"); 7103169689Skan orig_type = error_mark_node; 7104169689Skan } 710590075Sobrien exp = integer_zero_node; 710690075Sobrien } 710790075Sobrien else 710890075Sobrien { 7109169689Skan tree type = TYPE_MAIN_VARIANT (orig_type); 711090075Sobrien 7111169689Skan if (!in_system_header 711290075Sobrien && (type == long_integer_type_node 711390075Sobrien || type == long_unsigned_type_node)) 7114169689Skan warning (OPT_Wtraditional, "%<long%> switch expression not " 7115169689Skan "converted to %<int%> in ISO C"); 711690075Sobrien 711790075Sobrien exp = default_conversion (exp); 711890075Sobrien } 711918334Speter } 712018334Speter 7121169689Skan /* Add this new SWITCH_EXPR to the stack. */ 7122169689Skan cs = XNEW (struct c_switch); 7123169689Skan cs->switch_expr = build3 (SWITCH_EXPR, orig_type, exp, NULL_TREE, NULL_TREE); 7124169689Skan cs->orig_type = orig_type; 712590075Sobrien cs->cases = splay_tree_new (case_compare, NULL, NULL); 7126169689Skan cs->blocked_stmt_expr = 0; 7127169689Skan cs->blocked_vm = 0; 7128169689Skan cs->next = c_switch_stack; 7129169689Skan c_switch_stack = cs; 713018334Speter 7131169689Skan return add_stmt (cs->switch_expr); 713290075Sobrien} 713390075Sobrien 713490075Sobrien/* Process a case label. */ 713590075Sobrien 713690075Sobrientree 7137132718Skando_case (tree low_value, tree high_value) 713890075Sobrien{ 713990075Sobrien tree label = NULL_TREE; 714090075Sobrien 7141169689Skan if (c_switch_stack && !c_switch_stack->blocked_stmt_expr 7142169689Skan && !c_switch_stack->blocked_vm) 714390075Sobrien { 7144169689Skan label = c_add_case_label (c_switch_stack->cases, 7145169689Skan SWITCH_COND (c_switch_stack->switch_expr), 7146169689Skan c_switch_stack->orig_type, 714790075Sobrien low_value, high_value); 714890075Sobrien if (label == error_mark_node) 714990075Sobrien label = NULL_TREE; 715018334Speter } 7151169689Skan else if (c_switch_stack && c_switch_stack->blocked_stmt_expr) 7152169689Skan { 7153169689Skan if (low_value) 7154169689Skan error ("case label in statement expression not containing " 7155169689Skan "enclosing switch statement"); 7156169689Skan else 7157169689Skan error ("%<default%> label in statement expression not containing " 7158169689Skan "enclosing switch statement"); 7159169689Skan } 7160169689Skan else if (c_switch_stack && c_switch_stack->blocked_vm) 7161169689Skan { 7162169689Skan if (low_value) 7163169689Skan error ("case label in scope of identifier with variably modified " 7164169689Skan "type not containing enclosing switch statement"); 7165169689Skan else 7166169689Skan error ("%<default%> label in scope of identifier with variably " 7167169689Skan "modified type not containing enclosing switch statement"); 7168169689Skan } 716990075Sobrien else if (low_value) 717090075Sobrien error ("case label not within a switch statement"); 717190075Sobrien else 7172169689Skan error ("%<default%> label not within a switch statement"); 717318334Speter 717490075Sobrien return label; 717590075Sobrien} 717618334Speter 717790075Sobrien/* Finish the switch statement. */ 717890075Sobrien 717990075Sobrienvoid 7180169689Skanc_finish_case (tree body) 718190075Sobrien{ 7182169689Skan struct c_switch *cs = c_switch_stack; 7183169689Skan location_t switch_location; 718490075Sobrien 7185169689Skan SWITCH_BODY (cs->switch_expr) = body; 7186146895Skan 7187169689Skan /* We must not be within a statement expression nested in the switch 7188169689Skan at this point; we might, however, be within the scope of an 7189169689Skan identifier with variably modified type nested in the switch. */ 7190169689Skan gcc_assert (!cs->blocked_stmt_expr); 719190075Sobrien 7192169689Skan /* Emit warnings as needed. */ 7193169689Skan if (EXPR_HAS_LOCATION (cs->switch_expr)) 7194169689Skan switch_location = EXPR_LOCATION (cs->switch_expr); 7195169689Skan else 7196169689Skan switch_location = input_location; 7197169689Skan c_do_switch_warnings (cs->cases, switch_location, 7198169689Skan TREE_TYPE (cs->switch_expr), 7199169689Skan SWITCH_COND (cs->switch_expr)); 7200169689Skan 720190075Sobrien /* Pop the stack. */ 7202169689Skan c_switch_stack = cs->next; 720390075Sobrien splay_tree_delete (cs->cases); 7204169689Skan XDELETE (cs); 720518334Speter} 7206169689Skan 7207169689Skan/* Emit an if statement. IF_LOCUS is the location of the 'if'. COND, 7208169689Skan THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK 7209169689Skan may be null. NESTED_IF is true if THEN_BLOCK contains another IF 7210169689Skan statement, and was not surrounded with parenthesis. */ 7211132718Skan 7212169689Skanvoid 7213169689Skanc_finish_if_stmt (location_t if_locus, tree cond, tree then_block, 7214169689Skan tree else_block, bool nested_if) 7215169689Skan{ 7216169689Skan tree stmt; 7217169689Skan 7218169689Skan /* Diagnose an ambiguous else if if-then-else is nested inside if-then. */ 7219169689Skan if (warn_parentheses && nested_if && else_block == NULL) 7220169689Skan { 7221169689Skan tree inner_if = then_block; 7222169689Skan 7223169689Skan /* We know from the grammar productions that there is an IF nested 7224169689Skan within THEN_BLOCK. Due to labels and c99 conditional declarations, 7225169689Skan it might not be exactly THEN_BLOCK, but should be the last 7226169689Skan non-container statement within. */ 7227169689Skan while (1) 7228169689Skan switch (TREE_CODE (inner_if)) 7229169689Skan { 7230169689Skan case COND_EXPR: 7231169689Skan goto found; 7232169689Skan case BIND_EXPR: 7233169689Skan inner_if = BIND_EXPR_BODY (inner_if); 7234169689Skan break; 7235169689Skan case STATEMENT_LIST: 7236169689Skan inner_if = expr_last (then_block); 7237169689Skan break; 7238169689Skan case TRY_FINALLY_EXPR: 7239169689Skan case TRY_CATCH_EXPR: 7240169689Skan inner_if = TREE_OPERAND (inner_if, 0); 7241169689Skan break; 7242169689Skan default: 7243169689Skan gcc_unreachable (); 7244169689Skan } 7245169689Skan found: 7246169689Skan 7247169689Skan if (COND_EXPR_ELSE (inner_if)) 7248169689Skan warning (OPT_Wparentheses, 7249169689Skan "%Hsuggest explicit braces to avoid ambiguous %<else%>", 7250169689Skan &if_locus); 7251169689Skan } 7252169689Skan 7253169689Skan empty_body_warning (then_block, else_block); 7254169689Skan 7255169689Skan stmt = build3 (COND_EXPR, void_type_node, cond, then_block, else_block); 7256169689Skan SET_EXPR_LOCATION (stmt, if_locus); 7257169689Skan add_stmt (stmt); 7258169689Skan} 7259169689Skan 7260260919Spfg/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ 7261260919Spfg/* Emit a general-purpose loop construct. START_LOCUS is the location 7262260919Spfg of the beginning of the loop. COND is the loop condition. 7263260919Spfg COND_IS_FIRST is false for DO loops. INCR is the FOR increment 7264260919Spfg expression. BODY is the statement controlled by the loop. BLAB is 7265260919Spfg the break label. CLAB is the continue label. ATTRS is the 7266260919Spfg attributes associated with the loop, which at present are 7267260919Spfg associated with the topmost label. Everything is allowed to be 7268260919Spfg NULL. */ 7269169689Skan 7270260919Spfg/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ 7271169689Skanvoid 7272169689Skanc_finish_loop (location_t start_locus, tree cond, tree incr, tree body, 7273260919Spfg/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ 7274260919Spfg tree blab, tree clab, tree attrs, bool cond_is_first) 7275260919Spfg/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ 7276169689Skan{ 7277169689Skan tree entry = NULL, exit = NULL, t; 7278169689Skan 7279169689Skan /* If the condition is zero don't generate a loop construct. */ 7280169689Skan if (cond && integer_zerop (cond)) 7281169689Skan { 7282169689Skan if (cond_is_first) 7283169689Skan { 7284169689Skan t = build_and_jump (&blab); 7285169689Skan SET_EXPR_LOCATION (t, start_locus); 7286169689Skan add_stmt (t); 7287169689Skan } 7288169689Skan } 7289169689Skan else 7290169689Skan { 7291169689Skan tree top = build1 (LABEL_EXPR, void_type_node, NULL_TREE); 7292169689Skan 7293169689Skan /* If we have an exit condition, then we build an IF with gotos either 7294169689Skan out of the loop, or to the top of it. If there's no exit condition, 7295169689Skan then we just build a jump back to the top. */ 7296169689Skan exit = build_and_jump (&LABEL_EXPR_LABEL (top)); 7297169689Skan 7298169689Skan if (cond && !integer_nonzerop (cond)) 7299169689Skan { 7300169689Skan /* Canonicalize the loop condition to the end. This means 7301169689Skan generating a branch to the loop condition. Reuse the 7302169689Skan continue label, if possible. */ 7303169689Skan if (cond_is_first) 7304169689Skan { 7305169689Skan if (incr || !clab) 7306169689Skan { 7307169689Skan entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE); 7308169689Skan t = build_and_jump (&LABEL_EXPR_LABEL (entry)); 7309169689Skan } 7310169689Skan else 7311169689Skan t = build1 (GOTO_EXPR, void_type_node, clab); 7312169689Skan SET_EXPR_LOCATION (t, start_locus); 7313169689Skan add_stmt (t); 7314169689Skan } 7315169689Skan 7316169689Skan t = build_and_jump (&blab); 7317169689Skan exit = fold_build3 (COND_EXPR, void_type_node, cond, exit, t); 7318169689Skan if (cond_is_first) 7319169689Skan SET_EXPR_LOCATION (exit, start_locus); 7320169689Skan else 7321169689Skan SET_EXPR_LOCATION (exit, input_location); 7322169689Skan } 7323169689Skan 7324169689Skan add_stmt (top); 7325169689Skan } 7326169689Skan 7327169689Skan if (body) 7328169689Skan add_stmt (body); 7329169689Skan if (clab) 7330169689Skan add_stmt (build1 (LABEL_EXPR, void_type_node, clab)); 7331169689Skan if (incr) 7332169689Skan add_stmt (incr); 7333169689Skan if (entry) 7334169689Skan add_stmt (entry); 7335169689Skan if (exit) 7336169689Skan add_stmt (exit); 7337169689Skan if (blab) 7338169689Skan add_stmt (build1 (LABEL_EXPR, void_type_node, blab)); 7339169689Skan} 7340169689Skan 7341169689Skantree 7342169689Skanc_finish_bc_stmt (tree *label_p, bool is_break) 7343169689Skan{ 7344169689Skan bool skip; 7345169689Skan tree label = *label_p; 7346169689Skan 7347169689Skan /* In switch statements break is sometimes stylistically used after 7348169689Skan a return statement. This can lead to spurious warnings about 7349169689Skan control reaching the end of a non-void function when it is 7350169689Skan inlined. Note that we are calling block_may_fallthru with 7351169689Skan language specific tree nodes; this works because 7352169689Skan block_may_fallthru returns true when given something it does not 7353169689Skan understand. */ 7354169689Skan skip = !block_may_fallthru (cur_stmt_list); 7355169689Skan 7356169689Skan if (!label) 7357169689Skan { 7358169689Skan if (!skip) 7359169689Skan *label_p = label = create_artificial_label (); 7360169689Skan } 7361169689Skan else if (TREE_CODE (label) == LABEL_DECL) 7362169689Skan ; 7363169689Skan else switch (TREE_INT_CST_LOW (label)) 7364169689Skan { 7365169689Skan case 0: 7366169689Skan if (is_break) 7367169689Skan error ("break statement not within loop or switch"); 7368169689Skan else 7369169689Skan error ("continue statement not within a loop"); 7370169689Skan return NULL_TREE; 7371169689Skan 7372169689Skan case 1: 7373169689Skan gcc_assert (is_break); 7374169689Skan error ("break statement used with OpenMP for loop"); 7375169689Skan return NULL_TREE; 7376169689Skan 7377169689Skan default: 7378169689Skan gcc_unreachable (); 7379169689Skan } 7380169689Skan 7381169689Skan if (skip) 7382169689Skan return NULL_TREE; 7383169689Skan 7384169689Skan return add_stmt (build1 (GOTO_EXPR, void_type_node, label)); 7385169689Skan} 7386169689Skan 7387169689Skan/* A helper routine for c_process_expr_stmt and c_finish_stmt_expr. */ 7388169689Skan 7389169689Skanstatic void 7390169689Skanemit_side_effect_warnings (tree expr) 7391169689Skan{ 7392169689Skan if (expr == error_mark_node) 7393169689Skan ; 7394169689Skan else if (!TREE_SIDE_EFFECTS (expr)) 7395169689Skan { 7396169689Skan if (!VOID_TYPE_P (TREE_TYPE (expr)) && !TREE_NO_WARNING (expr)) 7397169689Skan warning (0, "%Hstatement with no effect", 7398169689Skan EXPR_HAS_LOCATION (expr) ? EXPR_LOCUS (expr) : &input_location); 7399169689Skan } 7400169689Skan else if (warn_unused_value) 7401169689Skan warn_if_unused_value (expr, input_location); 7402169689Skan} 7403169689Skan 7404169689Skan/* Process an expression as if it were a complete statement. Emit 7405169689Skan diagnostics, but do not call ADD_STMT. */ 7406169689Skan 7407169689Skantree 7408169689Skanc_process_expr_stmt (tree expr) 7409169689Skan{ 7410169689Skan if (!expr) 7411169689Skan return NULL_TREE; 7412169689Skan 7413169689Skan if (warn_sequence_point) 7414169689Skan verify_sequence_points (expr); 7415169689Skan 7416169689Skan if (TREE_TYPE (expr) != error_mark_node 7417169689Skan && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr)) 7418169689Skan && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE) 7419169689Skan error ("expression statement has incomplete type"); 7420169689Skan 7421169689Skan /* If we're not processing a statement expression, warn about unused values. 7422169689Skan Warnings for statement expressions will be emitted later, once we figure 7423169689Skan out which is the result. */ 7424169689Skan if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list) 7425169689Skan && (extra_warnings || warn_unused_value)) 7426169689Skan emit_side_effect_warnings (expr); 7427169689Skan 7428169689Skan /* If the expression is not of a type to which we cannot assign a line 7429169689Skan number, wrap the thing in a no-op NOP_EXPR. */ 7430169689Skan if (DECL_P (expr) || CONSTANT_CLASS_P (expr)) 7431169689Skan expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr); 7432169689Skan 7433169689Skan if (EXPR_P (expr)) 7434169689Skan SET_EXPR_LOCATION (expr, input_location); 7435169689Skan 7436169689Skan return expr; 7437169689Skan} 7438169689Skan 7439169689Skan/* Emit an expression as a statement. */ 7440169689Skan 7441169689Skantree 7442169689Skanc_finish_expr_stmt (tree expr) 7443169689Skan{ 7444169689Skan if (expr) 7445169689Skan return add_stmt (c_process_expr_stmt (expr)); 7446169689Skan else 7447169689Skan return NULL; 7448169689Skan} 7449169689Skan 7450169689Skan/* Do the opposite and emit a statement as an expression. To begin, 7451169689Skan create a new binding level and return it. */ 7452169689Skan 7453169689Skantree 7454169689Skanc_begin_stmt_expr (void) 7455169689Skan{ 7456169689Skan tree ret; 7457169689Skan struct c_label_context_se *nstack; 7458169689Skan struct c_label_list *glist; 7459169689Skan 7460169689Skan /* We must force a BLOCK for this level so that, if it is not expanded 7461169689Skan later, there is a way to turn off the entire subtree of blocks that 7462169689Skan are contained in it. */ 7463169689Skan keep_next_level (); 7464169689Skan ret = c_begin_compound_stmt (true); 7465169689Skan if (c_switch_stack) 7466169689Skan { 7467169689Skan c_switch_stack->blocked_stmt_expr++; 7468169689Skan gcc_assert (c_switch_stack->blocked_stmt_expr != 0); 7469169689Skan } 7470169689Skan for (glist = label_context_stack_se->labels_used; 7471169689Skan glist != NULL; 7472169689Skan glist = glist->next) 7473169689Skan { 7474169689Skan C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 1; 7475169689Skan } 7476169689Skan nstack = XOBNEW (&parser_obstack, struct c_label_context_se); 7477169689Skan nstack->labels_def = NULL; 7478169689Skan nstack->labels_used = NULL; 7479169689Skan nstack->next = label_context_stack_se; 7480169689Skan label_context_stack_se = nstack; 7481169689Skan 7482169689Skan /* Mark the current statement list as belonging to a statement list. */ 7483169689Skan STATEMENT_LIST_STMT_EXPR (ret) = 1; 7484169689Skan 7485169689Skan return ret; 7486169689Skan} 7487169689Skan 7488169689Skantree 7489169689Skanc_finish_stmt_expr (tree body) 7490169689Skan{ 7491169689Skan tree last, type, tmp, val; 7492169689Skan tree *last_p; 7493169689Skan struct c_label_list *dlist, *glist, *glist_prev = NULL; 7494169689Skan 7495169689Skan body = c_end_compound_stmt (body, true); 7496169689Skan if (c_switch_stack) 7497169689Skan { 7498169689Skan gcc_assert (c_switch_stack->blocked_stmt_expr != 0); 7499169689Skan c_switch_stack->blocked_stmt_expr--; 7500169689Skan } 7501169689Skan /* It is no longer possible to jump to labels defined within this 7502169689Skan statement expression. */ 7503169689Skan for (dlist = label_context_stack_se->labels_def; 7504169689Skan dlist != NULL; 7505169689Skan dlist = dlist->next) 7506169689Skan { 7507169689Skan C_DECL_UNJUMPABLE_STMT_EXPR (dlist->label) = 1; 7508169689Skan } 7509169689Skan /* It is again possible to define labels with a goto just outside 7510169689Skan this statement expression. */ 7511169689Skan for (glist = label_context_stack_se->next->labels_used; 7512169689Skan glist != NULL; 7513169689Skan glist = glist->next) 7514169689Skan { 7515169689Skan C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 0; 7516169689Skan glist_prev = glist; 7517169689Skan } 7518169689Skan if (glist_prev != NULL) 7519169689Skan glist_prev->next = label_context_stack_se->labels_used; 7520169689Skan else 7521169689Skan label_context_stack_se->next->labels_used 7522169689Skan = label_context_stack_se->labels_used; 7523169689Skan label_context_stack_se = label_context_stack_se->next; 7524169689Skan 7525169689Skan /* Locate the last statement in BODY. See c_end_compound_stmt 7526169689Skan about always returning a BIND_EXPR. */ 7527169689Skan last_p = &BIND_EXPR_BODY (body); 7528169689Skan last = BIND_EXPR_BODY (body); 7529169689Skan 7530169689Skan continue_searching: 7531169689Skan if (TREE_CODE (last) == STATEMENT_LIST) 7532169689Skan { 7533169689Skan tree_stmt_iterator i; 7534169689Skan 7535169689Skan /* This can happen with degenerate cases like ({ }). No value. */ 7536169689Skan if (!TREE_SIDE_EFFECTS (last)) 7537169689Skan return body; 7538169689Skan 7539169689Skan /* If we're supposed to generate side effects warnings, process 7540169689Skan all of the statements except the last. */ 7541169689Skan if (extra_warnings || warn_unused_value) 7542169689Skan { 7543169689Skan for (i = tsi_start (last); !tsi_one_before_end_p (i); tsi_next (&i)) 7544169689Skan emit_side_effect_warnings (tsi_stmt (i)); 7545169689Skan } 7546169689Skan else 7547169689Skan i = tsi_last (last); 7548169689Skan last_p = tsi_stmt_ptr (i); 7549169689Skan last = *last_p; 7550169689Skan } 7551169689Skan 7552169689Skan /* If the end of the list is exception related, then the list was split 7553169689Skan by a call to push_cleanup. Continue searching. */ 7554169689Skan if (TREE_CODE (last) == TRY_FINALLY_EXPR 7555169689Skan || TREE_CODE (last) == TRY_CATCH_EXPR) 7556169689Skan { 7557169689Skan last_p = &TREE_OPERAND (last, 0); 7558169689Skan last = *last_p; 7559169689Skan goto continue_searching; 7560169689Skan } 7561169689Skan 7562169689Skan /* In the case that the BIND_EXPR is not necessary, return the 7563169689Skan expression out from inside it. */ 7564169689Skan if (last == error_mark_node 7565169689Skan || (last == BIND_EXPR_BODY (body) 7566169689Skan && BIND_EXPR_VARS (body) == NULL)) 7567169689Skan { 7568169689Skan /* Do not warn if the return value of a statement expression is 7569169689Skan unused. */ 7570169689Skan if (EXPR_P (last)) 7571169689Skan TREE_NO_WARNING (last) = 1; 7572169689Skan return last; 7573169689Skan } 7574169689Skan 7575169689Skan /* Extract the type of said expression. */ 7576169689Skan type = TREE_TYPE (last); 7577169689Skan 7578169689Skan /* If we're not returning a value at all, then the BIND_EXPR that 7579169689Skan we already have is a fine expression to return. */ 7580169689Skan if (!type || VOID_TYPE_P (type)) 7581169689Skan return body; 7582169689Skan 7583169689Skan /* Now that we've located the expression containing the value, it seems 7584169689Skan silly to make voidify_wrapper_expr repeat the process. Create a 7585169689Skan temporary of the appropriate type and stick it in a TARGET_EXPR. */ 7586169689Skan tmp = create_tmp_var_raw (type, NULL); 7587169689Skan 7588169689Skan /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt. This avoids 7589169689Skan tree_expr_nonnegative_p giving up immediately. */ 7590169689Skan val = last; 7591169689Skan if (TREE_CODE (val) == NOP_EXPR 7592169689Skan && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0))) 7593169689Skan val = TREE_OPERAND (val, 0); 7594169689Skan 7595169689Skan *last_p = build2 (MODIFY_EXPR, void_type_node, tmp, val); 7596169689Skan SET_EXPR_LOCUS (*last_p, EXPR_LOCUS (last)); 7597169689Skan 7598169689Skan return build4 (TARGET_EXPR, type, tmp, body, NULL_TREE, NULL_TREE); 7599169689Skan} 7600169689Skan 7601169689Skan/* Begin the scope of an identifier of variably modified type, scope 7602169689Skan number SCOPE. Jumping from outside this scope to inside it is not 7603169689Skan permitted. */ 7604169689Skan 7605169689Skanvoid 7606169689Skanc_begin_vm_scope (unsigned int scope) 7607169689Skan{ 7608169689Skan struct c_label_context_vm *nstack; 7609169689Skan struct c_label_list *glist; 7610169689Skan 7611169689Skan gcc_assert (scope > 0); 7612169689Skan 7613169689Skan /* At file_scope, we don't have to do any processing. */ 7614169689Skan if (label_context_stack_vm == NULL) 7615169689Skan return; 7616169689Skan 7617169689Skan if (c_switch_stack && !c_switch_stack->blocked_vm) 7618169689Skan c_switch_stack->blocked_vm = scope; 7619169689Skan for (glist = label_context_stack_vm->labels_used; 7620169689Skan glist != NULL; 7621169689Skan glist = glist->next) 7622169689Skan { 7623169689Skan C_DECL_UNDEFINABLE_VM (glist->label) = 1; 7624169689Skan } 7625169689Skan nstack = XOBNEW (&parser_obstack, struct c_label_context_vm); 7626169689Skan nstack->labels_def = NULL; 7627169689Skan nstack->labels_used = NULL; 7628169689Skan nstack->scope = scope; 7629169689Skan nstack->next = label_context_stack_vm; 7630169689Skan label_context_stack_vm = nstack; 7631169689Skan} 7632169689Skan 7633169689Skan/* End a scope which may contain identifiers of variably modified 7634169689Skan type, scope number SCOPE. */ 7635169689Skan 7636169689Skanvoid 7637169689Skanc_end_vm_scope (unsigned int scope) 7638169689Skan{ 7639169689Skan if (label_context_stack_vm == NULL) 7640169689Skan return; 7641169689Skan if (c_switch_stack && c_switch_stack->blocked_vm == scope) 7642169689Skan c_switch_stack->blocked_vm = 0; 7643169689Skan /* We may have a number of nested scopes of identifiers with 7644169689Skan variably modified type, all at this depth. Pop each in turn. */ 7645169689Skan while (label_context_stack_vm->scope == scope) 7646169689Skan { 7647169689Skan struct c_label_list *dlist, *glist, *glist_prev = NULL; 7648169689Skan 7649169689Skan /* It is no longer possible to jump to labels defined within this 7650169689Skan scope. */ 7651169689Skan for (dlist = label_context_stack_vm->labels_def; 7652169689Skan dlist != NULL; 7653169689Skan dlist = dlist->next) 7654169689Skan { 7655169689Skan C_DECL_UNJUMPABLE_VM (dlist->label) = 1; 7656169689Skan } 7657169689Skan /* It is again possible to define labels with a goto just outside 7658169689Skan this scope. */ 7659169689Skan for (glist = label_context_stack_vm->next->labels_used; 7660169689Skan glist != NULL; 7661169689Skan glist = glist->next) 7662169689Skan { 7663169689Skan C_DECL_UNDEFINABLE_VM (glist->label) = 0; 7664169689Skan glist_prev = glist; 7665169689Skan } 7666169689Skan if (glist_prev != NULL) 7667169689Skan glist_prev->next = label_context_stack_vm->labels_used; 7668169689Skan else 7669169689Skan label_context_stack_vm->next->labels_used 7670169689Skan = label_context_stack_vm->labels_used; 7671169689Skan label_context_stack_vm = label_context_stack_vm->next; 7672169689Skan } 7673169689Skan} 7674169689Skan 7675169689Skan/* Begin and end compound statements. This is as simple as pushing 7676169689Skan and popping new statement lists from the tree. */ 7677169689Skan 7678169689Skantree 7679169689Skanc_begin_compound_stmt (bool do_scope) 7680169689Skan{ 7681169689Skan tree stmt = push_stmt_list (); 7682169689Skan if (do_scope) 7683169689Skan push_scope (); 7684169689Skan return stmt; 7685169689Skan} 7686169689Skan 7687169689Skantree 7688169689Skanc_end_compound_stmt (tree stmt, bool do_scope) 7689169689Skan{ 7690169689Skan tree block = NULL; 7691169689Skan 7692169689Skan if (do_scope) 7693169689Skan { 7694169689Skan if (c_dialect_objc ()) 7695169689Skan objc_clear_super_receiver (); 7696169689Skan block = pop_scope (); 7697169689Skan } 7698169689Skan 7699169689Skan stmt = pop_stmt_list (stmt); 7700169689Skan stmt = c_build_bind_expr (block, stmt); 7701169689Skan 7702169689Skan /* If this compound statement is nested immediately inside a statement 7703169689Skan expression, then force a BIND_EXPR to be created. Otherwise we'll 7704169689Skan do the wrong thing for ({ { 1; } }) or ({ 1; { } }). In particular, 7705169689Skan STATEMENT_LISTs merge, and thus we can lose track of what statement 7706169689Skan was really last. */ 7707169689Skan if (cur_stmt_list 7708169689Skan && STATEMENT_LIST_STMT_EXPR (cur_stmt_list) 7709169689Skan && TREE_CODE (stmt) != BIND_EXPR) 7710169689Skan { 7711169689Skan stmt = build3 (BIND_EXPR, void_type_node, NULL, stmt, NULL); 7712169689Skan TREE_SIDE_EFFECTS (stmt) = 1; 7713169689Skan } 7714169689Skan 7715169689Skan return stmt; 7716169689Skan} 7717169689Skan 7718169689Skan/* Queue a cleanup. CLEANUP is an expression/statement to be executed 7719169689Skan when the current scope is exited. EH_ONLY is true when this is not 7720169689Skan meant to apply to normal control flow transfer. */ 7721169689Skan 7722169689Skanvoid 7723169689Skanpush_cleanup (tree ARG_UNUSED (decl), tree cleanup, bool eh_only) 7724169689Skan{ 7725169689Skan enum tree_code code; 7726169689Skan tree stmt, list; 7727169689Skan bool stmt_expr; 7728169689Skan 7729169689Skan code = eh_only ? TRY_CATCH_EXPR : TRY_FINALLY_EXPR; 7730169689Skan stmt = build_stmt (code, NULL, cleanup); 7731169689Skan add_stmt (stmt); 7732169689Skan stmt_expr = STATEMENT_LIST_STMT_EXPR (cur_stmt_list); 7733169689Skan list = push_stmt_list (); 7734169689Skan TREE_OPERAND (stmt, 0) = list; 7735169689Skan STATEMENT_LIST_STMT_EXPR (list) = stmt_expr; 7736169689Skan} 7737169689Skan 7738132718Skan/* Build a binary-operation expression without default conversions. 7739132718Skan CODE is the kind of expression to build. 7740132718Skan This function differs from `build' in several ways: 7741132718Skan the data type of the result is computed and recorded in it, 7742132718Skan warnings are generated if arg data types are invalid, 7743132718Skan special handling for addition and subtraction of pointers is known, 7744132718Skan and some optimization is done (operations on narrow ints 7745132718Skan are done in the narrower type when that gives the same result). 7746132718Skan Constant folding is also done before the result is returned. 7747132718Skan 7748132718Skan Note that the operands will never have enumeral types, or function 7749132718Skan or array types, because either they will have the default conversions 7750132718Skan performed or they have both just been converted to some other type in which 7751132718Skan the arithmetic is to be done. */ 7752132718Skan 7753132718Skantree 7754132718Skanbuild_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, 7755132718Skan int convert_p) 7756132718Skan{ 7757132718Skan tree type0, type1; 7758132718Skan enum tree_code code0, code1; 7759132718Skan tree op0, op1; 7760169689Skan const char *invalid_op_diag; 7761132718Skan 7762132718Skan /* Expression code to give to the expression when it is built. 7763132718Skan Normally this is CODE, which is what the caller asked for, 7764132718Skan but in some special cases we change it. */ 7765132718Skan enum tree_code resultcode = code; 7766132718Skan 7767132718Skan /* Data type in which the computation is to be performed. 7768132718Skan In the simplest cases this is the common type of the arguments. */ 7769132718Skan tree result_type = NULL; 7770132718Skan 7771132718Skan /* Nonzero means operands have already been type-converted 7772132718Skan in whatever way is necessary. 7773132718Skan Zero means they need to be converted to RESULT_TYPE. */ 7774132718Skan int converted = 0; 7775132718Skan 7776132718Skan /* Nonzero means create the expression with this type, rather than 7777132718Skan RESULT_TYPE. */ 7778132718Skan tree build_type = 0; 7779132718Skan 7780132718Skan /* Nonzero means after finally constructing the expression 7781132718Skan convert it to this type. */ 7782132718Skan tree final_type = 0; 7783132718Skan 7784132718Skan /* Nonzero if this is an operation like MIN or MAX which can 7785132718Skan safely be computed in short if both args are promoted shorts. 7786132718Skan Also implies COMMON. 7787132718Skan -1 indicates a bitwise operation; this makes a difference 7788132718Skan in the exact conditions for when it is safe to do the operation 7789132718Skan in a narrower mode. */ 7790132718Skan int shorten = 0; 7791132718Skan 7792132718Skan /* Nonzero if this is a comparison operation; 7793132718Skan if both args are promoted shorts, compare the original shorts. 7794132718Skan Also implies COMMON. */ 7795132718Skan int short_compare = 0; 7796132718Skan 7797132718Skan /* Nonzero if this is a right-shift operation, which can be computed on the 7798132718Skan original short and then promoted if the operand is a promoted short. */ 7799132718Skan int short_shift = 0; 7800132718Skan 7801132718Skan /* Nonzero means set RESULT_TYPE to the common type of the args. */ 7802132718Skan int common = 0; 7803132718Skan 7804169689Skan /* True means types are compatible as far as ObjC is concerned. */ 7805169689Skan bool objc_ok; 7806169689Skan 7807132718Skan if (convert_p) 7808132718Skan { 7809132718Skan op0 = default_conversion (orig_op0); 7810132718Skan op1 = default_conversion (orig_op1); 7811132718Skan } 7812132718Skan else 7813132718Skan { 7814132718Skan op0 = orig_op0; 7815132718Skan op1 = orig_op1; 7816132718Skan } 7817132718Skan 7818132718Skan type0 = TREE_TYPE (op0); 7819132718Skan type1 = TREE_TYPE (op1); 7820132718Skan 7821132718Skan /* The expression codes of the data types of the arguments tell us 7822132718Skan whether the arguments are integers, floating, pointers, etc. */ 7823132718Skan code0 = TREE_CODE (type0); 7824132718Skan code1 = TREE_CODE (type1); 7825132718Skan 7826132718Skan /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */ 7827132718Skan STRIP_TYPE_NOPS (op0); 7828132718Skan STRIP_TYPE_NOPS (op1); 7829132718Skan 7830132718Skan /* If an error was already reported for one of the arguments, 7831132718Skan avoid reporting another error. */ 7832132718Skan 7833132718Skan if (code0 == ERROR_MARK || code1 == ERROR_MARK) 7834132718Skan return error_mark_node; 7835132718Skan 7836169689Skan if ((invalid_op_diag 7837169689Skan = targetm.invalid_binary_op (code, type0, type1))) 7838169689Skan { 7839260012Spfg error (invalid_op_diag, ""); 7840169689Skan return error_mark_node; 7841169689Skan } 7842169689Skan 7843169689Skan objc_ok = objc_compare_types (type0, type1, -3, NULL_TREE); 7844169689Skan 7845132718Skan switch (code) 7846132718Skan { 7847132718Skan case PLUS_EXPR: 7848132718Skan /* Handle the pointer + int case. */ 7849132718Skan if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 7850132718Skan return pointer_int_sum (PLUS_EXPR, op0, op1); 7851132718Skan else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE) 7852132718Skan return pointer_int_sum (PLUS_EXPR, op1, op0); 7853132718Skan else 7854132718Skan common = 1; 7855132718Skan break; 7856132718Skan 7857132718Skan case MINUS_EXPR: 7858132718Skan /* Subtraction of two similar pointers. 7859132718Skan We must subtract them as integers, then divide by object size. */ 7860132718Skan if (code0 == POINTER_TYPE && code1 == POINTER_TYPE 7861169689Skan && comp_target_types (type0, type1)) 7862132718Skan return pointer_diff (op0, op1); 7863132718Skan /* Handle pointer minus int. Just like pointer plus int. */ 7864132718Skan else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 7865132718Skan return pointer_int_sum (MINUS_EXPR, op0, op1); 7866132718Skan else 7867132718Skan common = 1; 7868132718Skan break; 7869132718Skan 7870132718Skan case MULT_EXPR: 7871132718Skan common = 1; 7872132718Skan break; 7873132718Skan 7874132718Skan case TRUNC_DIV_EXPR: 7875132718Skan case CEIL_DIV_EXPR: 7876132718Skan case FLOOR_DIV_EXPR: 7877132718Skan case ROUND_DIV_EXPR: 7878132718Skan case EXACT_DIV_EXPR: 7879132718Skan /* Floating point division by zero is a legitimate way to obtain 7880132718Skan infinities and NaNs. */ 7881169689Skan if (skip_evaluation == 0 && integer_zerop (op1)) 7882169689Skan warning (OPT_Wdiv_by_zero, "division by zero"); 7883132718Skan 7884132718Skan if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE 7885132718Skan || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE) 7886132718Skan && (code1 == INTEGER_TYPE || code1 == REAL_TYPE 7887132718Skan || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)) 7888132718Skan { 7889169689Skan enum tree_code tcode0 = code0, tcode1 = code1; 7890169689Skan 7891169689Skan if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE) 7892169689Skan tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0))); 7893169689Skan if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE) 7894169689Skan tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1))); 7895169689Skan 7896169689Skan if (!(tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE)) 7897132718Skan resultcode = RDIV_EXPR; 7898132718Skan else 7899132718Skan /* Although it would be tempting to shorten always here, that 7900132718Skan loses on some targets, since the modulo instruction is 7901132718Skan undefined if the quotient can't be represented in the 7902132718Skan computation mode. We shorten only if unsigned or if 7903132718Skan dividing by something we know != -1. */ 7904169689Skan shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0)) 7905132718Skan || (TREE_CODE (op1) == INTEGER_CST 7906169689Skan && !integer_all_onesp (op1))); 7907132718Skan common = 1; 7908132718Skan } 7909132718Skan break; 7910132718Skan 7911132718Skan case BIT_AND_EXPR: 7912132718Skan case BIT_IOR_EXPR: 7913132718Skan case BIT_XOR_EXPR: 7914132718Skan if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 7915132718Skan shorten = -1; 7916132718Skan else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE) 7917132718Skan common = 1; 7918132718Skan break; 7919132718Skan 7920132718Skan case TRUNC_MOD_EXPR: 7921132718Skan case FLOOR_MOD_EXPR: 7922169689Skan if (skip_evaluation == 0 && integer_zerop (op1)) 7923169689Skan warning (OPT_Wdiv_by_zero, "division by zero"); 7924132718Skan 7925132718Skan if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 7926132718Skan { 7927132718Skan /* Although it would be tempting to shorten always here, that loses 7928132718Skan on some targets, since the modulo instruction is undefined if the 7929132718Skan quotient can't be represented in the computation mode. We shorten 7930132718Skan only if unsigned or if dividing by something we know != -1. */ 7931169689Skan shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0)) 7932132718Skan || (TREE_CODE (op1) == INTEGER_CST 7933169689Skan && !integer_all_onesp (op1))); 7934132718Skan common = 1; 7935132718Skan } 7936132718Skan break; 7937132718Skan 7938132718Skan case TRUTH_ANDIF_EXPR: 7939132718Skan case TRUTH_ORIF_EXPR: 7940132718Skan case TRUTH_AND_EXPR: 7941132718Skan case TRUTH_OR_EXPR: 7942132718Skan case TRUTH_XOR_EXPR: 7943132718Skan if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE 7944132718Skan || code0 == REAL_TYPE || code0 == COMPLEX_TYPE) 7945132718Skan && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE 7946132718Skan || code1 == REAL_TYPE || code1 == COMPLEX_TYPE)) 7947132718Skan { 7948132718Skan /* Result of these operations is always an int, 7949132718Skan but that does not mean the operands should be 7950132718Skan converted to ints! */ 7951132718Skan result_type = integer_type_node; 7952132718Skan op0 = c_common_truthvalue_conversion (op0); 7953132718Skan op1 = c_common_truthvalue_conversion (op1); 7954132718Skan converted = 1; 7955132718Skan } 7956132718Skan break; 7957132718Skan 7958132718Skan /* Shift operations: result has same type as first operand; 7959132718Skan always convert second operand to int. 7960132718Skan Also set SHORT_SHIFT if shifting rightward. */ 7961132718Skan 7962132718Skan case RSHIFT_EXPR: 7963132718Skan if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 7964132718Skan { 7965132718Skan if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0) 7966132718Skan { 7967132718Skan if (tree_int_cst_sgn (op1) < 0) 7968169689Skan warning (0, "right shift count is negative"); 7969132718Skan else 7970132718Skan { 7971169689Skan if (!integer_zerop (op1)) 7972132718Skan short_shift = 1; 7973132718Skan 7974132718Skan if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0) 7975169689Skan warning (0, "right shift count >= width of type"); 7976132718Skan } 7977132718Skan } 7978132718Skan 7979132718Skan /* Use the type of the value to be shifted. */ 7980132718Skan result_type = type0; 7981132718Skan /* Convert the shift-count to an integer, regardless of size 7982132718Skan of value being shifted. */ 7983132718Skan if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node) 7984132718Skan op1 = convert (integer_type_node, op1); 7985132718Skan /* Avoid converting op1 to result_type later. */ 7986132718Skan converted = 1; 7987132718Skan } 7988132718Skan break; 7989132718Skan 7990132718Skan case LSHIFT_EXPR: 7991132718Skan if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 7992132718Skan { 7993132718Skan if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0) 7994132718Skan { 7995132718Skan if (tree_int_cst_sgn (op1) < 0) 7996169689Skan warning (0, "left shift count is negative"); 7997132718Skan 7998132718Skan else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0) 7999169689Skan warning (0, "left shift count >= width of type"); 8000132718Skan } 8001132718Skan 8002132718Skan /* Use the type of the value to be shifted. */ 8003132718Skan result_type = type0; 8004132718Skan /* Convert the shift-count to an integer, regardless of size 8005132718Skan of value being shifted. */ 8006132718Skan if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node) 8007132718Skan op1 = convert (integer_type_node, op1); 8008132718Skan /* Avoid converting op1 to result_type later. */ 8009132718Skan converted = 1; 8010132718Skan } 8011132718Skan break; 8012132718Skan 8013132718Skan case EQ_EXPR: 8014132718Skan case NE_EXPR: 8015169689Skan if (code0 == REAL_TYPE || code1 == REAL_TYPE) 8016169689Skan warning (OPT_Wfloat_equal, 8017169689Skan "comparing floating point with == or != is unsafe"); 8018132718Skan /* Result of comparison is always int, 8019132718Skan but don't convert the args to int! */ 8020132718Skan build_type = integer_type_node; 8021132718Skan if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE 8022132718Skan || code0 == COMPLEX_TYPE) 8023132718Skan && (code1 == INTEGER_TYPE || code1 == REAL_TYPE 8024132718Skan || code1 == COMPLEX_TYPE)) 8025132718Skan short_compare = 1; 8026132718Skan else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE) 8027132718Skan { 8028132718Skan tree tt0 = TREE_TYPE (type0); 8029132718Skan tree tt1 = TREE_TYPE (type1); 8030132718Skan /* Anything compares with void *. void * compares with anything. 8031132718Skan Otherwise, the targets must be compatible 8032132718Skan and both must be object or both incomplete. */ 8033169689Skan if (comp_target_types (type0, type1)) 8034169689Skan result_type = common_pointer_type (type0, type1); 8035132718Skan else if (VOID_TYPE_P (tt0)) 8036132718Skan { 8037132718Skan /* op0 != orig_op0 detects the case of something 8038132718Skan whose value is 0 but which isn't a valid null ptr const. */ 8039169689Skan if (pedantic && !null_pointer_constant_p (orig_op0) 8040132718Skan && TREE_CODE (tt1) == FUNCTION_TYPE) 8041169689Skan pedwarn ("ISO C forbids comparison of %<void *%>" 8042169689Skan " with function pointer"); 8043132718Skan } 8044132718Skan else if (VOID_TYPE_P (tt1)) 8045132718Skan { 8046169689Skan if (pedantic && !null_pointer_constant_p (orig_op1) 8047132718Skan && TREE_CODE (tt0) == FUNCTION_TYPE) 8048169689Skan pedwarn ("ISO C forbids comparison of %<void *%>" 8049169689Skan " with function pointer"); 8050132718Skan } 8051132718Skan else 8052169689Skan /* Avoid warning about the volatile ObjC EH puts on decls. */ 8053169689Skan if (!objc_ok) 8054169689Skan pedwarn ("comparison of distinct pointer types lacks a cast"); 8055132718Skan 8056132718Skan if (result_type == NULL_TREE) 8057132718Skan result_type = ptr_type_node; 8058132718Skan } 8059169689Skan else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1)) 8060169689Skan { 8061169689Skan if (TREE_CODE (op0) == ADDR_EXPR 8062169689Skan && DECL_P (TREE_OPERAND (op0, 0)) 8063169689Skan && (TREE_CODE (TREE_OPERAND (op0, 0)) == PARM_DECL 8064169689Skan || TREE_CODE (TREE_OPERAND (op0, 0)) == LABEL_DECL 8065169689Skan || !DECL_WEAK (TREE_OPERAND (op0, 0)))) 8066169689Skan warning (OPT_Waddress, "the address of %qD will never be NULL", 8067169689Skan TREE_OPERAND (op0, 0)); 8068169689Skan result_type = type0; 8069169689Skan } 8070169689Skan else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0)) 8071169689Skan { 8072169689Skan if (TREE_CODE (op1) == ADDR_EXPR 8073169689Skan && DECL_P (TREE_OPERAND (op1, 0)) 8074169689Skan && (TREE_CODE (TREE_OPERAND (op1, 0)) == PARM_DECL 8075169689Skan || TREE_CODE (TREE_OPERAND (op1, 0)) == LABEL_DECL 8076169689Skan || !DECL_WEAK (TREE_OPERAND (op1, 0)))) 8077169689Skan warning (OPT_Waddress, "the address of %qD will never be NULL", 8078169689Skan TREE_OPERAND (op1, 0)); 8079169689Skan result_type = type1; 8080169689Skan } 8081132718Skan else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 8082132718Skan { 8083132718Skan result_type = type0; 8084132718Skan pedwarn ("comparison between pointer and integer"); 8085132718Skan } 8086132718Skan else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE) 8087132718Skan { 8088132718Skan result_type = type1; 8089132718Skan pedwarn ("comparison between pointer and integer"); 8090132718Skan } 8091132718Skan break; 8092132718Skan 8093132718Skan case LE_EXPR: 8094132718Skan case GE_EXPR: 8095132718Skan case LT_EXPR: 8096132718Skan case GT_EXPR: 8097132718Skan build_type = integer_type_node; 8098132718Skan if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE) 8099132718Skan && (code1 == INTEGER_TYPE || code1 == REAL_TYPE)) 8100132718Skan short_compare = 1; 8101132718Skan else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE) 8102132718Skan { 8103169689Skan if (comp_target_types (type0, type1)) 8104132718Skan { 8105169689Skan result_type = common_pointer_type (type0, type1); 8106132718Skan if (!COMPLETE_TYPE_P (TREE_TYPE (type0)) 8107132718Skan != !COMPLETE_TYPE_P (TREE_TYPE (type1))) 8108132718Skan pedwarn ("comparison of complete and incomplete pointers"); 8109132718Skan else if (pedantic 8110132718Skan && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE) 8111132718Skan pedwarn ("ISO C forbids ordered comparisons of pointers to functions"); 8112132718Skan } 8113132718Skan else 8114132718Skan { 8115132718Skan result_type = ptr_type_node; 8116132718Skan pedwarn ("comparison of distinct pointer types lacks a cast"); 8117132718Skan } 8118132718Skan } 8119169689Skan else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1)) 8120132718Skan { 8121132718Skan result_type = type0; 8122132718Skan if (pedantic || extra_warnings) 8123132718Skan pedwarn ("ordered comparison of pointer with integer zero"); 8124132718Skan } 8125169689Skan else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0)) 8126132718Skan { 8127132718Skan result_type = type1; 8128132718Skan if (pedantic) 8129132718Skan pedwarn ("ordered comparison of pointer with integer zero"); 8130132718Skan } 8131132718Skan else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 8132132718Skan { 8133132718Skan result_type = type0; 8134132718Skan pedwarn ("comparison between pointer and integer"); 8135132718Skan } 8136132718Skan else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE) 8137132718Skan { 8138132718Skan result_type = type1; 8139132718Skan pedwarn ("comparison between pointer and integer"); 8140132718Skan } 8141132718Skan break; 8142132718Skan 8143132718Skan default: 8144169689Skan gcc_unreachable (); 8145132718Skan } 8146132718Skan 8147169689Skan if (code0 == ERROR_MARK || code1 == ERROR_MARK) 8148169689Skan return error_mark_node; 8149169689Skan 8150169689Skan if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE 8151169689Skan && (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1)) 8152169689Skan || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0), 8153169689Skan TREE_TYPE (type1)))) 8154169689Skan { 8155259948Spfg binary_op_error (code, type0, type1); 8156169689Skan return error_mark_node; 8157169689Skan } 8158169689Skan 8159132718Skan if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE 8160132718Skan || code0 == VECTOR_TYPE) 8161132718Skan && 8162132718Skan (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE 8163132718Skan || code1 == VECTOR_TYPE)) 8164132718Skan { 8165132718Skan int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE); 8166132718Skan 8167132718Skan if (shorten || common || short_compare) 8168169689Skan result_type = c_common_type (type0, type1); 8169132718Skan 8170132718Skan /* For certain operations (which identify themselves by shorten != 0) 8171132718Skan if both args were extended from the same smaller type, 8172132718Skan do the arithmetic in that type and then extend. 8173132718Skan 8174132718Skan shorten !=0 and !=1 indicates a bitwise operation. 8175132718Skan For them, this optimization is safe only if 8176132718Skan both args are zero-extended or both are sign-extended. 8177132718Skan Otherwise, we might change the result. 8178132718Skan Eg, (short)-1 | (unsigned short)-1 is (int)-1 8179132718Skan but calculated in (unsigned short) it would be (unsigned short)-1. */ 8180132718Skan 8181132718Skan if (shorten && none_complex) 8182132718Skan { 8183132718Skan int unsigned0, unsigned1; 8184169689Skan tree arg0, arg1; 8185169689Skan int uns; 8186132718Skan tree type; 8187132718Skan 8188169689Skan /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents 8189169689Skan excessive narrowing when we call get_narrower below. For 8190169689Skan example, suppose that OP0 is of unsigned int extended 8191169689Skan from signed char and that RESULT_TYPE is long long int. 8192169689Skan If we explicitly cast OP0 to RESULT_TYPE, OP0 would look 8193169689Skan like 8194169689Skan 8195169689Skan (long long int) (unsigned int) signed_char 8196169689Skan 8197169689Skan which get_narrower would narrow down to 8198169689Skan 8199169689Skan (unsigned int) signed char 8200169689Skan 8201169689Skan If we do not cast OP0 first, get_narrower would return 8202169689Skan signed_char, which is inconsistent with the case of the 8203169689Skan explicit cast. */ 8204169689Skan op0 = convert (result_type, op0); 8205169689Skan op1 = convert (result_type, op1); 8206169689Skan 8207169689Skan arg0 = get_narrower (op0, &unsigned0); 8208169689Skan arg1 = get_narrower (op1, &unsigned1); 8209169689Skan 8210169689Skan /* UNS is 1 if the operation to be done is an unsigned one. */ 8211169689Skan uns = TYPE_UNSIGNED (result_type); 8212169689Skan 8213132718Skan final_type = result_type; 8214132718Skan 8215132718Skan /* Handle the case that OP0 (or OP1) does not *contain* a conversion 8216132718Skan but it *requires* conversion to FINAL_TYPE. */ 8217132718Skan 8218132718Skan if ((TYPE_PRECISION (TREE_TYPE (op0)) 8219132718Skan == TYPE_PRECISION (TREE_TYPE (arg0))) 8220132718Skan && TREE_TYPE (op0) != final_type) 8221169689Skan unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0)); 8222132718Skan if ((TYPE_PRECISION (TREE_TYPE (op1)) 8223132718Skan == TYPE_PRECISION (TREE_TYPE (arg1))) 8224132718Skan && TREE_TYPE (op1) != final_type) 8225169689Skan unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1)); 8226132718Skan 8227132718Skan /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */ 8228132718Skan 8229132718Skan /* For bitwise operations, signedness of nominal type 8230132718Skan does not matter. Consider only how operands were extended. */ 8231132718Skan if (shorten == -1) 8232132718Skan uns = unsigned0; 8233132718Skan 8234132718Skan /* Note that in all three cases below we refrain from optimizing 8235132718Skan an unsigned operation on sign-extended args. 8236132718Skan That would not be valid. */ 8237132718Skan 8238132718Skan /* Both args variable: if both extended in same way 8239132718Skan from same width, do it in that width. 8240132718Skan Do it unsigned if args were zero-extended. */ 8241132718Skan if ((TYPE_PRECISION (TREE_TYPE (arg0)) 8242132718Skan < TYPE_PRECISION (result_type)) 8243132718Skan && (TYPE_PRECISION (TREE_TYPE (arg1)) 8244132718Skan == TYPE_PRECISION (TREE_TYPE (arg0))) 8245132718Skan && unsigned0 == unsigned1 8246132718Skan && (unsigned0 || !uns)) 8247132718Skan result_type 8248132718Skan = c_common_signed_or_unsigned_type 8249132718Skan (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1))); 8250132718Skan else if (TREE_CODE (arg0) == INTEGER_CST 8251132718Skan && (unsigned1 || !uns) 8252132718Skan && (TYPE_PRECISION (TREE_TYPE (arg1)) 8253132718Skan < TYPE_PRECISION (result_type)) 8254132718Skan && (type 8255132718Skan = c_common_signed_or_unsigned_type (unsigned1, 8256132718Skan TREE_TYPE (arg1)), 8257132718Skan int_fits_type_p (arg0, type))) 8258132718Skan result_type = type; 8259132718Skan else if (TREE_CODE (arg1) == INTEGER_CST 8260132718Skan && (unsigned0 || !uns) 8261132718Skan && (TYPE_PRECISION (TREE_TYPE (arg0)) 8262132718Skan < TYPE_PRECISION (result_type)) 8263132718Skan && (type 8264132718Skan = c_common_signed_or_unsigned_type (unsigned0, 8265132718Skan TREE_TYPE (arg0)), 8266132718Skan int_fits_type_p (arg1, type))) 8267132718Skan result_type = type; 8268132718Skan } 8269132718Skan 8270132718Skan /* Shifts can be shortened if shifting right. */ 8271132718Skan 8272132718Skan if (short_shift) 8273132718Skan { 8274132718Skan int unsigned_arg; 8275132718Skan tree arg0 = get_narrower (op0, &unsigned_arg); 8276132718Skan 8277132718Skan final_type = result_type; 8278132718Skan 8279132718Skan if (arg0 == op0 && final_type == TREE_TYPE (op0)) 8280169689Skan unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0)); 8281132718Skan 8282132718Skan if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type) 8283132718Skan /* We can shorten only if the shift count is less than the 8284132718Skan number of bits in the smaller type size. */ 8285132718Skan && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0 8286132718Skan /* We cannot drop an unsigned shift after sign-extension. */ 8287169689Skan && (!TYPE_UNSIGNED (final_type) || unsigned_arg)) 8288132718Skan { 8289132718Skan /* Do an unsigned shift if the operand was zero-extended. */ 8290132718Skan result_type 8291132718Skan = c_common_signed_or_unsigned_type (unsigned_arg, 8292132718Skan TREE_TYPE (arg0)); 8293132718Skan /* Convert value-to-be-shifted to that type. */ 8294132718Skan if (TREE_TYPE (op0) != result_type) 8295132718Skan op0 = convert (result_type, op0); 8296132718Skan converted = 1; 8297132718Skan } 8298132718Skan } 8299132718Skan 8300132718Skan /* Comparison operations are shortened too but differently. 8301132718Skan They identify themselves by setting short_compare = 1. */ 8302132718Skan 8303132718Skan if (short_compare) 8304132718Skan { 8305132718Skan /* Don't write &op0, etc., because that would prevent op0 8306132718Skan from being kept in a register. 8307132718Skan Instead, make copies of the our local variables and 8308132718Skan pass the copies by reference, then copy them back afterward. */ 8309132718Skan tree xop0 = op0, xop1 = op1, xresult_type = result_type; 8310132718Skan enum tree_code xresultcode = resultcode; 8311132718Skan tree val 8312132718Skan = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode); 8313132718Skan 8314132718Skan if (val != 0) 8315132718Skan return val; 8316132718Skan 8317132718Skan op0 = xop0, op1 = xop1; 8318132718Skan converted = 1; 8319132718Skan resultcode = xresultcode; 8320132718Skan 8321132718Skan if (warn_sign_compare && skip_evaluation == 0) 8322132718Skan { 8323169689Skan int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0)); 8324169689Skan int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1)); 8325132718Skan int unsignedp0, unsignedp1; 8326132718Skan tree primop0 = get_narrower (op0, &unsignedp0); 8327132718Skan tree primop1 = get_narrower (op1, &unsignedp1); 8328132718Skan 8329132718Skan xop0 = orig_op0; 8330132718Skan xop1 = orig_op1; 8331132718Skan STRIP_TYPE_NOPS (xop0); 8332132718Skan STRIP_TYPE_NOPS (xop1); 8333132718Skan 8334132718Skan /* Give warnings for comparisons between signed and unsigned 8335132718Skan quantities that may fail. 8336132718Skan 8337132718Skan Do the checking based on the original operand trees, so that 8338132718Skan casts will be considered, but default promotions won't be. 8339132718Skan 8340132718Skan Do not warn if the comparison is being done in a signed type, 8341132718Skan since the signed type will only be chosen if it can represent 8342132718Skan all the values of the unsigned type. */ 8343169689Skan if (!TYPE_UNSIGNED (result_type)) 8344132718Skan /* OK */; 8345169689Skan /* Do not warn if both operands are the same signedness. */ 8346169689Skan else if (op0_signed == op1_signed) 8347169689Skan /* OK */; 8348132718Skan else 8349132718Skan { 8350132718Skan tree sop, uop; 8351169689Skan bool ovf; 8352132718Skan 8353132718Skan if (op0_signed) 8354132718Skan sop = xop0, uop = xop1; 8355132718Skan else 8356132718Skan sop = xop1, uop = xop0; 8357132718Skan 8358132718Skan /* Do not warn if the signed quantity is an 8359132718Skan unsuffixed integer literal (or some static 8360132718Skan constant expression involving such literals or a 8361132718Skan conditional expression involving such literals) 8362132718Skan and it is non-negative. */ 8363169689Skan if (tree_expr_nonnegative_warnv_p (sop, &ovf)) 8364132718Skan /* OK */; 8365132718Skan /* Do not warn if the comparison is an equality operation, 8366132718Skan the unsigned quantity is an integral constant, and it 8367132718Skan would fit in the result if the result were signed. */ 8368132718Skan else if (TREE_CODE (uop) == INTEGER_CST 8369132718Skan && (resultcode == EQ_EXPR || resultcode == NE_EXPR) 8370132718Skan && int_fits_type_p 8371132718Skan (uop, c_common_signed_type (result_type))) 8372132718Skan /* OK */; 8373132718Skan /* Do not warn if the unsigned quantity is an enumeration 8374132718Skan constant and its maximum value would fit in the result 8375132718Skan if the result were signed. */ 8376132718Skan else if (TREE_CODE (uop) == INTEGER_CST 8377132718Skan && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE 8378132718Skan && int_fits_type_p 8379169689Skan (TYPE_MAX_VALUE (TREE_TYPE (uop)), 8380132718Skan c_common_signed_type (result_type))) 8381132718Skan /* OK */; 8382132718Skan else 8383169689Skan warning (0, "comparison between signed and unsigned"); 8384132718Skan } 8385132718Skan 8386132718Skan /* Warn if two unsigned values are being compared in a size 8387132718Skan larger than their original size, and one (and only one) is the 8388132718Skan result of a `~' operator. This comparison will always fail. 8389132718Skan 8390132718Skan Also warn if one operand is a constant, and the constant 8391132718Skan does not have all bits set that are set in the ~ operand 8392132718Skan when it is extended. */ 8393132718Skan 8394132718Skan if ((TREE_CODE (primop0) == BIT_NOT_EXPR) 8395132718Skan != (TREE_CODE (primop1) == BIT_NOT_EXPR)) 8396132718Skan { 8397132718Skan if (TREE_CODE (primop0) == BIT_NOT_EXPR) 8398132718Skan primop0 = get_narrower (TREE_OPERAND (primop0, 0), 8399132718Skan &unsignedp0); 8400132718Skan else 8401132718Skan primop1 = get_narrower (TREE_OPERAND (primop1, 0), 8402132718Skan &unsignedp1); 8403132718Skan 8404132718Skan if (host_integerp (primop0, 0) || host_integerp (primop1, 0)) 8405132718Skan { 8406132718Skan tree primop; 8407132718Skan HOST_WIDE_INT constant, mask; 8408132718Skan int unsignedp, bits; 8409132718Skan 8410132718Skan if (host_integerp (primop0, 0)) 8411132718Skan { 8412132718Skan primop = primop1; 8413132718Skan unsignedp = unsignedp1; 8414132718Skan constant = tree_low_cst (primop0, 0); 8415132718Skan } 8416132718Skan else 8417132718Skan { 8418132718Skan primop = primop0; 8419132718Skan unsignedp = unsignedp0; 8420132718Skan constant = tree_low_cst (primop1, 0); 8421132718Skan } 8422132718Skan 8423132718Skan bits = TYPE_PRECISION (TREE_TYPE (primop)); 8424132718Skan if (bits < TYPE_PRECISION (result_type) 8425132718Skan && bits < HOST_BITS_PER_WIDE_INT && unsignedp) 8426132718Skan { 8427169689Skan mask = (~(HOST_WIDE_INT) 0) << bits; 8428132718Skan if ((mask & constant) != mask) 8429169689Skan warning (0, "comparison of promoted ~unsigned with constant"); 8430132718Skan } 8431132718Skan } 8432132718Skan else if (unsignedp0 && unsignedp1 8433132718Skan && (TYPE_PRECISION (TREE_TYPE (primop0)) 8434132718Skan < TYPE_PRECISION (result_type)) 8435132718Skan && (TYPE_PRECISION (TREE_TYPE (primop1)) 8436132718Skan < TYPE_PRECISION (result_type))) 8437169689Skan warning (0, "comparison of promoted ~unsigned with unsigned"); 8438132718Skan } 8439132718Skan } 8440132718Skan } 8441132718Skan } 8442132718Skan 8443132718Skan /* At this point, RESULT_TYPE must be nonzero to avoid an error message. 8444132718Skan If CONVERTED is zero, both args will be converted to type RESULT_TYPE. 8445132718Skan Then the expression will be built. 8446132718Skan It will be given type FINAL_TYPE if that is nonzero; 8447132718Skan otherwise, it will be given type RESULT_TYPE. */ 8448132718Skan 8449132718Skan if (!result_type) 8450132718Skan { 8451259948Spfg binary_op_error (code, TREE_TYPE (op0), TREE_TYPE (op1)); 8452132718Skan return error_mark_node; 8453132718Skan } 8454132718Skan 8455169689Skan if (!converted) 8456132718Skan { 8457132718Skan if (TREE_TYPE (op0) != result_type) 8458169689Skan op0 = convert_and_check (result_type, op0); 8459132718Skan if (TREE_TYPE (op1) != result_type) 8460169689Skan op1 = convert_and_check (result_type, op1); 8461169689Skan 8462169689Skan /* This can happen if one operand has a vector type, and the other 8463169689Skan has a different type. */ 8464169689Skan if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK) 8465169689Skan return error_mark_node; 8466132718Skan } 8467132718Skan 8468132718Skan if (build_type == NULL_TREE) 8469132718Skan build_type = result_type; 8470132718Skan 8471132718Skan { 8472169689Skan /* Treat expressions in initializers specially as they can't trap. */ 8473169689Skan tree result = require_constant_value ? fold_build2_initializer (resultcode, 8474169689Skan build_type, 8475169689Skan op0, op1) 8476169689Skan : fold_build2 (resultcode, build_type, 8477169689Skan op0, op1); 8478132718Skan 8479132718Skan if (final_type != 0) 8480169689Skan result = convert (final_type, result); 8481169689Skan return result; 8482132718Skan } 8483132718Skan} 8484169689Skan 8485169689Skan 8486169689Skan/* Convert EXPR to be a truth-value, validating its type for this 8487169689Skan purpose. */ 8488169689Skan 8489169689Skantree 8490169689Skanc_objc_common_truthvalue_conversion (tree expr) 8491169689Skan{ 8492169689Skan switch (TREE_CODE (TREE_TYPE (expr))) 8493169689Skan { 8494169689Skan case ARRAY_TYPE: 8495169689Skan error ("used array that cannot be converted to pointer where scalar is required"); 8496169689Skan return error_mark_node; 8497169689Skan 8498169689Skan case RECORD_TYPE: 8499169689Skan error ("used struct type value where scalar is required"); 8500169689Skan return error_mark_node; 8501169689Skan 8502169689Skan case UNION_TYPE: 8503169689Skan error ("used union type value where scalar is required"); 8504169689Skan return error_mark_node; 8505169689Skan 8506169689Skan case FUNCTION_TYPE: 8507169689Skan gcc_unreachable (); 8508169689Skan 8509169689Skan default: 8510169689Skan break; 8511169689Skan } 8512169689Skan 8513169689Skan /* ??? Should we also give an error for void and vectors rather than 8514169689Skan leaving those to give errors later? */ 8515169689Skan return c_common_truthvalue_conversion (expr); 8516169689Skan} 8517169689Skan 8518169689Skan 8519169689Skan/* Convert EXPR to a contained DECL, updating *TC, *TI and *SE as 8520169689Skan required. */ 8521169689Skan 8522169689Skantree 8523169689Skanc_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, 8524169689Skan bool *ti ATTRIBUTE_UNUSED, bool *se) 8525169689Skan{ 8526169689Skan if (TREE_CODE (expr) == COMPOUND_LITERAL_EXPR) 8527169689Skan { 8528169689Skan tree decl = COMPOUND_LITERAL_EXPR_DECL (expr); 8529169689Skan /* Executing a compound literal inside a function reinitializes 8530169689Skan it. */ 8531169689Skan if (!TREE_STATIC (decl)) 8532169689Skan *se = true; 8533169689Skan return decl; 8534169689Skan } 8535169689Skan else 8536169689Skan return expr; 8537169689Skan} 8538169689Skan 8539169689Skan/* Like c_begin_compound_stmt, except force the retention of the BLOCK. */ 8540169689Skan 8541169689Skantree 8542169689Skanc_begin_omp_parallel (void) 8543169689Skan{ 8544169689Skan tree block; 8545169689Skan 8546169689Skan keep_next_level (); 8547169689Skan block = c_begin_compound_stmt (true); 8548169689Skan 8549169689Skan return block; 8550169689Skan} 8551169689Skan 8552169689Skantree 8553169689Skanc_finish_omp_parallel (tree clauses, tree block) 8554169689Skan{ 8555169689Skan tree stmt; 8556169689Skan 8557169689Skan block = c_end_compound_stmt (block, true); 8558169689Skan 8559169689Skan stmt = make_node (OMP_PARALLEL); 8560169689Skan TREE_TYPE (stmt) = void_type_node; 8561169689Skan OMP_PARALLEL_CLAUSES (stmt) = clauses; 8562169689Skan OMP_PARALLEL_BODY (stmt) = block; 8563169689Skan 8564169689Skan return add_stmt (stmt); 8565169689Skan} 8566169689Skan 8567169689Skan/* For all elements of CLAUSES, validate them vs OpenMP constraints. 8568169689Skan Remove any elements from the list that are invalid. */ 8569169689Skan 8570169689Skantree 8571169689Skanc_finish_omp_clauses (tree clauses) 8572169689Skan{ 8573169689Skan bitmap_head generic_head, firstprivate_head, lastprivate_head; 8574169689Skan tree c, t, *pc = &clauses; 8575169689Skan const char *name; 8576169689Skan 8577169689Skan bitmap_obstack_initialize (NULL); 8578169689Skan bitmap_initialize (&generic_head, &bitmap_default_obstack); 8579169689Skan bitmap_initialize (&firstprivate_head, &bitmap_default_obstack); 8580169689Skan bitmap_initialize (&lastprivate_head, &bitmap_default_obstack); 8581169689Skan 8582169689Skan for (pc = &clauses, c = clauses; c ; c = *pc) 8583169689Skan { 8584169689Skan bool remove = false; 8585169689Skan bool need_complete = false; 8586169689Skan bool need_implicitly_determined = false; 8587169689Skan 8588169689Skan switch (OMP_CLAUSE_CODE (c)) 8589169689Skan { 8590169689Skan case OMP_CLAUSE_SHARED: 8591169689Skan name = "shared"; 8592169689Skan need_implicitly_determined = true; 8593169689Skan goto check_dup_generic; 8594169689Skan 8595169689Skan case OMP_CLAUSE_PRIVATE: 8596169689Skan name = "private"; 8597169689Skan need_complete = true; 8598169689Skan need_implicitly_determined = true; 8599169689Skan goto check_dup_generic; 8600169689Skan 8601169689Skan case OMP_CLAUSE_REDUCTION: 8602169689Skan name = "reduction"; 8603169689Skan need_implicitly_determined = true; 8604169689Skan t = OMP_CLAUSE_DECL (c); 8605169689Skan if (AGGREGATE_TYPE_P (TREE_TYPE (t)) 8606169689Skan || POINTER_TYPE_P (TREE_TYPE (t))) 8607169689Skan { 8608169689Skan error ("%qE has invalid type for %<reduction%>", t); 8609169689Skan remove = true; 8610169689Skan } 8611169689Skan else if (FLOAT_TYPE_P (TREE_TYPE (t))) 8612169689Skan { 8613169689Skan enum tree_code r_code = OMP_CLAUSE_REDUCTION_CODE (c); 8614169689Skan const char *r_name = NULL; 8615169689Skan 8616169689Skan switch (r_code) 8617169689Skan { 8618169689Skan case PLUS_EXPR: 8619169689Skan case MULT_EXPR: 8620169689Skan case MINUS_EXPR: 8621169689Skan break; 8622169689Skan case BIT_AND_EXPR: 8623169689Skan r_name = "&"; 8624169689Skan break; 8625169689Skan case BIT_XOR_EXPR: 8626169689Skan r_name = "^"; 8627169689Skan break; 8628169689Skan case BIT_IOR_EXPR: 8629169689Skan r_name = "|"; 8630169689Skan break; 8631169689Skan case TRUTH_ANDIF_EXPR: 8632169689Skan r_name = "&&"; 8633169689Skan break; 8634169689Skan case TRUTH_ORIF_EXPR: 8635169689Skan r_name = "||"; 8636169689Skan break; 8637169689Skan default: 8638169689Skan gcc_unreachable (); 8639169689Skan } 8640169689Skan if (r_name) 8641169689Skan { 8642169689Skan error ("%qE has invalid type for %<reduction(%s)%>", 8643169689Skan t, r_name); 8644169689Skan remove = true; 8645169689Skan } 8646169689Skan } 8647169689Skan goto check_dup_generic; 8648169689Skan 8649169689Skan case OMP_CLAUSE_COPYPRIVATE: 8650169689Skan name = "copyprivate"; 8651169689Skan goto check_dup_generic; 8652169689Skan 8653169689Skan case OMP_CLAUSE_COPYIN: 8654169689Skan name = "copyin"; 8655169689Skan t = OMP_CLAUSE_DECL (c); 8656169689Skan if (TREE_CODE (t) != VAR_DECL || !DECL_THREAD_LOCAL_P (t)) 8657169689Skan { 8658169689Skan error ("%qE must be %<threadprivate%> for %<copyin%>", t); 8659169689Skan remove = true; 8660169689Skan } 8661169689Skan goto check_dup_generic; 8662169689Skan 8663169689Skan check_dup_generic: 8664169689Skan t = OMP_CLAUSE_DECL (c); 8665169689Skan if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL) 8666169689Skan { 8667169689Skan error ("%qE is not a variable in clause %qs", t, name); 8668169689Skan remove = true; 8669169689Skan } 8670169689Skan else if (bitmap_bit_p (&generic_head, DECL_UID (t)) 8671169689Skan || bitmap_bit_p (&firstprivate_head, DECL_UID (t)) 8672169689Skan || bitmap_bit_p (&lastprivate_head, DECL_UID (t))) 8673169689Skan { 8674169689Skan error ("%qE appears more than once in data clauses", t); 8675169689Skan remove = true; 8676169689Skan } 8677169689Skan else 8678169689Skan bitmap_set_bit (&generic_head, DECL_UID (t)); 8679169689Skan break; 8680169689Skan 8681169689Skan case OMP_CLAUSE_FIRSTPRIVATE: 8682169689Skan name = "firstprivate"; 8683169689Skan t = OMP_CLAUSE_DECL (c); 8684169689Skan need_complete = true; 8685169689Skan need_implicitly_determined = true; 8686169689Skan if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL) 8687169689Skan { 8688169689Skan error ("%qE is not a variable in clause %<firstprivate%>", t); 8689169689Skan remove = true; 8690169689Skan } 8691169689Skan else if (bitmap_bit_p (&generic_head, DECL_UID (t)) 8692169689Skan || bitmap_bit_p (&firstprivate_head, DECL_UID (t))) 8693169689Skan { 8694169689Skan error ("%qE appears more than once in data clauses", t); 8695169689Skan remove = true; 8696169689Skan } 8697169689Skan else 8698169689Skan bitmap_set_bit (&firstprivate_head, DECL_UID (t)); 8699169689Skan break; 8700169689Skan 8701169689Skan case OMP_CLAUSE_LASTPRIVATE: 8702169689Skan name = "lastprivate"; 8703169689Skan t = OMP_CLAUSE_DECL (c); 8704169689Skan need_complete = true; 8705169689Skan need_implicitly_determined = true; 8706169689Skan if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL) 8707169689Skan { 8708169689Skan error ("%qE is not a variable in clause %<lastprivate%>", t); 8709169689Skan remove = true; 8710169689Skan } 8711169689Skan else if (bitmap_bit_p (&generic_head, DECL_UID (t)) 8712169689Skan || bitmap_bit_p (&lastprivate_head, DECL_UID (t))) 8713169689Skan { 8714169689Skan error ("%qE appears more than once in data clauses", t); 8715169689Skan remove = true; 8716169689Skan } 8717169689Skan else 8718169689Skan bitmap_set_bit (&lastprivate_head, DECL_UID (t)); 8719169689Skan break; 8720169689Skan 8721169689Skan case OMP_CLAUSE_IF: 8722169689Skan case OMP_CLAUSE_NUM_THREADS: 8723169689Skan case OMP_CLAUSE_SCHEDULE: 8724169689Skan case OMP_CLAUSE_NOWAIT: 8725169689Skan case OMP_CLAUSE_ORDERED: 8726169689Skan case OMP_CLAUSE_DEFAULT: 8727169689Skan pc = &OMP_CLAUSE_CHAIN (c); 8728169689Skan continue; 8729169689Skan 8730169689Skan default: 8731169689Skan gcc_unreachable (); 8732169689Skan } 8733169689Skan 8734169689Skan if (!remove) 8735169689Skan { 8736169689Skan t = OMP_CLAUSE_DECL (c); 8737169689Skan 8738169689Skan if (need_complete) 8739169689Skan { 8740169689Skan t = require_complete_type (t); 8741169689Skan if (t == error_mark_node) 8742169689Skan remove = true; 8743169689Skan } 8744169689Skan 8745169689Skan if (need_implicitly_determined) 8746169689Skan { 8747169689Skan const char *share_name = NULL; 8748169689Skan 8749169689Skan if (TREE_CODE (t) == VAR_DECL && DECL_THREAD_LOCAL_P (t)) 8750169689Skan share_name = "threadprivate"; 8751169689Skan else switch (c_omp_predetermined_sharing (t)) 8752169689Skan { 8753169689Skan case OMP_CLAUSE_DEFAULT_UNSPECIFIED: 8754169689Skan break; 8755169689Skan case OMP_CLAUSE_DEFAULT_SHARED: 8756169689Skan share_name = "shared"; 8757169689Skan break; 8758169689Skan case OMP_CLAUSE_DEFAULT_PRIVATE: 8759169689Skan share_name = "private"; 8760169689Skan break; 8761169689Skan default: 8762169689Skan gcc_unreachable (); 8763169689Skan } 8764169689Skan if (share_name) 8765169689Skan { 8766169689Skan error ("%qE is predetermined %qs for %qs", 8767169689Skan t, share_name, name); 8768169689Skan remove = true; 8769169689Skan } 8770169689Skan } 8771169689Skan } 8772169689Skan 8773169689Skan if (remove) 8774169689Skan *pc = OMP_CLAUSE_CHAIN (c); 8775169689Skan else 8776169689Skan pc = &OMP_CLAUSE_CHAIN (c); 8777169689Skan } 8778169689Skan 8779169689Skan bitmap_obstack_release (NULL); 8780169689Skan return clauses; 8781169689Skan} 8782