c-typeck.c revision 169689
118334Speter/* Build expressions with type checking for C compiler. 2169689Skan Copyright (C) 1987, 1988, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 3169689Skan 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006 4169689Skan Free Software Foundation, Inc. 518334Speter 690075SobrienThis file is part of GCC. 718334Speter 890075SobrienGCC is free software; you can redistribute it and/or modify it under 990075Sobrienthe terms of the GNU General Public License as published by the Free 1090075SobrienSoftware Foundation; either version 2, or (at your option) any later 1190075Sobrienversion. 1218334Speter 1390075SobrienGCC is distributed in the hope that it will be useful, but WITHOUT ANY 1490075SobrienWARRANTY; without even the implied warranty of MERCHANTABILITY or 1590075SobrienFITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 1690075Sobrienfor more details. 1718334Speter 1818334SpeterYou should have received a copy of the GNU General Public License 1990075Sobrienalong with GCC; see the file COPYING. If not, write to the Free 20169689SkanSoftware Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 21169689Skan02110-1301, USA. */ 2218334Speter 2318334Speter 2418334Speter/* This file is part of the C front end. 2518334Speter It contains routines to build C expressions given their operands, 2618334Speter including computing the types of the result, C-specific error checks, 27169689Skan and some optimization. */ 2818334Speter 2918334Speter#include "config.h" 3050397Sobrien#include "system.h" 31132718Skan#include "coretypes.h" 32132718Skan#include "tm.h" 3390075Sobrien#include "rtl.h" 3418334Speter#include "tree.h" 35169689Skan#include "langhooks.h" 3618334Speter#include "c-tree.h" 3790075Sobrien#include "tm_p.h" 3818334Speter#include "flags.h" 3918334Speter#include "output.h" 4050397Sobrien#include "expr.h" 4150397Sobrien#include "toplev.h" 4252284Sobrien#include "intl.h" 4390075Sobrien#include "ggc.h" 4490075Sobrien#include "target.h" 45169689Skan#include "tree-iterator.h" 46169689Skan#include "tree-gimple.h" 47169689Skan#include "tree-flow.h" 4818334Speter 49169689Skan/* Possible cases of implicit bad conversions. Used to select 50169689Skan diagnostic messages in convert_for_assignment. */ 51169689Skanenum impl_conv { 52169689Skan ic_argpass, 53169689Skan ic_argpass_nonproto, 54169689Skan ic_assign, 55169689Skan ic_init, 56169689Skan ic_return 57169689Skan}; 58169689Skan 59169689Skan/* The level of nesting inside "__alignof__". */ 60169689Skanint in_alignof; 61169689Skan 62169689Skan/* The level of nesting inside "sizeof". */ 63169689Skanint in_sizeof; 64169689Skan 65169689Skan/* The level of nesting inside "typeof". */ 66169689Skanint in_typeof; 67169689Skan 68169689Skanstruct c_label_context_se *label_context_stack_se; 69169689Skanstruct c_label_context_vm *label_context_stack_vm; 70169689Skan 7118334Speter/* Nonzero if we've already printed a "missing braces around initializer" 7218334Speter message within this initializer. */ 7318334Speterstatic int missing_braces_mentioned; 7418334Speter 75132718Skanstatic int require_constant_value; 76132718Skanstatic int require_constant_elements; 7790075Sobrien 78169689Skanstatic bool null_pointer_constant_p (tree); 79132718Skanstatic tree qualify_type (tree, tree); 80169689Skanstatic int tagged_types_tu_compatible_p (tree, tree); 81169689Skanstatic int comp_target_types (tree, tree); 82169689Skanstatic int function_types_compatible_p (tree, tree); 83169689Skanstatic int type_lists_compatible_p (tree, tree); 84132718Skanstatic tree decl_constant_value_for_broken_optimization (tree); 85132718Skanstatic tree lookup_field (tree, tree); 86132718Skanstatic tree convert_arguments (tree, tree, tree, tree); 87132718Skanstatic tree pointer_diff (tree, tree); 88169689Skanstatic tree convert_for_assignment (tree, tree, enum impl_conv, tree, tree, 89132718Skan int); 90132718Skanstatic tree valid_compound_expr_initializer (tree, tree); 91132718Skanstatic void push_string (const char *); 92132718Skanstatic void push_member_name (tree); 93132718Skanstatic int spelling_length (void); 94132718Skanstatic char *print_spelling (char *); 95132718Skanstatic void warning_init (const char *); 96169689Skanstatic tree digest_init (tree, tree, bool, int); 97169689Skanstatic void output_init_element (tree, bool, tree, tree, int); 98132718Skanstatic void output_pending_init_elements (int); 99132718Skanstatic int set_designator (int); 100132718Skanstatic void push_range_stack (tree); 101132718Skanstatic void add_pending_init (tree, tree); 102132718Skanstatic void set_nonincremental_init (void); 103132718Skanstatic void set_nonincremental_init_from_string (tree); 104132718Skanstatic tree find_init_member (tree); 105169689Skanstatic void readonly_error (tree, enum lvalue_use); 106169689Skanstatic int lvalue_or_else (tree, enum lvalue_use); 107169689Skanstatic int lvalue_p (tree); 108169689Skanstatic void record_maybe_used_decl (tree); 109169689Skanstatic int comptypes_internal (tree, tree); 11018334Speter 111169689Skan/* Return true if EXP is a null pointer constant, false otherwise. */ 112169689Skan 113169689Skanstatic bool 114169689Skannull_pointer_constant_p (tree expr) 115169689Skan{ 116169689Skan /* This should really operate on c_expr structures, but they aren't 117169689Skan yet available everywhere required. */ 118169689Skan tree type = TREE_TYPE (expr); 119169689Skan return (TREE_CODE (expr) == INTEGER_CST 120169689Skan && !TREE_CONSTANT_OVERFLOW (expr) 121169689Skan && integer_zerop (expr) 122169689Skan && (INTEGRAL_TYPE_P (type) 123169689Skan || (TREE_CODE (type) == POINTER_TYPE 124169689Skan && VOID_TYPE_P (TREE_TYPE (type)) 125169689Skan && TYPE_QUALS (TREE_TYPE (type)) == TYPE_UNQUALIFIED))); 126169689Skan} 127169689Skan/* This is a cache to hold if two types are compatible or not. */ 128169689Skan 129169689Skanstruct tagged_tu_seen_cache { 130169689Skan const struct tagged_tu_seen_cache * next; 131169689Skan tree t1; 132169689Skan tree t2; 133169689Skan /* The return value of tagged_types_tu_compatible_p if we had seen 134169689Skan these two types already. */ 135169689Skan int val; 136169689Skan}; 137169689Skan 138169689Skanstatic const struct tagged_tu_seen_cache * tagged_tu_seen_base; 139169689Skanstatic void free_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache *); 140169689Skan 14118334Speter/* Do `exp = require_complete_type (exp);' to make sure exp 14218334Speter does not have an incomplete type. (That includes void types.) */ 14318334Speter 14418334Spetertree 145132718Skanrequire_complete_type (tree value) 14618334Speter{ 14718334Speter tree type = TREE_TYPE (value); 14818334Speter 14990075Sobrien if (value == error_mark_node || type == error_mark_node) 15052284Sobrien return error_mark_node; 15152284Sobrien 15218334Speter /* First, detect a valid value with a complete type. */ 15390075Sobrien if (COMPLETE_TYPE_P (type)) 15418334Speter return value; 15518334Speter 156117395Skan c_incomplete_type_error (value, type); 15718334Speter return error_mark_node; 15818334Speter} 15918334Speter 16018334Speter/* Print an error message for invalid use of an incomplete type. 16118334Speter VALUE is the expression that was used (or 0 if that isn't known) 16218334Speter and TYPE is the type that was invalid. */ 16318334Speter 16418334Spetervoid 165132718Skanc_incomplete_type_error (tree value, tree type) 16618334Speter{ 16752284Sobrien const char *type_code_string; 16818334Speter 16918334Speter /* Avoid duplicate error message. */ 17018334Speter if (TREE_CODE (type) == ERROR_MARK) 17118334Speter return; 17218334Speter 17318334Speter if (value != 0 && (TREE_CODE (value) == VAR_DECL 17418334Speter || TREE_CODE (value) == PARM_DECL)) 175169689Skan error ("%qD has an incomplete type", value); 17618334Speter else 17718334Speter { 17818334Speter retry: 17918334Speter /* We must print an error message. Be clever about what it says. */ 18018334Speter 18118334Speter switch (TREE_CODE (type)) 18218334Speter { 18318334Speter case RECORD_TYPE: 18452284Sobrien type_code_string = "struct"; 18518334Speter break; 18618334Speter 18718334Speter case UNION_TYPE: 18852284Sobrien type_code_string = "union"; 18918334Speter break; 19018334Speter 19118334Speter case ENUMERAL_TYPE: 19252284Sobrien type_code_string = "enum"; 19318334Speter break; 19418334Speter 19518334Speter case VOID_TYPE: 19618334Speter error ("invalid use of void expression"); 19718334Speter return; 19818334Speter 19918334Speter case ARRAY_TYPE: 20018334Speter if (TYPE_DOMAIN (type)) 20118334Speter { 20296263Sobrien if (TYPE_MAX_VALUE (TYPE_DOMAIN (type)) == NULL) 20396263Sobrien { 20496263Sobrien error ("invalid use of flexible array member"); 20596263Sobrien return; 20696263Sobrien } 20718334Speter type = TREE_TYPE (type); 20818334Speter goto retry; 20918334Speter } 21018334Speter error ("invalid use of array with unspecified bounds"); 21118334Speter return; 21218334Speter 21318334Speter default: 214169689Skan gcc_unreachable (); 21518334Speter } 21618334Speter 21718334Speter if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE) 218169689Skan error ("invalid use of undefined type %<%s %E%>", 219169689Skan type_code_string, TYPE_NAME (type)); 22018334Speter else 22118334Speter /* If this type has a typedef-name, the TYPE_NAME is a TYPE_DECL. */ 222169689Skan error ("invalid use of incomplete typedef %qD", TYPE_NAME (type)); 22318334Speter } 22418334Speter} 22518334Speter 226117395Skan/* Given a type, apply default promotions wrt unnamed function 227117395Skan arguments and return the new type. */ 228117395Skan 229117395Skantree 230132718Skanc_type_promotes_to (tree type) 231117395Skan{ 232117395Skan if (TYPE_MAIN_VARIANT (type) == float_type_node) 233117395Skan return double_type_node; 234117395Skan 235117395Skan if (c_promoting_integer_type_p (type)) 236117395Skan { 237117395Skan /* Preserve unsignedness if not really getting any wider. */ 238169689Skan if (TYPE_UNSIGNED (type) 239169689Skan && (TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node))) 240169689Skan return unsigned_type_node; 241117395Skan return integer_type_node; 242117395Skan } 243117395Skan 244117395Skan return type; 245117395Skan} 246117395Skan 24718334Speter/* Return a variant of TYPE which has all the type qualifiers of LIKE 24818334Speter as well as those of TYPE. */ 24918334Speter 25018334Speterstatic tree 251132718Skanqualify_type (tree type, tree like) 25218334Speter{ 253132718Skan return c_build_qualified_type (type, 25452750Sobrien TYPE_QUALS (type) | TYPE_QUALS (like)); 25518334Speter} 256169689Skan 257169689Skan/* Return true iff the given tree T is a variable length array. */ 258169689Skan 259169689Skanbool 260169689Skanc_vla_type_p (tree t) 261169689Skan{ 262169689Skan if (TREE_CODE (t) == ARRAY_TYPE 263169689Skan && C_TYPE_VARIABLE_SIZE (t)) 264169689Skan return true; 265169689Skan return false; 266169689Skan} 26718334Speter 268169689Skan/* Return the composite type of two compatible types. 26918334Speter 270169689Skan We assume that comptypes has already been done and returned 271169689Skan nonzero; if that isn't so, this may crash. In particular, we 272169689Skan assume that qualifiers match. */ 27318334Speter 27418334Spetertree 275169689Skancomposite_type (tree t1, tree t2) 27618334Speter{ 27790075Sobrien enum tree_code code1; 27890075Sobrien enum tree_code code2; 27918334Speter tree attributes; 28018334Speter 28118334Speter /* Save time if the two types are the same. */ 28218334Speter 28318334Speter if (t1 == t2) return t1; 28418334Speter 28518334Speter /* If one type is nonsense, use the other. */ 28618334Speter if (t1 == error_mark_node) 28718334Speter return t2; 28818334Speter if (t2 == error_mark_node) 28918334Speter return t1; 29018334Speter 291169689Skan code1 = TREE_CODE (t1); 292169689Skan code2 = TREE_CODE (t2); 293169689Skan 29450397Sobrien /* Merge the attributes. */ 295169689Skan attributes = targetm.merge_type_attributes (t1, t2); 29618334Speter 297169689Skan /* If one is an enumerated type and the other is the compatible 298169689Skan integer type, the composite type might be either of the two 299169689Skan (DR#013 question 3). For consistency, use the enumerated type as 300169689Skan the composite type. */ 30118334Speter 302169689Skan if (code1 == ENUMERAL_TYPE && code2 == INTEGER_TYPE) 303169689Skan return t1; 304169689Skan if (code2 == ENUMERAL_TYPE && code1 == INTEGER_TYPE) 305169689Skan return t2; 30618334Speter 307169689Skan gcc_assert (code1 == code2); 30818334Speter 30918334Speter switch (code1) 31018334Speter { 31118334Speter case POINTER_TYPE: 312169689Skan /* For two pointers, do this recursively on the target type. */ 31318334Speter { 31452284Sobrien tree pointed_to_1 = TREE_TYPE (t1); 31552284Sobrien tree pointed_to_2 = TREE_TYPE (t2); 316169689Skan tree target = composite_type (pointed_to_1, pointed_to_2); 317169689Skan t1 = build_pointer_type (target); 318169689Skan t1 = build_type_attribute_variant (t1, attributes); 319169689Skan return qualify_type (t1, t2); 32018334Speter } 32118334Speter 32218334Speter case ARRAY_TYPE: 32318334Speter { 324169689Skan tree elt = composite_type (TREE_TYPE (t1), TREE_TYPE (t2)); 325169689Skan int quals; 326169689Skan tree unqual_elt; 327169689Skan tree d1 = TYPE_DOMAIN (t1); 328169689Skan tree d2 = TYPE_DOMAIN (t2); 329169689Skan bool d1_variable, d2_variable; 330169689Skan bool d1_zero, d2_zero; 331169689Skan 332169689Skan /* We should not have any type quals on arrays at all. */ 333169689Skan gcc_assert (!TYPE_QUALS (t1) && !TYPE_QUALS (t2)); 334169689Skan 335169689Skan d1_zero = d1 == 0 || !TYPE_MAX_VALUE (d1); 336169689Skan d2_zero = d2 == 0 || !TYPE_MAX_VALUE (d2); 337169689Skan 338169689Skan d1_variable = (!d1_zero 339169689Skan && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST 340169689Skan || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST)); 341169689Skan d2_variable = (!d2_zero 342169689Skan && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST 343169689Skan || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST)); 344169689Skan d1_variable = d1_variable || (d1_zero && c_vla_type_p (t1)); 345169689Skan d2_variable = d2_variable || (d2_zero && c_vla_type_p (t2)); 346169689Skan 34718334Speter /* Save space: see if the result is identical to one of the args. */ 348169689Skan if (elt == TREE_TYPE (t1) && TYPE_DOMAIN (t1) 349169689Skan && (d2_variable || d2_zero || !d1_variable)) 35018334Speter return build_type_attribute_variant (t1, attributes); 351169689Skan if (elt == TREE_TYPE (t2) && TYPE_DOMAIN (t2) 352169689Skan && (d1_variable || d1_zero || !d2_variable)) 35318334Speter return build_type_attribute_variant (t2, attributes); 354169689Skan 355169689Skan if (elt == TREE_TYPE (t1) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1)) 356169689Skan return build_type_attribute_variant (t1, attributes); 357169689Skan if (elt == TREE_TYPE (t2) && !TYPE_DOMAIN (t2) && !TYPE_DOMAIN (t1)) 358169689Skan return build_type_attribute_variant (t2, attributes); 359169689Skan 360169689Skan /* Merge the element types, and have a size if either arg has 361169689Skan one. We may have qualifiers on the element types. To set 362169689Skan up TYPE_MAIN_VARIANT correctly, we need to form the 363169689Skan composite of the unqualified types and add the qualifiers 364169689Skan back at the end. */ 365169689Skan quals = TYPE_QUALS (strip_array_types (elt)); 366169689Skan unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED); 367169689Skan t1 = build_array_type (unqual_elt, 368169689Skan TYPE_DOMAIN ((TYPE_DOMAIN (t1) 369169689Skan && (d2_variable 370169689Skan || d2_zero 371169689Skan || !d1_variable)) 372169689Skan ? t1 373169689Skan : t2)); 374169689Skan t1 = c_build_qualified_type (t1, quals); 37518334Speter return build_type_attribute_variant (t1, attributes); 37618334Speter } 37718334Speter 378169689Skan case ENUMERAL_TYPE: 379169689Skan case RECORD_TYPE: 380169689Skan case UNION_TYPE: 381169689Skan if (attributes != NULL) 382169689Skan { 383169689Skan /* Try harder not to create a new aggregate type. */ 384169689Skan if (attribute_list_equal (TYPE_ATTRIBUTES (t1), attributes)) 385169689Skan return t1; 386169689Skan if (attribute_list_equal (TYPE_ATTRIBUTES (t2), attributes)) 387169689Skan return t2; 388169689Skan } 389169689Skan return build_type_attribute_variant (t1, attributes); 390169689Skan 39118334Speter case FUNCTION_TYPE: 39218334Speter /* Function types: prefer the one that specified arg types. 39318334Speter If both do, merge the arg types. Also merge the return types. */ 39418334Speter { 395169689Skan tree valtype = composite_type (TREE_TYPE (t1), TREE_TYPE (t2)); 39618334Speter tree p1 = TYPE_ARG_TYPES (t1); 39718334Speter tree p2 = TYPE_ARG_TYPES (t2); 39818334Speter int len; 39918334Speter tree newargs, n; 40018334Speter int i; 40118334Speter 40218334Speter /* Save space: see if the result is identical to one of the args. */ 403169689Skan if (valtype == TREE_TYPE (t1) && !TYPE_ARG_TYPES (t2)) 40418334Speter return build_type_attribute_variant (t1, attributes); 405169689Skan if (valtype == TREE_TYPE (t2) && !TYPE_ARG_TYPES (t1)) 40618334Speter return build_type_attribute_variant (t2, attributes); 40718334Speter 40818334Speter /* Simple way if one arg fails to specify argument types. */ 40918334Speter if (TYPE_ARG_TYPES (t1) == 0) 41018334Speter { 411169689Skan t1 = build_function_type (valtype, TYPE_ARG_TYPES (t2)); 412169689Skan t1 = build_type_attribute_variant (t1, attributes); 413169689Skan return qualify_type (t1, t2); 41418334Speter } 41518334Speter if (TYPE_ARG_TYPES (t2) == 0) 41618334Speter { 41718334Speter t1 = build_function_type (valtype, TYPE_ARG_TYPES (t1)); 418169689Skan t1 = build_type_attribute_variant (t1, attributes); 419169689Skan return qualify_type (t1, t2); 42018334Speter } 42118334Speter 42218334Speter /* If both args specify argument types, we must merge the two 42318334Speter lists, argument by argument. */ 424169689Skan /* Tell global_bindings_p to return false so that variable_size 425169689Skan doesn't die on VLAs in parameter types. */ 426169689Skan c_override_global_bindings_to_false = true; 42718334Speter 42818334Speter len = list_length (p1); 42918334Speter newargs = 0; 43018334Speter 43118334Speter for (i = 0; i < len; i++) 43218334Speter newargs = tree_cons (NULL_TREE, NULL_TREE, newargs); 43318334Speter 43418334Speter n = newargs; 43518334Speter 43618334Speter for (; p1; 43718334Speter p1 = TREE_CHAIN (p1), p2 = TREE_CHAIN (p2), n = TREE_CHAIN (n)) 43818334Speter { 43918334Speter /* A null type means arg type is not specified. 44018334Speter Take whatever the other function type has. */ 44118334Speter if (TREE_VALUE (p1) == 0) 44218334Speter { 44318334Speter TREE_VALUE (n) = TREE_VALUE (p2); 44418334Speter goto parm_done; 44518334Speter } 44618334Speter if (TREE_VALUE (p2) == 0) 44718334Speter { 44818334Speter TREE_VALUE (n) = TREE_VALUE (p1); 44918334Speter goto parm_done; 45018334Speter } 451132718Skan 45218334Speter /* Given wait (union {union wait *u; int *i} *) 45318334Speter and wait (union wait *), 45418334Speter prefer union wait * as type of parm. */ 45518334Speter if (TREE_CODE (TREE_VALUE (p1)) == UNION_TYPE 45618334Speter && TREE_VALUE (p1) != TREE_VALUE (p2)) 45718334Speter { 45818334Speter tree memb; 459169689Skan tree mv2 = TREE_VALUE (p2); 460169689Skan if (mv2 && mv2 != error_mark_node 461169689Skan && TREE_CODE (mv2) != ARRAY_TYPE) 462169689Skan mv2 = TYPE_MAIN_VARIANT (mv2); 46318334Speter for (memb = TYPE_FIELDS (TREE_VALUE (p1)); 46418334Speter memb; memb = TREE_CHAIN (memb)) 465169689Skan { 466169689Skan tree mv3 = TREE_TYPE (memb); 467169689Skan if (mv3 && mv3 != error_mark_node 468169689Skan && TREE_CODE (mv3) != ARRAY_TYPE) 469169689Skan mv3 = TYPE_MAIN_VARIANT (mv3); 470169689Skan if (comptypes (mv3, mv2)) 471169689Skan { 472169689Skan TREE_VALUE (n) = composite_type (TREE_TYPE (memb), 473169689Skan TREE_VALUE (p2)); 474169689Skan if (pedantic) 475169689Skan pedwarn ("function types not truly compatible in ISO C"); 476169689Skan goto parm_done; 477169689Skan } 478169689Skan } 47918334Speter } 48018334Speter if (TREE_CODE (TREE_VALUE (p2)) == UNION_TYPE 48118334Speter && TREE_VALUE (p2) != TREE_VALUE (p1)) 48218334Speter { 48318334Speter tree memb; 484169689Skan tree mv1 = TREE_VALUE (p1); 485169689Skan if (mv1 && mv1 != error_mark_node 486169689Skan && TREE_CODE (mv1) != ARRAY_TYPE) 487169689Skan mv1 = TYPE_MAIN_VARIANT (mv1); 48818334Speter for (memb = TYPE_FIELDS (TREE_VALUE (p2)); 48918334Speter memb; memb = TREE_CHAIN (memb)) 490169689Skan { 491169689Skan tree mv3 = TREE_TYPE (memb); 492169689Skan if (mv3 && mv3 != error_mark_node 493169689Skan && TREE_CODE (mv3) != ARRAY_TYPE) 494169689Skan mv3 = TYPE_MAIN_VARIANT (mv3); 495169689Skan if (comptypes (mv3, mv1)) 496169689Skan { 497169689Skan TREE_VALUE (n) = composite_type (TREE_TYPE (memb), 498169689Skan TREE_VALUE (p1)); 499169689Skan if (pedantic) 500169689Skan pedwarn ("function types not truly compatible in ISO C"); 501169689Skan goto parm_done; 502169689Skan } 503169689Skan } 50418334Speter } 505169689Skan TREE_VALUE (n) = composite_type (TREE_VALUE (p1), TREE_VALUE (p2)); 50618334Speter parm_done: ; 50718334Speter } 50818334Speter 509169689Skan c_override_global_bindings_to_false = false; 51018334Speter t1 = build_function_type (valtype, newargs); 511169689Skan t1 = qualify_type (t1, t2); 51250397Sobrien /* ... falls through ... */ 51318334Speter } 51418334Speter 51518334Speter default: 51618334Speter return build_type_attribute_variant (t1, attributes); 51718334Speter } 51818334Speter 51918334Speter} 520169689Skan 521169689Skan/* Return the type of a conditional expression between pointers to 522169689Skan possibly differently qualified versions of compatible types. 523169689Skan 524169689Skan We assume that comp_target_types has already been done and returned 525169689Skan nonzero; if that isn't so, this may crash. */ 526169689Skan 527169689Skanstatic tree 528169689Skancommon_pointer_type (tree t1, tree t2) 529169689Skan{ 530169689Skan tree attributes; 531169689Skan tree pointed_to_1, mv1; 532169689Skan tree pointed_to_2, mv2; 533169689Skan tree target; 534169689Skan 535169689Skan /* Save time if the two types are the same. */ 536169689Skan 537169689Skan if (t1 == t2) return t1; 538169689Skan 539169689Skan /* If one type is nonsense, use the other. */ 540169689Skan if (t1 == error_mark_node) 541169689Skan return t2; 542169689Skan if (t2 == error_mark_node) 543169689Skan return t1; 544169689Skan 545169689Skan gcc_assert (TREE_CODE (t1) == POINTER_TYPE 546169689Skan && TREE_CODE (t2) == POINTER_TYPE); 547169689Skan 548169689Skan /* Merge the attributes. */ 549169689Skan attributes = targetm.merge_type_attributes (t1, t2); 550169689Skan 551169689Skan /* Find the composite type of the target types, and combine the 552169689Skan qualifiers of the two types' targets. Do not lose qualifiers on 553169689Skan array element types by taking the TYPE_MAIN_VARIANT. */ 554169689Skan mv1 = pointed_to_1 = TREE_TYPE (t1); 555169689Skan mv2 = pointed_to_2 = TREE_TYPE (t2); 556169689Skan if (TREE_CODE (mv1) != ARRAY_TYPE) 557169689Skan mv1 = TYPE_MAIN_VARIANT (pointed_to_1); 558169689Skan if (TREE_CODE (mv2) != ARRAY_TYPE) 559169689Skan mv2 = TYPE_MAIN_VARIANT (pointed_to_2); 560169689Skan target = composite_type (mv1, mv2); 561169689Skan t1 = build_pointer_type (c_build_qualified_type 562169689Skan (target, 563169689Skan TYPE_QUALS (pointed_to_1) | 564169689Skan TYPE_QUALS (pointed_to_2))); 565169689Skan return build_type_attribute_variant (t1, attributes); 566169689Skan} 567169689Skan 568169689Skan/* Return the common type for two arithmetic types under the usual 569169689Skan arithmetic conversions. The default conversions have already been 570169689Skan applied, and enumerated types converted to their compatible integer 571169689Skan types. The resulting type is unqualified and has no attributes. 572169689Skan 573169689Skan This is the type for the result of most arithmetic operations 574169689Skan if the operands have the given two types. */ 575169689Skan 576169689Skanstatic tree 577169689Skanc_common_type (tree t1, tree t2) 578169689Skan{ 579169689Skan enum tree_code code1; 580169689Skan enum tree_code code2; 581169689Skan 582169689Skan /* If one type is nonsense, use the other. */ 583169689Skan if (t1 == error_mark_node) 584169689Skan return t2; 585169689Skan if (t2 == error_mark_node) 586169689Skan return t1; 587169689Skan 588169689Skan if (TYPE_QUALS (t1) != TYPE_UNQUALIFIED) 589169689Skan t1 = TYPE_MAIN_VARIANT (t1); 590169689Skan 591169689Skan if (TYPE_QUALS (t2) != TYPE_UNQUALIFIED) 592169689Skan t2 = TYPE_MAIN_VARIANT (t2); 593169689Skan 594169689Skan if (TYPE_ATTRIBUTES (t1) != NULL_TREE) 595169689Skan t1 = build_type_attribute_variant (t1, NULL_TREE); 596169689Skan 597169689Skan if (TYPE_ATTRIBUTES (t2) != NULL_TREE) 598169689Skan t2 = build_type_attribute_variant (t2, NULL_TREE); 599169689Skan 600169689Skan /* Save time if the two types are the same. */ 601169689Skan 602169689Skan if (t1 == t2) return t1; 603169689Skan 604169689Skan code1 = TREE_CODE (t1); 605169689Skan code2 = TREE_CODE (t2); 606169689Skan 607169689Skan gcc_assert (code1 == VECTOR_TYPE || code1 == COMPLEX_TYPE 608169689Skan || code1 == REAL_TYPE || code1 == INTEGER_TYPE); 609169689Skan gcc_assert (code2 == VECTOR_TYPE || code2 == COMPLEX_TYPE 610169689Skan || code2 == REAL_TYPE || code2 == INTEGER_TYPE); 611169689Skan 612169689Skan /* When one operand is a decimal float type, the other operand cannot be 613169689Skan a generic float type or a complex type. We also disallow vector types 614169689Skan here. */ 615169689Skan if ((DECIMAL_FLOAT_TYPE_P (t1) || DECIMAL_FLOAT_TYPE_P (t2)) 616169689Skan && !(DECIMAL_FLOAT_TYPE_P (t1) && DECIMAL_FLOAT_TYPE_P (t2))) 617169689Skan { 618169689Skan if (code1 == VECTOR_TYPE || code2 == VECTOR_TYPE) 619169689Skan { 620169689Skan error ("can%'t mix operands of decimal float and vector types"); 621169689Skan return error_mark_node; 622169689Skan } 623169689Skan if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE) 624169689Skan { 625169689Skan error ("can%'t mix operands of decimal float and complex types"); 626169689Skan return error_mark_node; 627169689Skan } 628169689Skan if (code1 == REAL_TYPE && code2 == REAL_TYPE) 629169689Skan { 630169689Skan error ("can%'t mix operands of decimal float and other float types"); 631169689Skan return error_mark_node; 632169689Skan } 633169689Skan } 634169689Skan 635169689Skan /* If one type is a vector type, return that type. (How the usual 636169689Skan arithmetic conversions apply to the vector types extension is not 637169689Skan precisely specified.) */ 638169689Skan if (code1 == VECTOR_TYPE) 639169689Skan return t1; 640169689Skan 641169689Skan if (code2 == VECTOR_TYPE) 642169689Skan return t2; 643169689Skan 644169689Skan /* If one type is complex, form the common type of the non-complex 645169689Skan components, then make that complex. Use T1 or T2 if it is the 646169689Skan required type. */ 647169689Skan if (code1 == COMPLEX_TYPE || code2 == COMPLEX_TYPE) 648169689Skan { 649169689Skan tree subtype1 = code1 == COMPLEX_TYPE ? TREE_TYPE (t1) : t1; 650169689Skan tree subtype2 = code2 == COMPLEX_TYPE ? TREE_TYPE (t2) : t2; 651169689Skan tree subtype = c_common_type (subtype1, subtype2); 652169689Skan 653169689Skan if (code1 == COMPLEX_TYPE && TREE_TYPE (t1) == subtype) 654169689Skan return t1; 655169689Skan else if (code2 == COMPLEX_TYPE && TREE_TYPE (t2) == subtype) 656169689Skan return t2; 657169689Skan else 658169689Skan return build_complex_type (subtype); 659169689Skan } 660169689Skan 661169689Skan /* If only one is real, use it as the result. */ 662169689Skan 663169689Skan if (code1 == REAL_TYPE && code2 != REAL_TYPE) 664169689Skan return t1; 665169689Skan 666169689Skan if (code2 == REAL_TYPE && code1 != REAL_TYPE) 667169689Skan return t2; 668169689Skan 669169689Skan /* If both are real and either are decimal floating point types, use 670169689Skan the decimal floating point type with the greater precision. */ 671169689Skan 672169689Skan if (code1 == REAL_TYPE && code2 == REAL_TYPE) 673169689Skan { 674169689Skan if (TYPE_MAIN_VARIANT (t1) == dfloat128_type_node 675169689Skan || TYPE_MAIN_VARIANT (t2) == dfloat128_type_node) 676169689Skan return dfloat128_type_node; 677169689Skan else if (TYPE_MAIN_VARIANT (t1) == dfloat64_type_node 678169689Skan || TYPE_MAIN_VARIANT (t2) == dfloat64_type_node) 679169689Skan return dfloat64_type_node; 680169689Skan else if (TYPE_MAIN_VARIANT (t1) == dfloat32_type_node 681169689Skan || TYPE_MAIN_VARIANT (t2) == dfloat32_type_node) 682169689Skan return dfloat32_type_node; 683169689Skan } 684169689Skan 685169689Skan /* Both real or both integers; use the one with greater precision. */ 686169689Skan 687169689Skan if (TYPE_PRECISION (t1) > TYPE_PRECISION (t2)) 688169689Skan return t1; 689169689Skan else if (TYPE_PRECISION (t2) > TYPE_PRECISION (t1)) 690169689Skan return t2; 691169689Skan 692169689Skan /* Same precision. Prefer long longs to longs to ints when the 693169689Skan same precision, following the C99 rules on integer type rank 694169689Skan (which are equivalent to the C90 rules for C90 types). */ 695169689Skan 696169689Skan if (TYPE_MAIN_VARIANT (t1) == long_long_unsigned_type_node 697169689Skan || TYPE_MAIN_VARIANT (t2) == long_long_unsigned_type_node) 698169689Skan return long_long_unsigned_type_node; 699169689Skan 700169689Skan if (TYPE_MAIN_VARIANT (t1) == long_long_integer_type_node 701169689Skan || TYPE_MAIN_VARIANT (t2) == long_long_integer_type_node) 702169689Skan { 703169689Skan if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2)) 704169689Skan return long_long_unsigned_type_node; 705169689Skan else 706169689Skan return long_long_integer_type_node; 707169689Skan } 708169689Skan 709169689Skan if (TYPE_MAIN_VARIANT (t1) == long_unsigned_type_node 710169689Skan || TYPE_MAIN_VARIANT (t2) == long_unsigned_type_node) 711169689Skan return long_unsigned_type_node; 712169689Skan 713169689Skan if (TYPE_MAIN_VARIANT (t1) == long_integer_type_node 714169689Skan || TYPE_MAIN_VARIANT (t2) == long_integer_type_node) 715169689Skan { 716169689Skan /* But preserve unsignedness from the other type, 717169689Skan since long cannot hold all the values of an unsigned int. */ 718169689Skan if (TYPE_UNSIGNED (t1) || TYPE_UNSIGNED (t2)) 719169689Skan return long_unsigned_type_node; 720169689Skan else 721169689Skan return long_integer_type_node; 722169689Skan } 723169689Skan 724169689Skan /* Likewise, prefer long double to double even if same size. */ 725169689Skan if (TYPE_MAIN_VARIANT (t1) == long_double_type_node 726169689Skan || TYPE_MAIN_VARIANT (t2) == long_double_type_node) 727169689Skan return long_double_type_node; 728169689Skan 729169689Skan /* Otherwise prefer the unsigned one. */ 730169689Skan 731169689Skan if (TYPE_UNSIGNED (t1)) 732169689Skan return t1; 733169689Skan else 734169689Skan return t2; 735169689Skan} 73618334Speter 737169689Skan/* Wrapper around c_common_type that is used by c-common.c and other 738169689Skan front end optimizations that remove promotions. ENUMERAL_TYPEs 739169689Skan are allowed here and are converted to their compatible integer types. 740169689Skan BOOLEAN_TYPEs are allowed here and return either boolean_type_node or 741169689Skan preferably a non-Boolean type as the common type. */ 742169689Skantree 743169689Skancommon_type (tree t1, tree t2) 744169689Skan{ 745169689Skan if (TREE_CODE (t1) == ENUMERAL_TYPE) 746169689Skan t1 = c_common_type_for_size (TYPE_PRECISION (t1), 1); 747169689Skan if (TREE_CODE (t2) == ENUMERAL_TYPE) 748169689Skan t2 = c_common_type_for_size (TYPE_PRECISION (t2), 1); 749169689Skan 750169689Skan /* If both types are BOOLEAN_TYPE, then return boolean_type_node. */ 751169689Skan if (TREE_CODE (t1) == BOOLEAN_TYPE 752169689Skan && TREE_CODE (t2) == BOOLEAN_TYPE) 753169689Skan return boolean_type_node; 754169689Skan 755169689Skan /* If either type is BOOLEAN_TYPE, then return the other. */ 756169689Skan if (TREE_CODE (t1) == BOOLEAN_TYPE) 757169689Skan return t2; 758169689Skan if (TREE_CODE (t2) == BOOLEAN_TYPE) 759169689Skan return t1; 760169689Skan 761169689Skan return c_common_type (t1, t2); 762169689Skan} 763169689Skan 76418334Speter/* Return 1 if TYPE1 and TYPE2 are compatible types for assignment 76518334Speter or various other operations. Return 2 if they are compatible 76618334Speter but a warning may be needed if you use them together. */ 76718334Speter 76818334Speterint 769169689Skancomptypes (tree type1, tree type2) 77018334Speter{ 771169689Skan const struct tagged_tu_seen_cache * tagged_tu_seen_base1 = tagged_tu_seen_base; 772169689Skan int val; 773169689Skan 774169689Skan val = comptypes_internal (type1, type2); 775169689Skan free_all_tagged_tu_seen_up_to (tagged_tu_seen_base1); 776169689Skan 777169689Skan return val; 778169689Skan} 779169689Skan 780169689Skan/* Return 1 if TYPE1 and TYPE2 are compatible types for assignment 781169689Skan or various other operations. Return 2 if they are compatible 782169689Skan but a warning may be needed if you use them together. This 783169689Skan differs from comptypes, in that we don't free the seen types. */ 784169689Skan 785169689Skanstatic int 786169689Skancomptypes_internal (tree type1, tree type2) 787169689Skan{ 78890075Sobrien tree t1 = type1; 78990075Sobrien tree t2 = type2; 79018334Speter int attrval, val; 79118334Speter 79218334Speter /* Suppress errors caused by previously reported errors. */ 79318334Speter 79450397Sobrien if (t1 == t2 || !t1 || !t2 79550397Sobrien || TREE_CODE (t1) == ERROR_MARK || TREE_CODE (t2) == ERROR_MARK) 79618334Speter return 1; 79718334Speter 79890075Sobrien /* If either type is the internal version of sizetype, return the 79990075Sobrien language version. */ 80090075Sobrien if (TREE_CODE (t1) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t1) 801169689Skan && TYPE_ORIG_SIZE_TYPE (t1)) 802169689Skan t1 = TYPE_ORIG_SIZE_TYPE (t1); 80390075Sobrien 80490075Sobrien if (TREE_CODE (t2) == INTEGER_TYPE && TYPE_IS_SIZETYPE (t2) 805169689Skan && TYPE_ORIG_SIZE_TYPE (t2)) 806169689Skan t2 = TYPE_ORIG_SIZE_TYPE (t2); 80790075Sobrien 808169689Skan 809132718Skan /* Enumerated types are compatible with integer types, but this is 810132718Skan not transitive: two enumerated types in the same translation unit 811132718Skan are compatible with each other only if they are the same type. */ 81218334Speter 813132718Skan if (TREE_CODE (t1) == ENUMERAL_TYPE && TREE_CODE (t2) != ENUMERAL_TYPE) 814169689Skan t1 = c_common_type_for_size (TYPE_PRECISION (t1), TYPE_UNSIGNED (t1)); 815132718Skan else if (TREE_CODE (t2) == ENUMERAL_TYPE && TREE_CODE (t1) != ENUMERAL_TYPE) 816169689Skan t2 = c_common_type_for_size (TYPE_PRECISION (t2), TYPE_UNSIGNED (t2)); 81718334Speter 81818334Speter if (t1 == t2) 81918334Speter return 1; 82018334Speter 82118334Speter /* Different classes of types can't be compatible. */ 82218334Speter 823132718Skan if (TREE_CODE (t1) != TREE_CODE (t2)) 824132718Skan return 0; 82518334Speter 826169689Skan /* Qualifiers must match. C99 6.7.3p9 */ 82718334Speter 82852284Sobrien if (TYPE_QUALS (t1) != TYPE_QUALS (t2)) 82918334Speter return 0; 83018334Speter 83118334Speter /* Allow for two different type nodes which have essentially the same 83218334Speter definition. Note that we already checked for equality of the type 83350397Sobrien qualifiers (just above). */ 83418334Speter 835169689Skan if (TREE_CODE (t1) != ARRAY_TYPE 836169689Skan && TYPE_MAIN_VARIANT (t1) == TYPE_MAIN_VARIANT (t2)) 83718334Speter return 1; 83818334Speter 83918334Speter /* 1 if no need for warning yet, 2 if warning cause has been seen. */ 840169689Skan if (!(attrval = targetm.comp_type_attributes (t1, t2))) 84118334Speter return 0; 84218334Speter 84318334Speter /* 1 if no need for warning yet, 2 if warning cause has been seen. */ 84418334Speter val = 0; 84518334Speter 84618334Speter switch (TREE_CODE (t1)) 84718334Speter { 84818334Speter case POINTER_TYPE: 849169689Skan /* Do not remove mode or aliasing information. */ 850169689Skan if (TYPE_MODE (t1) != TYPE_MODE (t2) 851169689Skan || TYPE_REF_CAN_ALIAS_ALL (t1) != TYPE_REF_CAN_ALIAS_ALL (t2)) 852132718Skan break; 85318334Speter val = (TREE_TYPE (t1) == TREE_TYPE (t2) 854169689Skan ? 1 : comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2))); 85518334Speter break; 85618334Speter 85718334Speter case FUNCTION_TYPE: 858169689Skan val = function_types_compatible_p (t1, t2); 85918334Speter break; 86018334Speter 86118334Speter case ARRAY_TYPE: 86218334Speter { 86318334Speter tree d1 = TYPE_DOMAIN (t1); 86418334Speter tree d2 = TYPE_DOMAIN (t2); 86590075Sobrien bool d1_variable, d2_variable; 86690075Sobrien bool d1_zero, d2_zero; 86718334Speter val = 1; 86818334Speter 86918334Speter /* Target types must match incl. qualifiers. */ 87018334Speter if (TREE_TYPE (t1) != TREE_TYPE (t2) 871169689Skan && 0 == (val = comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2)))) 87218334Speter return 0; 87318334Speter 87418334Speter /* Sizes must match unless one is missing or variable. */ 87590075Sobrien if (d1 == 0 || d2 == 0 || d1 == d2) 87618334Speter break; 87718334Speter 878169689Skan d1_zero = !TYPE_MAX_VALUE (d1); 879169689Skan d2_zero = !TYPE_MAX_VALUE (d2); 88090075Sobrien 881169689Skan d1_variable = (!d1_zero 88290075Sobrien && (TREE_CODE (TYPE_MIN_VALUE (d1)) != INTEGER_CST 88390075Sobrien || TREE_CODE (TYPE_MAX_VALUE (d1)) != INTEGER_CST)); 884169689Skan d2_variable = (!d2_zero 88590075Sobrien && (TREE_CODE (TYPE_MIN_VALUE (d2)) != INTEGER_CST 88690075Sobrien || TREE_CODE (TYPE_MAX_VALUE (d2)) != INTEGER_CST)); 887169689Skan d1_variable = d1_variable || (d1_zero && c_vla_type_p (t1)); 888169689Skan d2_variable = d2_variable || (d2_zero && c_vla_type_p (t2)); 88990075Sobrien 89090075Sobrien if (d1_variable || d2_variable) 89190075Sobrien break; 89290075Sobrien if (d1_zero && d2_zero) 89390075Sobrien break; 89490075Sobrien if (d1_zero || d2_zero 895169689Skan || !tree_int_cst_equal (TYPE_MIN_VALUE (d1), TYPE_MIN_VALUE (d2)) 896169689Skan || !tree_int_cst_equal (TYPE_MAX_VALUE (d1), TYPE_MAX_VALUE (d2))) 89790075Sobrien val = 0; 89890075Sobrien 899169689Skan break; 90018334Speter } 90118334Speter 902169689Skan case ENUMERAL_TYPE: 90318334Speter case RECORD_TYPE: 904132718Skan case UNION_TYPE: 905132718Skan if (val != 1 && !same_translation_unit_p (t1, t2)) 906169689Skan { 907169689Skan tree a1 = TYPE_ATTRIBUTES (t1); 908169689Skan tree a2 = TYPE_ATTRIBUTES (t2); 909169689Skan 910169689Skan if (! attribute_list_contained (a1, a2) 911169689Skan && ! attribute_list_contained (a2, a1)) 912169689Skan break; 913169689Skan 914169689Skan if (attrval != 2) 915169689Skan return tagged_types_tu_compatible_p (t1, t2); 916169689Skan val = tagged_types_tu_compatible_p (t1, t2); 917169689Skan } 91818334Speter break; 91950397Sobrien 920132718Skan case VECTOR_TYPE: 921169689Skan val = TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2) 922169689Skan && comptypes_internal (TREE_TYPE (t1), TREE_TYPE (t2)); 923132718Skan break; 924132718Skan 92550397Sobrien default: 92650397Sobrien break; 92718334Speter } 92818334Speter return attrval == 2 && val == 1 ? 2 : val; 92918334Speter} 93018334Speter 93118334Speter/* Return 1 if TTL and TTR are pointers to types that are equivalent, 932169689Skan ignoring their qualifiers. */ 93318334Speter 93418334Speterstatic int 935169689Skancomp_target_types (tree ttl, tree ttr) 93618334Speter{ 93718334Speter int val; 938169689Skan tree mvl, mvr; 93918334Speter 940169689Skan /* Do not lose qualifiers on element types of array types that are 941169689Skan pointer targets by taking their TYPE_MAIN_VARIANT. */ 942169689Skan mvl = TREE_TYPE (ttl); 943169689Skan mvr = TREE_TYPE (ttr); 944169689Skan if (TREE_CODE (mvl) != ARRAY_TYPE) 945169689Skan mvl = TYPE_MAIN_VARIANT (mvl); 946169689Skan if (TREE_CODE (mvr) != ARRAY_TYPE) 947169689Skan mvr = TYPE_MAIN_VARIANT (mvr); 948169689Skan val = comptypes (mvl, mvr); 94918334Speter 95018334Speter if (val == 2 && pedantic) 95118334Speter pedwarn ("types are not quite compatible"); 95218334Speter return val; 95318334Speter} 95418334Speter 95518334Speter/* Subroutines of `comptypes'. */ 95618334Speter 957169689Skan/* Determine whether two trees derive from the same translation unit. 958169689Skan If the CONTEXT chain ends in a null, that tree's context is still 959169689Skan being parsed, so if two trees have context chains ending in null, 960132718Skan they're in the same translation unit. */ 961169689Skanint 962132718Skansame_translation_unit_p (tree t1, tree t2) 963132718Skan{ 964132718Skan while (t1 && TREE_CODE (t1) != TRANSLATION_UNIT_DECL) 965132718Skan switch (TREE_CODE_CLASS (TREE_CODE (t1))) 966132718Skan { 967169689Skan case tcc_declaration: 968169689Skan t1 = DECL_CONTEXT (t1); break; 969169689Skan case tcc_type: 970169689Skan t1 = TYPE_CONTEXT (t1); break; 971169689Skan case tcc_exceptional: 972169689Skan t1 = BLOCK_SUPERCONTEXT (t1); break; /* assume block */ 973169689Skan default: gcc_unreachable (); 974132718Skan } 975132718Skan 976132718Skan while (t2 && TREE_CODE (t2) != TRANSLATION_UNIT_DECL) 977132718Skan switch (TREE_CODE_CLASS (TREE_CODE (t2))) 978132718Skan { 979169689Skan case tcc_declaration: 980169689Skan t2 = DECL_CONTEXT (t2); break; 981169689Skan case tcc_type: 982169689Skan t2 = TYPE_CONTEXT (t2); break; 983169689Skan case tcc_exceptional: 984169689Skan t2 = BLOCK_SUPERCONTEXT (t2); break; /* assume block */ 985169689Skan default: gcc_unreachable (); 986132718Skan } 987132718Skan 988132718Skan return t1 == t2; 989132718Skan} 990132718Skan 991169689Skan/* Allocate the seen two types, assuming that they are compatible. */ 992132718Skan 993169689Skanstatic struct tagged_tu_seen_cache * 994169689Skanalloc_tagged_tu_seen_cache (tree t1, tree t2) 995169689Skan{ 996169689Skan struct tagged_tu_seen_cache *tu = XNEW (struct tagged_tu_seen_cache); 997169689Skan tu->next = tagged_tu_seen_base; 998169689Skan tu->t1 = t1; 999169689Skan tu->t2 = t2; 1000132718Skan 1001169689Skan tagged_tu_seen_base = tu; 1002132718Skan 1003169689Skan /* The C standard says that two structures in different translation 1004169689Skan units are compatible with each other only if the types of their 1005169689Skan fields are compatible (among other things). We assume that they 1006169689Skan are compatible until proven otherwise when building the cache. 1007169689Skan An example where this can occur is: 1008169689Skan struct a 1009169689Skan { 1010169689Skan struct a *next; 1011169689Skan }; 1012169689Skan If we are comparing this against a similar struct in another TU, 1013169689Skan and did not assume they were compatible, we end up with an infinite 1014169689Skan loop. */ 1015169689Skan tu->val = 1; 1016169689Skan return tu; 1017169689Skan} 1018132718Skan 1019169689Skan/* Free the seen types until we get to TU_TIL. */ 1020169689Skan 1021169689Skanstatic void 1022169689Skanfree_all_tagged_tu_seen_up_to (const struct tagged_tu_seen_cache *tu_til) 1023169689Skan{ 1024169689Skan const struct tagged_tu_seen_cache *tu = tagged_tu_seen_base; 1025169689Skan while (tu != tu_til) 1026169689Skan { 1027169689Skan struct tagged_tu_seen_cache *tu1 = (struct tagged_tu_seen_cache*)tu; 1028169689Skan tu = tu1->next; 1029169689Skan free (tu1); 1030169689Skan } 1031169689Skan tagged_tu_seen_base = tu_til; 1032169689Skan} 1033169689Skan 1034132718Skan/* Return 1 if two 'struct', 'union', or 'enum' types T1 and T2 are 1035132718Skan compatible. If the two types are not the same (which has been 1036132718Skan checked earlier), this can only happen when multiple translation 1037132718Skan units are being compiled. See C99 6.2.7 paragraph 1 for the exact 1038132718Skan rules. */ 1039132718Skan 1040132718Skanstatic int 1041169689Skantagged_types_tu_compatible_p (tree t1, tree t2) 1042132718Skan{ 1043132718Skan tree s1, s2; 1044132718Skan bool needs_warning = false; 1045132718Skan 1046132718Skan /* We have to verify that the tags of the types are the same. This 1047132718Skan is harder than it looks because this may be a typedef, so we have 1048132718Skan to go look at the original type. It may even be a typedef of a 1049169689Skan typedef... 1050169689Skan In the case of compiler-created builtin structs the TYPE_DECL 1051169689Skan may be a dummy, with no DECL_ORIGINAL_TYPE. Don't fault. */ 1052132718Skan while (TYPE_NAME (t1) 1053132718Skan && TREE_CODE (TYPE_NAME (t1)) == TYPE_DECL 1054132718Skan && DECL_ORIGINAL_TYPE (TYPE_NAME (t1))) 1055132718Skan t1 = DECL_ORIGINAL_TYPE (TYPE_NAME (t1)); 1056132718Skan 1057132718Skan while (TYPE_NAME (t2) 1058132718Skan && TREE_CODE (TYPE_NAME (t2)) == TYPE_DECL 1059132718Skan && DECL_ORIGINAL_TYPE (TYPE_NAME (t2))) 1060132718Skan t2 = DECL_ORIGINAL_TYPE (TYPE_NAME (t2)); 1061132718Skan 1062132718Skan /* C90 didn't have the requirement that the two tags be the same. */ 1063132718Skan if (flag_isoc99 && TYPE_NAME (t1) != TYPE_NAME (t2)) 1064132718Skan return 0; 1065132718Skan 1066132718Skan /* C90 didn't say what happened if one or both of the types were 1067132718Skan incomplete; we choose to follow C99 rules here, which is that they 1068132718Skan are compatible. */ 1069132718Skan if (TYPE_SIZE (t1) == NULL 1070132718Skan || TYPE_SIZE (t2) == NULL) 1071132718Skan return 1; 1072132718Skan 1073132718Skan { 1074169689Skan const struct tagged_tu_seen_cache * tts_i; 1075132718Skan for (tts_i = tagged_tu_seen_base; tts_i != NULL; tts_i = tts_i->next) 1076132718Skan if (tts_i->t1 == t1 && tts_i->t2 == t2) 1077169689Skan return tts_i->val; 1078132718Skan } 1079132718Skan 1080132718Skan switch (TREE_CODE (t1)) 1081132718Skan { 1082132718Skan case ENUMERAL_TYPE: 1083132718Skan { 1084169689Skan struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2); 1085169689Skan /* Speed up the case where the type values are in the same order. */ 1086169689Skan tree tv1 = TYPE_VALUES (t1); 1087169689Skan tree tv2 = TYPE_VALUES (t2); 1088169689Skan 1089169689Skan if (tv1 == tv2) 1090169689Skan { 1091169689Skan return 1; 1092169689Skan } 1093169689Skan 1094169689Skan for (;tv1 && tv2; tv1 = TREE_CHAIN (tv1), tv2 = TREE_CHAIN (tv2)) 1095169689Skan { 1096169689Skan if (TREE_PURPOSE (tv1) != TREE_PURPOSE (tv2)) 1097169689Skan break; 1098169689Skan if (simple_cst_equal (TREE_VALUE (tv1), TREE_VALUE (tv2)) != 1) 1099169689Skan { 1100169689Skan tu->val = 0; 1101169689Skan return 0; 1102169689Skan } 1103169689Skan } 1104169689Skan 1105169689Skan if (tv1 == NULL_TREE && tv2 == NULL_TREE) 1106169689Skan { 1107169689Skan return 1; 1108169689Skan } 1109169689Skan if (tv1 == NULL_TREE || tv2 == NULL_TREE) 1110169689Skan { 1111169689Skan tu->val = 0; 1112169689Skan return 0; 1113169689Skan } 1114169689Skan 1115132718Skan if (list_length (TYPE_VALUES (t1)) != list_length (TYPE_VALUES (t2))) 1116169689Skan { 1117169689Skan tu->val = 0; 1118169689Skan return 0; 1119169689Skan } 1120132718Skan 1121132718Skan for (s1 = TYPE_VALUES (t1); s1; s1 = TREE_CHAIN (s1)) 1122132718Skan { 1123132718Skan s2 = purpose_member (TREE_PURPOSE (s1), TYPE_VALUES (t2)); 1124132718Skan if (s2 == NULL 1125132718Skan || simple_cst_equal (TREE_VALUE (s1), TREE_VALUE (s2)) != 1) 1126169689Skan { 1127169689Skan tu->val = 0; 1128169689Skan return 0; 1129169689Skan } 1130132718Skan } 1131132718Skan return 1; 1132132718Skan } 1133132718Skan 1134132718Skan case UNION_TYPE: 1135132718Skan { 1136169689Skan struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2); 1137132718Skan if (list_length (TYPE_FIELDS (t1)) != list_length (TYPE_FIELDS (t2))) 1138169689Skan { 1139169689Skan tu->val = 0; 1140169689Skan return 0; 1141169689Skan } 1142132718Skan 1143169689Skan /* Speed up the common case where the fields are in the same order. */ 1144169689Skan for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2); s1 && s2; 1145169689Skan s1 = TREE_CHAIN (s1), s2 = TREE_CHAIN (s2)) 1146169689Skan { 1147169689Skan int result; 1148169689Skan 1149169689Skan 1150169689Skan if (DECL_NAME (s1) == NULL 1151169689Skan || DECL_NAME (s1) != DECL_NAME (s2)) 1152169689Skan break; 1153169689Skan result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2)); 1154169689Skan if (result == 0) 1155169689Skan { 1156169689Skan tu->val = 0; 1157169689Skan return 0; 1158169689Skan } 1159169689Skan if (result == 2) 1160169689Skan needs_warning = true; 1161169689Skan 1162169689Skan if (TREE_CODE (s1) == FIELD_DECL 1163169689Skan && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1), 1164169689Skan DECL_FIELD_BIT_OFFSET (s2)) != 1) 1165169689Skan { 1166169689Skan tu->val = 0; 1167169689Skan return 0; 1168169689Skan } 1169169689Skan } 1170169689Skan if (!s1 && !s2) 1171169689Skan { 1172169689Skan tu->val = needs_warning ? 2 : 1; 1173169689Skan return tu->val; 1174169689Skan } 1175169689Skan 1176132718Skan for (s1 = TYPE_FIELDS (t1); s1; s1 = TREE_CHAIN (s1)) 1177132718Skan { 1178132718Skan bool ok = false; 1179132718Skan 1180132718Skan if (DECL_NAME (s1) != NULL) 1181169689Skan for (s2 = TYPE_FIELDS (t2); s2; s2 = TREE_CHAIN (s2)) 1182132718Skan if (DECL_NAME (s1) == DECL_NAME (s2)) 1183132718Skan { 1184132718Skan int result; 1185169689Skan result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2)); 1186132718Skan if (result == 0) 1187169689Skan { 1188169689Skan tu->val = 0; 1189169689Skan return 0; 1190169689Skan } 1191132718Skan if (result == 2) 1192132718Skan needs_warning = true; 1193132718Skan 1194132718Skan if (TREE_CODE (s1) == FIELD_DECL 1195132718Skan && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1), 1196132718Skan DECL_FIELD_BIT_OFFSET (s2)) != 1) 1197132718Skan break; 1198132718Skan 1199132718Skan ok = true; 1200132718Skan break; 1201132718Skan } 1202169689Skan if (!ok) 1203169689Skan { 1204169689Skan tu->val = 0; 1205169689Skan return 0; 1206169689Skan } 1207132718Skan } 1208169689Skan tu->val = needs_warning ? 2 : 10; 1209169689Skan return tu->val; 1210132718Skan } 1211132718Skan 1212132718Skan case RECORD_TYPE: 1213132718Skan { 1214169689Skan struct tagged_tu_seen_cache *tu = alloc_tagged_tu_seen_cache (t1, t2); 1215132718Skan 1216132718Skan for (s1 = TYPE_FIELDS (t1), s2 = TYPE_FIELDS (t2); 1217132718Skan s1 && s2; 1218132718Skan s1 = TREE_CHAIN (s1), s2 = TREE_CHAIN (s2)) 1219132718Skan { 1220132718Skan int result; 1221132718Skan if (TREE_CODE (s1) != TREE_CODE (s2) 1222132718Skan || DECL_NAME (s1) != DECL_NAME (s2)) 1223132718Skan break; 1224169689Skan result = comptypes_internal (TREE_TYPE (s1), TREE_TYPE (s2)); 1225132718Skan if (result == 0) 1226132718Skan break; 1227132718Skan if (result == 2) 1228132718Skan needs_warning = true; 1229132718Skan 1230132718Skan if (TREE_CODE (s1) == FIELD_DECL 1231132718Skan && simple_cst_equal (DECL_FIELD_BIT_OFFSET (s1), 1232132718Skan DECL_FIELD_BIT_OFFSET (s2)) != 1) 1233132718Skan break; 1234132718Skan } 1235132718Skan if (s1 && s2) 1236169689Skan tu->val = 0; 1237169689Skan else 1238169689Skan tu->val = needs_warning ? 2 : 1; 1239169689Skan return tu->val; 1240132718Skan } 1241132718Skan 1242132718Skan default: 1243169689Skan gcc_unreachable (); 1244132718Skan } 1245132718Skan} 1246132718Skan 124718334Speter/* Return 1 if two function types F1 and F2 are compatible. 124818334Speter If either type specifies no argument types, 124918334Speter the other must specify a fixed number of self-promoting arg types. 1250132718Skan Otherwise, if one type specifies only the number of arguments, 125118334Speter the other must specify that number of self-promoting arg types. 125218334Speter Otherwise, the argument types must match. */ 125318334Speter 125418334Speterstatic int 1255169689Skanfunction_types_compatible_p (tree f1, tree f2) 125618334Speter{ 125718334Speter tree args1, args2; 125818334Speter /* 1 if no need for warning yet, 2 if warning cause has been seen. */ 125918334Speter int val = 1; 126018334Speter int val1; 1261132718Skan tree ret1, ret2; 126218334Speter 1263132718Skan ret1 = TREE_TYPE (f1); 1264132718Skan ret2 = TREE_TYPE (f2); 1265132718Skan 1266169689Skan /* 'volatile' qualifiers on a function's return type used to mean 1267169689Skan the function is noreturn. */ 1268169689Skan if (TYPE_VOLATILE (ret1) != TYPE_VOLATILE (ret2)) 1269169689Skan pedwarn ("function return types not compatible due to %<volatile%>"); 1270132718Skan if (TYPE_VOLATILE (ret1)) 1271132718Skan ret1 = build_qualified_type (TYPE_MAIN_VARIANT (ret1), 1272132718Skan TYPE_QUALS (ret1) & ~TYPE_QUAL_VOLATILE); 1273132718Skan if (TYPE_VOLATILE (ret2)) 1274132718Skan ret2 = build_qualified_type (TYPE_MAIN_VARIANT (ret2), 1275132718Skan TYPE_QUALS (ret2) & ~TYPE_QUAL_VOLATILE); 1276169689Skan val = comptypes_internal (ret1, ret2); 1277132718Skan if (val == 0) 127818334Speter return 0; 127918334Speter 128018334Speter args1 = TYPE_ARG_TYPES (f1); 128118334Speter args2 = TYPE_ARG_TYPES (f2); 128218334Speter 128318334Speter /* An unspecified parmlist matches any specified parmlist 128418334Speter whose argument types don't need default promotions. */ 128518334Speter 128618334Speter if (args1 == 0) 128718334Speter { 128818334Speter if (!self_promoting_args_p (args2)) 128918334Speter return 0; 129018334Speter /* If one of these types comes from a non-prototype fn definition, 129118334Speter compare that with the other type's arglist. 129218334Speter If they don't match, ask for a warning (but no error). */ 129318334Speter if (TYPE_ACTUAL_ARG_TYPES (f1) 1294169689Skan && 1 != type_lists_compatible_p (args2, TYPE_ACTUAL_ARG_TYPES (f1))) 129518334Speter val = 2; 129618334Speter return val; 129718334Speter } 129818334Speter if (args2 == 0) 129918334Speter { 130018334Speter if (!self_promoting_args_p (args1)) 130118334Speter return 0; 130218334Speter if (TYPE_ACTUAL_ARG_TYPES (f2) 1303169689Skan && 1 != type_lists_compatible_p (args1, TYPE_ACTUAL_ARG_TYPES (f2))) 130418334Speter val = 2; 130518334Speter return val; 130618334Speter } 130718334Speter 130818334Speter /* Both types have argument lists: compare them and propagate results. */ 1309169689Skan val1 = type_lists_compatible_p (args1, args2); 131018334Speter return val1 != 1 ? val1 : val; 131118334Speter} 131218334Speter 131318334Speter/* Check two lists of types for compatibility, 131418334Speter returning 0 for incompatible, 1 for compatible, 131518334Speter or 2 for compatible with warning. */ 131618334Speter 131718334Speterstatic int 1318169689Skantype_lists_compatible_p (tree args1, tree args2) 131918334Speter{ 132018334Speter /* 1 if no need for warning yet, 2 if warning cause has been seen. */ 132118334Speter int val = 1; 132218334Speter int newval = 0; 132318334Speter 132418334Speter while (1) 132518334Speter { 1326169689Skan tree a1, mv1, a2, mv2; 132718334Speter if (args1 == 0 && args2 == 0) 132818334Speter return val; 132918334Speter /* If one list is shorter than the other, 133018334Speter they fail to match. */ 133118334Speter if (args1 == 0 || args2 == 0) 133218334Speter return 0; 1333169689Skan mv1 = a1 = TREE_VALUE (args1); 1334169689Skan mv2 = a2 = TREE_VALUE (args2); 1335169689Skan if (mv1 && mv1 != error_mark_node && TREE_CODE (mv1) != ARRAY_TYPE) 1336169689Skan mv1 = TYPE_MAIN_VARIANT (mv1); 1337169689Skan if (mv2 && mv2 != error_mark_node && TREE_CODE (mv2) != ARRAY_TYPE) 1338169689Skan mv2 = TYPE_MAIN_VARIANT (mv2); 133918334Speter /* A null pointer instead of a type 134018334Speter means there is supposed to be an argument 134118334Speter but nothing is specified about what type it has. 134218334Speter So match anything that self-promotes. */ 1343169689Skan if (a1 == 0) 134418334Speter { 1345169689Skan if (c_type_promotes_to (a2) != a2) 134618334Speter return 0; 134718334Speter } 1348169689Skan else if (a2 == 0) 134918334Speter { 1350169689Skan if (c_type_promotes_to (a1) != a1) 135118334Speter return 0; 135218334Speter } 1353132718Skan /* If one of the lists has an error marker, ignore this arg. */ 1354169689Skan else if (TREE_CODE (a1) == ERROR_MARK 1355169689Skan || TREE_CODE (a2) == ERROR_MARK) 1356132718Skan ; 1357169689Skan else if (!(newval = comptypes_internal (mv1, mv2))) 135818334Speter { 135918334Speter /* Allow wait (union {union wait *u; int *i} *) 136018334Speter and wait (union wait *) to be compatible. */ 1361169689Skan if (TREE_CODE (a1) == UNION_TYPE 1362169689Skan && (TYPE_NAME (a1) == 0 1363169689Skan || TYPE_TRANSPARENT_UNION (a1)) 1364169689Skan && TREE_CODE (TYPE_SIZE (a1)) == INTEGER_CST 1365169689Skan && tree_int_cst_equal (TYPE_SIZE (a1), 1366169689Skan TYPE_SIZE (a2))) 136718334Speter { 136818334Speter tree memb; 1369169689Skan for (memb = TYPE_FIELDS (a1); 137018334Speter memb; memb = TREE_CHAIN (memb)) 1371169689Skan { 1372169689Skan tree mv3 = TREE_TYPE (memb); 1373169689Skan if (mv3 && mv3 != error_mark_node 1374169689Skan && TREE_CODE (mv3) != ARRAY_TYPE) 1375169689Skan mv3 = TYPE_MAIN_VARIANT (mv3); 1376169689Skan if (comptypes_internal (mv3, mv2)) 1377169689Skan break; 1378169689Skan } 137918334Speter if (memb == 0) 138018334Speter return 0; 138118334Speter } 1382169689Skan else if (TREE_CODE (a2) == UNION_TYPE 1383169689Skan && (TYPE_NAME (a2) == 0 1384169689Skan || TYPE_TRANSPARENT_UNION (a2)) 1385169689Skan && TREE_CODE (TYPE_SIZE (a2)) == INTEGER_CST 1386169689Skan && tree_int_cst_equal (TYPE_SIZE (a2), 1387169689Skan TYPE_SIZE (a1))) 138818334Speter { 138918334Speter tree memb; 1390169689Skan for (memb = TYPE_FIELDS (a2); 139118334Speter memb; memb = TREE_CHAIN (memb)) 1392169689Skan { 1393169689Skan tree mv3 = TREE_TYPE (memb); 1394169689Skan if (mv3 && mv3 != error_mark_node 1395169689Skan && TREE_CODE (mv3) != ARRAY_TYPE) 1396169689Skan mv3 = TYPE_MAIN_VARIANT (mv3); 1397169689Skan if (comptypes_internal (mv3, mv1)) 1398169689Skan break; 1399169689Skan } 140018334Speter if (memb == 0) 140118334Speter return 0; 140218334Speter } 140318334Speter else 140418334Speter return 0; 140518334Speter } 140618334Speter 140718334Speter /* comptypes said ok, but record if it said to warn. */ 140818334Speter if (newval > val) 140918334Speter val = newval; 141018334Speter 141118334Speter args1 = TREE_CHAIN (args1); 141218334Speter args2 = TREE_CHAIN (args2); 141318334Speter } 141418334Speter} 141518334Speter 141618334Speter/* Compute the size to increment a pointer by. */ 141718334Speter 1418169689Skanstatic tree 1419132718Skanc_size_in_bytes (tree type) 142018334Speter{ 142118334Speter enum tree_code code = TREE_CODE (type); 142218334Speter 142390075Sobrien if (code == FUNCTION_TYPE || code == VOID_TYPE || code == ERROR_MARK) 142490075Sobrien return size_one_node; 142590075Sobrien 142690075Sobrien if (!COMPLETE_OR_VOID_TYPE_P (type)) 142718334Speter { 142818334Speter error ("arithmetic on pointer to an incomplete type"); 142990075Sobrien return size_one_node; 143018334Speter } 143118334Speter 143218334Speter /* Convert in case a char is more than one unit. */ 143390075Sobrien return size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type), 143490075Sobrien size_int (TYPE_PRECISION (char_type_node) 143590075Sobrien / BITS_PER_UNIT)); 143618334Speter} 143718334Speter 143890075Sobrien/* Return either DECL or its known constant value (if it has one). */ 143918334Speter 144018334Spetertree 1441132718Skandecl_constant_value (tree decl) 144218334Speter{ 144350397Sobrien if (/* Don't change a variable array bound or initial value to a constant 1444169689Skan in a place where a variable is invalid. Note that DECL_INITIAL 1445169689Skan isn't valid for a PARM_DECL. */ 144650397Sobrien current_function_decl != 0 1447169689Skan && TREE_CODE (decl) != PARM_DECL 1448169689Skan && !TREE_THIS_VOLATILE (decl) 144990075Sobrien && TREE_READONLY (decl) 145018334Speter && DECL_INITIAL (decl) != 0 145118334Speter && TREE_CODE (DECL_INITIAL (decl)) != ERROR_MARK 145218334Speter /* This is invalid if initial value is not constant. 145318334Speter If it has either a function call, a memory reference, 145418334Speter or a variable, then re-evaluating it could give different results. */ 145518334Speter && TREE_CONSTANT (DECL_INITIAL (decl)) 145618334Speter /* Check for cases where this is sub-optimal, even though valid. */ 145790075Sobrien && TREE_CODE (DECL_INITIAL (decl)) != CONSTRUCTOR) 145818334Speter return DECL_INITIAL (decl); 145918334Speter return decl; 146018334Speter} 146118334Speter 146290075Sobrien/* Return either DECL or its known constant value (if it has one), but 146390075Sobrien return DECL if pedantic or DECL has mode BLKmode. This is for 146490075Sobrien bug-compatibility with the old behavior of decl_constant_value 146590075Sobrien (before GCC 3.0); every use of this function is a bug and it should 146690075Sobrien be removed before GCC 3.1. It is not appropriate to use pedantic 146790075Sobrien in a way that affects optimization, and BLKmode is probably not the 146890075Sobrien right test for avoiding misoptimizations either. */ 146918334Speter 147090075Sobrienstatic tree 1471132718Skandecl_constant_value_for_broken_optimization (tree decl) 147218334Speter{ 1473169689Skan tree ret; 1474169689Skan 147590075Sobrien if (pedantic || DECL_MODE (decl) == BLKmode) 147690075Sobrien return decl; 1477169689Skan 1478169689Skan ret = decl_constant_value (decl); 1479169689Skan /* Avoid unwanted tree sharing between the initializer and current 1480169689Skan function's body where the tree can be modified e.g. by the 1481169689Skan gimplifier. */ 1482169689Skan if (ret != decl && TREE_STATIC (decl)) 1483169689Skan ret = unshare_expr (ret); 1484169689Skan return ret; 148590075Sobrien} 148618334Speter 1487169689Skan/* Convert the array expression EXP to a pointer. */ 148890075Sobrienstatic tree 1489169689Skanarray_to_pointer_conversion (tree exp) 149090075Sobrien{ 1491169689Skan tree orig_exp = exp; 149290075Sobrien tree type = TREE_TYPE (exp); 1493169689Skan tree adr; 1494169689Skan tree restype = TREE_TYPE (type); 1495169689Skan tree ptrtype; 149690075Sobrien 1497169689Skan gcc_assert (TREE_CODE (type) == ARRAY_TYPE); 149890075Sobrien 1499169689Skan STRIP_TYPE_NOPS (exp); 150018334Speter 1501169689Skan if (TREE_NO_WARNING (orig_exp)) 1502169689Skan TREE_NO_WARNING (exp) = 1; 150350397Sobrien 1504169689Skan ptrtype = build_pointer_type (restype); 1505169689Skan 1506169689Skan if (TREE_CODE (exp) == INDIRECT_REF) 1507169689Skan return convert (ptrtype, TREE_OPERAND (exp, 0)); 1508169689Skan 1509169689Skan if (TREE_CODE (exp) == VAR_DECL) 151018334Speter { 1511169689Skan /* We are making an ADDR_EXPR of ptrtype. This is a valid 1512169689Skan ADDR_EXPR because it's the best way of representing what 1513169689Skan happens in C when we take the address of an array and place 1514169689Skan it in a pointer to the element type. */ 1515169689Skan adr = build1 (ADDR_EXPR, ptrtype, exp); 1516169689Skan if (!c_mark_addressable (exp)) 1517169689Skan return error_mark_node; 1518169689Skan TREE_SIDE_EFFECTS (adr) = 0; /* Default would be, same as EXP. */ 1519169689Skan return adr; 152018334Speter } 152118334Speter 1522169689Skan /* This way is better for a COMPONENT_REF since it can 1523169689Skan simplify the offset for a component. */ 1524169689Skan adr = build_unary_op (ADDR_EXPR, exp, 1); 1525169689Skan return convert (ptrtype, adr); 1526169689Skan} 152718334Speter 1528169689Skan/* Convert the function expression EXP to a pointer. */ 1529169689Skanstatic tree 1530169689Skanfunction_to_pointer_conversion (tree exp) 1531169689Skan{ 1532169689Skan tree orig_exp = exp; 153318334Speter 1534169689Skan gcc_assert (TREE_CODE (TREE_TYPE (exp)) == FUNCTION_TYPE); 153518334Speter 1536169689Skan STRIP_TYPE_NOPS (exp); 153718334Speter 1538169689Skan if (TREE_NO_WARNING (orig_exp)) 1539169689Skan TREE_NO_WARNING (exp) = 1; 154018334Speter 1541169689Skan return build_unary_op (ADDR_EXPR, exp, 0); 154218334Speter} 154390075Sobrien 1544169689Skan/* Perform the default conversion of arrays and functions to pointers. 1545169689Skan Return the result of converting EXP. For any other expression, just 1546169689Skan return EXP after removing NOPs. */ 154790075Sobrien 1548169689Skanstruct c_expr 1549169689Skandefault_function_array_conversion (struct c_expr exp) 155090075Sobrien{ 1551169689Skan tree orig_exp = exp.value; 1552169689Skan tree type = TREE_TYPE (exp.value); 155390075Sobrien enum tree_code code = TREE_CODE (type); 155490075Sobrien 1555169689Skan switch (code) 1556169689Skan { 1557169689Skan case ARRAY_TYPE: 1558169689Skan { 1559169689Skan bool not_lvalue = false; 1560169689Skan bool lvalue_array_p; 156190075Sobrien 1562169689Skan while ((TREE_CODE (exp.value) == NON_LVALUE_EXPR 1563169689Skan || TREE_CODE (exp.value) == NOP_EXPR 1564169689Skan || TREE_CODE (exp.value) == CONVERT_EXPR) 1565169689Skan && TREE_TYPE (TREE_OPERAND (exp.value, 0)) == type) 1566169689Skan { 1567169689Skan if (TREE_CODE (exp.value) == NON_LVALUE_EXPR) 1568169689Skan not_lvalue = true; 1569169689Skan exp.value = TREE_OPERAND (exp.value, 0); 1570169689Skan } 157190075Sobrien 1572169689Skan if (TREE_NO_WARNING (orig_exp)) 1573169689Skan TREE_NO_WARNING (exp.value) = 1; 1574169689Skan 1575169689Skan lvalue_array_p = !not_lvalue && lvalue_p (exp.value); 1576169689Skan if (!flag_isoc99 && !lvalue_array_p) 1577169689Skan { 1578169689Skan /* Before C99, non-lvalue arrays do not decay to pointers. 1579169689Skan Normally, using such an array would be invalid; but it can 1580169689Skan be used correctly inside sizeof or as a statement expression. 1581169689Skan Thus, do not give an error here; an error will result later. */ 1582169689Skan return exp; 1583169689Skan } 1584169689Skan 1585169689Skan exp.value = array_to_pointer_conversion (exp.value); 1586169689Skan } 1587169689Skan break; 1588169689Skan case FUNCTION_TYPE: 1589169689Skan exp.value = function_to_pointer_conversion (exp.value); 1590169689Skan break; 1591169689Skan default: 1592169689Skan STRIP_TYPE_NOPS (exp.value); 1593169689Skan if (TREE_NO_WARNING (orig_exp)) 1594169689Skan TREE_NO_WARNING (exp.value) = 1; 1595169689Skan break; 159690075Sobrien } 159790075Sobrien 1598169689Skan return exp; 1599169689Skan} 160090075Sobrien 160190075Sobrien 1602169689Skan/* EXP is an expression of integer type. Apply the integer promotions 1603169689Skan to it and return the promoted value. */ 160490075Sobrien 1605169689Skantree 1606169689Skanperform_integral_promotions (tree exp) 1607169689Skan{ 1608169689Skan tree type = TREE_TYPE (exp); 1609169689Skan enum tree_code code = TREE_CODE (type); 1610169689Skan 1611169689Skan gcc_assert (INTEGRAL_TYPE_P (type)); 1612169689Skan 161390075Sobrien /* Normally convert enums to int, 161490075Sobrien but convert wide enums to something wider. */ 161590075Sobrien if (code == ENUMERAL_TYPE) 161690075Sobrien { 1617117395Skan type = c_common_type_for_size (MAX (TYPE_PRECISION (type), 1618117395Skan TYPE_PRECISION (integer_type_node)), 1619117395Skan ((TYPE_PRECISION (type) 1620117395Skan >= TYPE_PRECISION (integer_type_node)) 1621169689Skan && TYPE_UNSIGNED (type))); 162290075Sobrien 162390075Sobrien return convert (type, exp); 162490075Sobrien } 162590075Sobrien 1626169689Skan /* ??? This should no longer be needed now bit-fields have their 1627169689Skan proper types. */ 162890075Sobrien if (TREE_CODE (exp) == COMPONENT_REF 162990075Sobrien && DECL_C_BIT_FIELD (TREE_OPERAND (exp, 1)) 163090075Sobrien /* If it's thinner than an int, promote it like a 163190075Sobrien c_promoting_integer_type_p, otherwise leave it alone. */ 163290075Sobrien && 0 > compare_tree_int (DECL_SIZE (TREE_OPERAND (exp, 1)), 163390075Sobrien TYPE_PRECISION (integer_type_node))) 1634117395Skan return convert (integer_type_node, exp); 163590075Sobrien 163690075Sobrien if (c_promoting_integer_type_p (type)) 163790075Sobrien { 1638117395Skan /* Preserve unsignedness if not really getting any wider. */ 1639169689Skan if (TYPE_UNSIGNED (type) 1640117395Skan && TYPE_PRECISION (type) == TYPE_PRECISION (integer_type_node)) 164190075Sobrien return convert (unsigned_type_node, exp); 164290075Sobrien 164390075Sobrien return convert (integer_type_node, exp); 164490075Sobrien } 164590075Sobrien 1646169689Skan return exp; 1647169689Skan} 1648169689Skan 1649169689Skan 1650169689Skan/* Perform default promotions for C data used in expressions. 1651169689Skan Enumeral types or short or char are converted to int. 1652169689Skan In addition, manifest constants symbols are replaced by their values. */ 1653169689Skan 1654169689Skantree 1655169689Skandefault_conversion (tree exp) 1656169689Skan{ 1657169689Skan tree orig_exp; 1658169689Skan tree type = TREE_TYPE (exp); 1659169689Skan enum tree_code code = TREE_CODE (type); 1660169689Skan 1661169689Skan /* Functions and arrays have been converted during parsing. */ 1662169689Skan gcc_assert (code != FUNCTION_TYPE); 1663169689Skan if (code == ARRAY_TYPE) 1664169689Skan return exp; 1665169689Skan 1666169689Skan /* Constants can be used directly unless they're not loadable. */ 1667169689Skan if (TREE_CODE (exp) == CONST_DECL) 1668169689Skan exp = DECL_INITIAL (exp); 1669169689Skan 1670169689Skan /* Replace a nonvolatile const static variable with its value unless 1671169689Skan it is an array, in which case we must be sure that taking the 1672169689Skan address of the array produces consistent results. */ 1673169689Skan else if (optimize && TREE_CODE (exp) == VAR_DECL && code != ARRAY_TYPE) 1674169689Skan { 1675169689Skan exp = decl_constant_value_for_broken_optimization (exp); 1676169689Skan type = TREE_TYPE (exp); 1677169689Skan } 1678169689Skan 1679169689Skan /* Strip no-op conversions. */ 1680169689Skan orig_exp = exp; 1681169689Skan STRIP_TYPE_NOPS (exp); 1682169689Skan 1683169689Skan if (TREE_NO_WARNING (orig_exp)) 1684169689Skan TREE_NO_WARNING (exp) = 1; 1685169689Skan 1686169689Skan if (INTEGRAL_TYPE_P (type)) 1687169689Skan return perform_integral_promotions (exp); 1688169689Skan 168990075Sobrien if (code == VOID_TYPE) 169090075Sobrien { 169190075Sobrien error ("void value not ignored as it ought to be"); 169290075Sobrien return error_mark_node; 169390075Sobrien } 169490075Sobrien return exp; 169590075Sobrien} 169618334Speter 169790075Sobrien/* Look up COMPONENT in a structure or union DECL. 169818334Speter 169990075Sobrien If the component name is not found, returns NULL_TREE. Otherwise, 170090075Sobrien the return value is a TREE_LIST, with each TREE_VALUE a FIELD_DECL 170190075Sobrien stepping down the chain to the component, which is in the last 170290075Sobrien TREE_VALUE of the list. Normally the list is of length one, but if 170390075Sobrien the component is embedded within (nested) anonymous structures or 170490075Sobrien unions, the list steps down the chain to the component. */ 1705132718Skan 170618334Speterstatic tree 1707132718Skanlookup_field (tree decl, tree component) 170818334Speter{ 170990075Sobrien tree type = TREE_TYPE (decl); 171018334Speter tree field; 171118334Speter 171218334Speter /* If TYPE_LANG_SPECIFIC is set, then it is a sorted array of pointers 171318334Speter to the field elements. Use a binary search on this array to quickly 171418334Speter find the element. Otherwise, do a linear search. TYPE_LANG_SPECIFIC 171518334Speter will always be set for structures which have many elements. */ 171618334Speter 1717169689Skan if (TYPE_LANG_SPECIFIC (type) && TYPE_LANG_SPECIFIC (type)->s) 171818334Speter { 171918334Speter int bot, top, half; 1720132718Skan tree *field_array = &TYPE_LANG_SPECIFIC (type)->s->elts[0]; 172118334Speter 172218334Speter field = TYPE_FIELDS (type); 172318334Speter bot = 0; 1724132718Skan top = TYPE_LANG_SPECIFIC (type)->s->len; 172518334Speter while (top - bot > 1) 172618334Speter { 172718334Speter half = (top - bot + 1) >> 1; 172818334Speter field = field_array[bot+half]; 172918334Speter 173018334Speter if (DECL_NAME (field) == NULL_TREE) 173118334Speter { 173218334Speter /* Step through all anon unions in linear fashion. */ 173318334Speter while (DECL_NAME (field_array[bot]) == NULL_TREE) 173418334Speter { 173518334Speter field = field_array[bot++]; 173650397Sobrien if (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE 173750397Sobrien || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE) 173890075Sobrien { 173990075Sobrien tree anon = lookup_field (field, component); 174050397Sobrien 174190075Sobrien if (anon) 174290075Sobrien return tree_cons (NULL_TREE, field, anon); 1743132718Skan } 174418334Speter } 174518334Speter 174618334Speter /* Entire record is only anon unions. */ 174718334Speter if (bot > top) 174818334Speter return NULL_TREE; 174918334Speter 175018334Speter /* Restart the binary search, with new lower bound. */ 175118334Speter continue; 175218334Speter } 175318334Speter 175418334Speter if (DECL_NAME (field) == component) 175518334Speter break; 175618334Speter if (DECL_NAME (field) < component) 175718334Speter bot += half; 175818334Speter else 175918334Speter top = bot + half; 176018334Speter } 176118334Speter 176218334Speter if (DECL_NAME (field_array[bot]) == component) 176318334Speter field = field_array[bot]; 176418334Speter else if (DECL_NAME (field) != component) 176590075Sobrien return NULL_TREE; 176618334Speter } 176718334Speter else 176818334Speter { 176918334Speter for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 177018334Speter { 177190075Sobrien if (DECL_NAME (field) == NULL_TREE 177290075Sobrien && (TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE 177390075Sobrien || TREE_CODE (TREE_TYPE (field)) == UNION_TYPE)) 177418334Speter { 177590075Sobrien tree anon = lookup_field (field, component); 177650397Sobrien 177790075Sobrien if (anon) 177890075Sobrien return tree_cons (NULL_TREE, field, anon); 177918334Speter } 178018334Speter 178118334Speter if (DECL_NAME (field) == component) 178218334Speter break; 178318334Speter } 178490075Sobrien 178590075Sobrien if (field == NULL_TREE) 178690075Sobrien return NULL_TREE; 178718334Speter } 178818334Speter 178990075Sobrien return tree_cons (NULL_TREE, field, NULL_TREE); 179018334Speter} 179118334Speter 179218334Speter/* Make an expression to refer to the COMPONENT field of 179318334Speter structure or union value DATUM. COMPONENT is an IDENTIFIER_NODE. */ 179418334Speter 179518334Spetertree 1796132718Skanbuild_component_ref (tree datum, tree component) 179718334Speter{ 179890075Sobrien tree type = TREE_TYPE (datum); 179990075Sobrien enum tree_code code = TREE_CODE (type); 180090075Sobrien tree field = NULL; 180190075Sobrien tree ref; 180218334Speter 1803169689Skan if (!objc_is_public (datum, component)) 1804169689Skan return error_mark_node; 1805169689Skan 180618334Speter /* See if there is a field or component with name COMPONENT. */ 180718334Speter 180818334Speter if (code == RECORD_TYPE || code == UNION_TYPE) 180918334Speter { 181090075Sobrien if (!COMPLETE_TYPE_P (type)) 181118334Speter { 1812117395Skan c_incomplete_type_error (NULL_TREE, type); 181318334Speter return error_mark_node; 181418334Speter } 181518334Speter 181690075Sobrien field = lookup_field (datum, component); 181718334Speter 181818334Speter if (!field) 181918334Speter { 1820169689Skan error ("%qT has no member named %qE", type, component); 182118334Speter return error_mark_node; 182218334Speter } 182318334Speter 182490075Sobrien /* Chain the COMPONENT_REFs if necessary down to the FIELD. 182590075Sobrien This might be better solved in future the way the C++ front 182690075Sobrien end does it - by giving the anonymous entities each a 182790075Sobrien separate name and type, and then have build_component_ref 182890075Sobrien recursively call itself. We can't do that here. */ 1829117395Skan do 183018334Speter { 183190075Sobrien tree subdatum = TREE_VALUE (field); 1832169689Skan int quals; 1833169689Skan tree subtype; 183490075Sobrien 183590075Sobrien if (TREE_TYPE (subdatum) == error_mark_node) 183690075Sobrien return error_mark_node; 183790075Sobrien 1838169689Skan quals = TYPE_QUALS (strip_array_types (TREE_TYPE (subdatum))); 1839169689Skan quals |= TYPE_QUALS (TREE_TYPE (datum)); 1840169689Skan subtype = c_build_qualified_type (TREE_TYPE (subdatum), quals); 1841169689Skan 1842169689Skan ref = build3 (COMPONENT_REF, subtype, datum, subdatum, 1843169689Skan NULL_TREE); 184490075Sobrien if (TREE_READONLY (datum) || TREE_READONLY (subdatum)) 184518334Speter TREE_READONLY (ref) = 1; 184690075Sobrien if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (subdatum)) 184718334Speter TREE_THIS_VOLATILE (ref) = 1; 184890075Sobrien 184990075Sobrien if (TREE_DEPRECATED (subdatum)) 185090075Sobrien warn_deprecated_use (subdatum); 185190075Sobrien 185218334Speter datum = ref; 1853117395Skan 1854117395Skan field = TREE_CHAIN (field); 185518334Speter } 1856117395Skan while (field); 185718334Speter 185818334Speter return ref; 185918334Speter } 186018334Speter else if (code != ERROR_MARK) 1861169689Skan error ("request for member %qE in something not a structure or union", 1862169689Skan component); 186318334Speter 186418334Speter return error_mark_node; 186518334Speter} 186618334Speter 186718334Speter/* Given an expression PTR for a pointer, return an expression 186818334Speter for the value pointed to. 186918334Speter ERRORSTRING is the name of the operator to appear in error messages. */ 187018334Speter 187118334Spetertree 1872132718Skanbuild_indirect_ref (tree ptr, const char *errorstring) 187318334Speter{ 187490075Sobrien tree pointer = default_conversion (ptr); 187590075Sobrien tree type = TREE_TYPE (pointer); 187618334Speter 187718334Speter if (TREE_CODE (type) == POINTER_TYPE) 187818334Speter { 187918334Speter if (TREE_CODE (pointer) == ADDR_EXPR 188018334Speter && (TREE_TYPE (TREE_OPERAND (pointer, 0)) 188118334Speter == TREE_TYPE (type))) 188218334Speter return TREE_OPERAND (pointer, 0); 188318334Speter else 188418334Speter { 188518334Speter tree t = TREE_TYPE (type); 1886169689Skan tree ref; 188718334Speter 1888169689Skan ref = build1 (INDIRECT_REF, t, pointer); 1889169689Skan 189090075Sobrien if (!COMPLETE_OR_VOID_TYPE_P (t) && TREE_CODE (t) != ARRAY_TYPE) 189118334Speter { 189218334Speter error ("dereferencing pointer to incomplete type"); 189318334Speter return error_mark_node; 189418334Speter } 189590075Sobrien if (VOID_TYPE_P (t) && skip_evaluation == 0) 1896169689Skan warning (0, "dereferencing %<void *%> pointer"); 189718334Speter 189818334Speter /* We *must* set TREE_READONLY when dereferencing a pointer to const, 189918334Speter so that we get the proper error message if the result is used 190018334Speter to assign to. Also, &* is supposed to be a no-op. 190118334Speter And ANSI C seems to specify that the type of the result 190218334Speter should be the const type. */ 190318334Speter /* A de-reference of a pointer to const is not a const. It is valid 190418334Speter to change it via some other pointer. */ 190518334Speter TREE_READONLY (ref) = TYPE_READONLY (t); 190618334Speter TREE_SIDE_EFFECTS (ref) 1907132718Skan = TYPE_VOLATILE (t) || TREE_SIDE_EFFECTS (pointer); 190818334Speter TREE_THIS_VOLATILE (ref) = TYPE_VOLATILE (t); 190918334Speter return ref; 191018334Speter } 191118334Speter } 191218334Speter else if (TREE_CODE (pointer) != ERROR_MARK) 1913169689Skan error ("invalid type argument of %qs", errorstring); 191418334Speter return error_mark_node; 191518334Speter} 191618334Speter 191718334Speter/* This handles expressions of the form "a[i]", which denotes 191818334Speter an array reference. 191918334Speter 192018334Speter This is logically equivalent in C to *(a+i), but we may do it differently. 192118334Speter If A is a variable or a member, we generate a primitive ARRAY_REF. 192218334Speter This avoids forcing the array out of registers, and can work on 192318334Speter arrays that are not lvalues (for example, members of structures returned 192418334Speter by functions). */ 192518334Speter 192618334Spetertree 1927132718Skanbuild_array_ref (tree array, tree index) 192818334Speter{ 1929169689Skan bool swapped = false; 193018334Speter if (TREE_TYPE (array) == error_mark_node 193118334Speter || TREE_TYPE (index) == error_mark_node) 193218334Speter return error_mark_node; 193318334Speter 1934169689Skan if (TREE_CODE (TREE_TYPE (array)) != ARRAY_TYPE 1935169689Skan && TREE_CODE (TREE_TYPE (array)) != POINTER_TYPE) 193618334Speter { 1937169689Skan tree temp; 1938169689Skan if (TREE_CODE (TREE_TYPE (index)) != ARRAY_TYPE 1939169689Skan && TREE_CODE (TREE_TYPE (index)) != POINTER_TYPE) 194018334Speter { 1941169689Skan error ("subscripted value is neither array nor pointer"); 194218334Speter return error_mark_node; 194318334Speter } 1944169689Skan temp = array; 1945169689Skan array = index; 1946169689Skan index = temp; 1947169689Skan swapped = true; 1948169689Skan } 194918334Speter 1950169689Skan if (!INTEGRAL_TYPE_P (TREE_TYPE (index))) 1951169689Skan { 1952169689Skan error ("array subscript is not an integer"); 1953169689Skan return error_mark_node; 1954169689Skan } 1955169689Skan 1956169689Skan if (TREE_CODE (TREE_TYPE (TREE_TYPE (array))) == FUNCTION_TYPE) 1957169689Skan { 1958169689Skan error ("subscripted value is pointer to function"); 1959169689Skan return error_mark_node; 1960169689Skan } 1961169689Skan 1962169689Skan /* ??? Existing practice has been to warn only when the char 1963169689Skan index is syntactically the index, not for char[array]. */ 1964169689Skan if (!swapped) 1965169689Skan warn_array_subscript_with_type_char (index); 1966169689Skan 1967169689Skan /* Apply default promotions *after* noticing character types. */ 1968169689Skan index = default_conversion (index); 1969169689Skan 1970169689Skan gcc_assert (TREE_CODE (TREE_TYPE (index)) == INTEGER_TYPE); 1971169689Skan 1972169689Skan if (TREE_CODE (TREE_TYPE (array)) == ARRAY_TYPE) 1973169689Skan { 1974169689Skan tree rval, type; 1975169689Skan 197618334Speter /* An array that is indexed by a non-constant 197718334Speter cannot be stored in a register; we must be able to do 197818334Speter address arithmetic on its address. 197918334Speter Likewise an array of elements of variable size. */ 198018334Speter if (TREE_CODE (index) != INTEGER_CST 198190075Sobrien || (COMPLETE_TYPE_P (TREE_TYPE (TREE_TYPE (array))) 198218334Speter && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (array)))) != INTEGER_CST)) 198318334Speter { 1984117395Skan if (!c_mark_addressable (array)) 198518334Speter return error_mark_node; 198618334Speter } 198718334Speter /* An array that is indexed by a constant value which is not within 198818334Speter the array bounds cannot be stored in a register either; because we 198918334Speter would get a crash in store_bit_field/extract_bit_field when trying 199018334Speter to access a non-existent part of the register. */ 199118334Speter if (TREE_CODE (index) == INTEGER_CST 1992169689Skan && TYPE_DOMAIN (TREE_TYPE (array)) 1993169689Skan && !int_fits_type_p (index, TYPE_DOMAIN (TREE_TYPE (array)))) 199418334Speter { 1995117395Skan if (!c_mark_addressable (array)) 199618334Speter return error_mark_node; 199718334Speter } 199818334Speter 199918334Speter if (pedantic) 200018334Speter { 200118334Speter tree foo = array; 200218334Speter while (TREE_CODE (foo) == COMPONENT_REF) 200318334Speter foo = TREE_OPERAND (foo, 0); 2004169689Skan if (TREE_CODE (foo) == VAR_DECL && C_DECL_REGISTER (foo)) 2005169689Skan pedwarn ("ISO C forbids subscripting %<register%> array"); 2006169689Skan else if (!flag_isoc99 && !lvalue_p (foo)) 2007117395Skan pedwarn ("ISO C90 forbids subscripting non-lvalue array"); 200818334Speter } 200918334Speter 2010169689Skan type = TREE_TYPE (TREE_TYPE (array)); 2011169689Skan if (TREE_CODE (type) != ARRAY_TYPE) 2012169689Skan type = TYPE_MAIN_VARIANT (type); 2013169689Skan rval = build4 (ARRAY_REF, type, array, index, NULL_TREE, NULL_TREE); 201418334Speter /* Array ref is const/volatile if the array elements are 2015169689Skan or if the array is. */ 201618334Speter TREE_READONLY (rval) 201718334Speter |= (TYPE_READONLY (TREE_TYPE (TREE_TYPE (array))) 201818334Speter | TREE_READONLY (array)); 201918334Speter TREE_SIDE_EFFECTS (rval) 202018334Speter |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array))) 202118334Speter | TREE_SIDE_EFFECTS (array)); 202218334Speter TREE_THIS_VOLATILE (rval) 202318334Speter |= (TYPE_VOLATILE (TREE_TYPE (TREE_TYPE (array))) 202418334Speter /* This was added by rms on 16 Nov 91. 2025132718Skan It fixes vol struct foo *a; a->elts[1] 202618334Speter in an inline function. 202718334Speter Hope it doesn't break something else. */ 202818334Speter | TREE_THIS_VOLATILE (array)); 202918334Speter return require_complete_type (fold (rval)); 203018334Speter } 2031169689Skan else 2032169689Skan { 2033169689Skan tree ar = default_conversion (array); 203418334Speter 2035169689Skan if (ar == error_mark_node) 2036169689Skan return ar; 203718334Speter 2038169689Skan gcc_assert (TREE_CODE (TREE_TYPE (ar)) == POINTER_TYPE); 2039169689Skan gcc_assert (TREE_CODE (TREE_TYPE (TREE_TYPE (ar))) != FUNCTION_TYPE); 204050397Sobrien 2041169689Skan return build_indirect_ref (build_binary_op (PLUS_EXPR, ar, index, 0), 2042169689Skan "array indexing"); 2043169689Skan } 204418334Speter} 204518334Speter 204690075Sobrien/* Build an external reference to identifier ID. FUN indicates 2047169689Skan whether this will be used for a function call. LOC is the source 2048169689Skan location of the identifier. */ 204990075Sobrientree 2050169689Skanbuild_external_ref (tree id, int fun, location_t loc) 205190075Sobrien{ 205290075Sobrien tree ref; 205390075Sobrien tree decl = lookup_name (id); 205490075Sobrien 2055169689Skan /* In Objective-C, an instance variable (ivar) may be preferred to 2056169689Skan whatever lookup_name() found. */ 2057169689Skan decl = objc_lookup_ivar (decl, id); 2058169689Skan 2059132718Skan if (decl && decl != error_mark_node) 2060169689Skan ref = decl; 2061132718Skan else if (fun) 2062132718Skan /* Implicit function declaration. */ 2063132718Skan ref = implicitly_declare (id); 2064132718Skan else if (decl == error_mark_node) 2065132718Skan /* Don't complain about something that's already been 2066132718Skan complained about. */ 2067132718Skan return error_mark_node; 2068132718Skan else 2069132718Skan { 2070169689Skan undeclared_variable (id, loc); 2071132718Skan return error_mark_node; 2072132718Skan } 207390075Sobrien 207490075Sobrien if (TREE_TYPE (ref) == error_mark_node) 207590075Sobrien return error_mark_node; 207690075Sobrien 2077132718Skan if (TREE_DEPRECATED (ref)) 2078132718Skan warn_deprecated_use (ref); 2079132718Skan 2080103445Skan if (!skip_evaluation) 2081103445Skan assemble_external (ref); 208290075Sobrien TREE_USED (ref) = 1; 208390075Sobrien 2084169689Skan if (TREE_CODE (ref) == FUNCTION_DECL && !in_alignof) 2085169689Skan { 2086169689Skan if (!in_sizeof && !in_typeof) 2087169689Skan C_DECL_USED (ref) = 1; 2088169689Skan else if (DECL_INITIAL (ref) == 0 2089169689Skan && DECL_EXTERNAL (ref) 2090169689Skan && !TREE_PUBLIC (ref)) 2091169689Skan record_maybe_used_decl (ref); 2092169689Skan } 2093169689Skan 209490075Sobrien if (TREE_CODE (ref) == CONST_DECL) 209590075Sobrien { 2096169689Skan used_types_insert (TREE_TYPE (ref)); 209790075Sobrien ref = DECL_INITIAL (ref); 209890075Sobrien TREE_CONSTANT (ref) = 1; 2099169689Skan TREE_INVARIANT (ref) = 1; 210090075Sobrien } 2101117395Skan else if (current_function_decl != 0 2102132718Skan && !DECL_FILE_SCOPE_P (current_function_decl) 2103117395Skan && (TREE_CODE (ref) == VAR_DECL 2104117395Skan || TREE_CODE (ref) == PARM_DECL 2105117395Skan || TREE_CODE (ref) == FUNCTION_DECL)) 2106117395Skan { 2107117395Skan tree context = decl_function_context (ref); 2108132718Skan 2109117395Skan if (context != 0 && context != current_function_decl) 2110117395Skan DECL_NONLOCAL (ref) = 1; 2111117395Skan } 211290075Sobrien 211390075Sobrien return ref; 211490075Sobrien} 211590075Sobrien 2116169689Skan/* Record details of decls possibly used inside sizeof or typeof. */ 2117169689Skanstruct maybe_used_decl 2118169689Skan{ 2119169689Skan /* The decl. */ 2120169689Skan tree decl; 2121169689Skan /* The level seen at (in_sizeof + in_typeof). */ 2122169689Skan int level; 2123169689Skan /* The next one at this level or above, or NULL. */ 2124169689Skan struct maybe_used_decl *next; 2125169689Skan}; 2126169689Skan 2127169689Skanstatic struct maybe_used_decl *maybe_used_decls; 2128169689Skan 2129169689Skan/* Record that DECL, an undefined static function reference seen 2130169689Skan inside sizeof or typeof, might be used if the operand of sizeof is 2131169689Skan a VLA type or the operand of typeof is a variably modified 2132169689Skan type. */ 2133169689Skan 2134169689Skanstatic void 2135169689Skanrecord_maybe_used_decl (tree decl) 2136169689Skan{ 2137169689Skan struct maybe_used_decl *t = XOBNEW (&parser_obstack, struct maybe_used_decl); 2138169689Skan t->decl = decl; 2139169689Skan t->level = in_sizeof + in_typeof; 2140169689Skan t->next = maybe_used_decls; 2141169689Skan maybe_used_decls = t; 2142169689Skan} 2143169689Skan 2144169689Skan/* Pop the stack of decls possibly used inside sizeof or typeof. If 2145169689Skan USED is false, just discard them. If it is true, mark them used 2146169689Skan (if no longer inside sizeof or typeof) or move them to the next 2147169689Skan level up (if still inside sizeof or typeof). */ 2148169689Skan 2149169689Skanvoid 2150169689Skanpop_maybe_used (bool used) 2151169689Skan{ 2152169689Skan struct maybe_used_decl *p = maybe_used_decls; 2153169689Skan int cur_level = in_sizeof + in_typeof; 2154169689Skan while (p && p->level > cur_level) 2155169689Skan { 2156169689Skan if (used) 2157169689Skan { 2158169689Skan if (cur_level == 0) 2159169689Skan C_DECL_USED (p->decl) = 1; 2160169689Skan else 2161169689Skan p->level = cur_level; 2162169689Skan } 2163169689Skan p = p->next; 2164169689Skan } 2165169689Skan if (!used || cur_level == 0) 2166169689Skan maybe_used_decls = p; 2167169689Skan} 2168169689Skan 2169169689Skan/* Return the result of sizeof applied to EXPR. */ 2170169689Skan 2171169689Skanstruct c_expr 2172169689Skanc_expr_sizeof_expr (struct c_expr expr) 2173169689Skan{ 2174169689Skan struct c_expr ret; 2175169689Skan if (expr.value == error_mark_node) 2176169689Skan { 2177169689Skan ret.value = error_mark_node; 2178169689Skan ret.original_code = ERROR_MARK; 2179169689Skan pop_maybe_used (false); 2180169689Skan } 2181169689Skan else 2182169689Skan { 2183169689Skan ret.value = c_sizeof (TREE_TYPE (expr.value)); 2184169689Skan ret.original_code = ERROR_MARK; 2185169689Skan if (c_vla_type_p (TREE_TYPE (expr.value))) 2186169689Skan { 2187169689Skan /* sizeof is evaluated when given a vla (C99 6.5.3.4p2). */ 2188169689Skan ret.value = build2 (COMPOUND_EXPR, TREE_TYPE (ret.value), expr.value, ret.value); 2189169689Skan } 2190169689Skan pop_maybe_used (C_TYPE_VARIABLE_SIZE (TREE_TYPE (expr.value))); 2191169689Skan } 2192169689Skan return ret; 2193169689Skan} 2194169689Skan 2195169689Skan/* Return the result of sizeof applied to T, a structure for the type 2196169689Skan name passed to sizeof (rather than the type itself). */ 2197169689Skan 2198169689Skanstruct c_expr 2199169689Skanc_expr_sizeof_type (struct c_type_name *t) 2200169689Skan{ 2201169689Skan tree type; 2202169689Skan struct c_expr ret; 2203169689Skan type = groktypename (t); 2204169689Skan ret.value = c_sizeof (type); 2205169689Skan ret.original_code = ERROR_MARK; 2206169689Skan pop_maybe_used (type != error_mark_node 2207169689Skan ? C_TYPE_VARIABLE_SIZE (type) : false); 2208169689Skan return ret; 2209169689Skan} 2210169689Skan 221118334Speter/* Build a function call to function FUNCTION with parameters PARAMS. 221218334Speter PARAMS is a list--a chain of TREE_LIST nodes--in which the 221318334Speter TREE_VALUE of each node is a parameter-expression. 221418334Speter FUNCTION's data type may be a function type or a pointer-to-function. */ 221518334Speter 221618334Spetertree 2217132718Skanbuild_function_call (tree function, tree params) 221818334Speter{ 221990075Sobrien tree fntype, fundecl = 0; 222090075Sobrien tree coerced_params; 2221132718Skan tree name = NULL_TREE, result; 2222132718Skan tree tem; 222318334Speter 222418334Speter /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */ 222518334Speter STRIP_TYPE_NOPS (function); 222618334Speter 222718334Speter /* Convert anything with function type to a pointer-to-function. */ 222818334Speter if (TREE_CODE (function) == FUNCTION_DECL) 222918334Speter { 2230169689Skan /* Implement type-directed function overloading for builtins. 2231169689Skan resolve_overloaded_builtin and targetm.resolve_overloaded_builtin 2232169689Skan handle all the type checking. The result is a complete expression 2233169689Skan that implements this function call. */ 2234169689Skan tem = resolve_overloaded_builtin (function, params); 2235169689Skan if (tem) 2236169689Skan return tem; 2237169689Skan 223818334Speter name = DECL_NAME (function); 223918334Speter fundecl = function; 224018334Speter } 2241169689Skan if (TREE_CODE (TREE_TYPE (function)) == FUNCTION_TYPE) 2242169689Skan function = function_to_pointer_conversion (function); 224318334Speter 2244169689Skan /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF 2245169689Skan expressions, like those used for ObjC messenger dispatches. */ 2246169689Skan function = objc_rewrite_function_call (function, params); 2247169689Skan 224818334Speter fntype = TREE_TYPE (function); 224918334Speter 225018334Speter if (TREE_CODE (fntype) == ERROR_MARK) 225118334Speter return error_mark_node; 225218334Speter 225318334Speter if (!(TREE_CODE (fntype) == POINTER_TYPE 225418334Speter && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE)) 225518334Speter { 2256169689Skan error ("called object %qE is not a function", function); 225718334Speter return error_mark_node; 225818334Speter } 225918334Speter 226096263Sobrien if (fundecl && TREE_THIS_VOLATILE (fundecl)) 226196263Sobrien current_function_returns_abnormally = 1; 226296263Sobrien 226318334Speter /* fntype now gets the type of function pointed to. */ 226418334Speter fntype = TREE_TYPE (fntype); 226518334Speter 2266132718Skan /* Check that the function is called through a compatible prototype. 2267132718Skan If it is not, replace the call by a trap, wrapped up in a compound 2268132718Skan expression if necessary. This has the nice side-effect to prevent 2269132718Skan the tree-inliner from generating invalid assignment trees which may 2270169689Skan blow up in the RTL expander later. */ 2271169689Skan if ((TREE_CODE (function) == NOP_EXPR 2272169689Skan || TREE_CODE (function) == CONVERT_EXPR) 2273132718Skan && TREE_CODE (tem = TREE_OPERAND (function, 0)) == ADDR_EXPR 2274132718Skan && TREE_CODE (tem = TREE_OPERAND (tem, 0)) == FUNCTION_DECL 2275169689Skan && !comptypes (fntype, TREE_TYPE (tem))) 2276132718Skan { 2277132718Skan tree return_type = TREE_TYPE (fntype); 2278132718Skan tree trap = build_function_call (built_in_decls[BUILT_IN_TRAP], 2279132718Skan NULL_TREE); 2280132718Skan 2281132718Skan /* This situation leads to run-time undefined behavior. We can't, 2282132718Skan therefore, simply error unless we can prove that all possible 2283132718Skan executions of the program must execute the code. */ 2284169689Skan warning (0, "function called through a non-compatible type"); 2285132718Skan 2286132718Skan /* We can, however, treat "undefined" any way we please. 2287132718Skan Call abort to encourage the user to fix the program. */ 2288132718Skan inform ("if this code is reached, the program will abort"); 2289132718Skan 2290132718Skan if (VOID_TYPE_P (return_type)) 2291132718Skan return trap; 2292132718Skan else 2293132718Skan { 2294132718Skan tree rhs; 2295132718Skan 2296132718Skan if (AGGREGATE_TYPE_P (return_type)) 2297132718Skan rhs = build_compound_literal (return_type, 2298169689Skan build_constructor (return_type, 0)); 2299132718Skan else 2300169689Skan rhs = fold_convert (return_type, integer_zero_node); 2301132718Skan 2302169689Skan return build2 (COMPOUND_EXPR, return_type, trap, rhs); 2303132718Skan } 2304132718Skan } 2305132718Skan 230618334Speter /* Convert the parameters to the types declared in the 230718334Speter function prototype, or apply default promotions. */ 230818334Speter 230918334Speter coerced_params 2310169689Skan = convert_arguments (TYPE_ARG_TYPES (fntype), params, function, fundecl); 231118334Speter 2312169689Skan if (coerced_params == error_mark_node) 2313169689Skan return error_mark_node; 2314169689Skan 2315117395Skan /* Check that the arguments to the function are valid. */ 231618334Speter 2317169689Skan check_function_arguments (TYPE_ATTRIBUTES (fntype), coerced_params, 2318169689Skan TYPE_ARG_TYPES (fntype)); 231918334Speter 2320132718Skan if (require_constant_value) 2321132718Skan { 2322169689Skan result = fold_build3_initializer (CALL_EXPR, TREE_TYPE (fntype), 2323169689Skan function, coerced_params, NULL_TREE); 2324132718Skan 2325132718Skan if (TREE_CONSTANT (result) 2326132718Skan && (name == NULL_TREE 2327132718Skan || strncmp (IDENTIFIER_POINTER (name), "__builtin_", 10) != 0)) 2328132718Skan pedwarn_init ("initializer element is not constant"); 2329132718Skan } 2330132718Skan else 2331169689Skan result = fold_build3 (CALL_EXPR, TREE_TYPE (fntype), 2332169689Skan function, coerced_params, NULL_TREE); 2333132718Skan 233490075Sobrien if (VOID_TYPE_P (TREE_TYPE (result))) 233590075Sobrien return result; 233690075Sobrien return require_complete_type (result); 233718334Speter} 233818334Speter 233918334Speter/* Convert the argument expressions in the list VALUES 234018334Speter to the types in the list TYPELIST. The result is a list of converted 2341169689Skan argument expressions, unless there are too few arguments in which 2342169689Skan case it is error_mark_node. 234318334Speter 234418334Speter If TYPELIST is exhausted, or when an element has NULL as its type, 234518334Speter perform the default conversions. 234618334Speter 234718334Speter PARMLIST is the chain of parm decls for the function being called. 234818334Speter It may be 0, if that info is not available. 234918334Speter It is used only for generating error messages. 235018334Speter 2351169689Skan FUNCTION is a tree for the called function. It is used only for 2352169689Skan error messages, where it is formatted with %qE. 235318334Speter 235418334Speter This is also where warnings about wrong number of args are generated. 235518334Speter 235618334Speter Both VALUES and the returned value are chains of TREE_LIST nodes 235718334Speter with the elements of the list in the TREE_VALUE slots of those nodes. */ 235818334Speter 235918334Speterstatic tree 2360169689Skanconvert_arguments (tree typelist, tree values, tree function, tree fundecl) 236118334Speter{ 236290075Sobrien tree typetail, valtail; 236390075Sobrien tree result = NULL; 236418334Speter int parmnum; 2365169689Skan tree selector; 236618334Speter 2367169689Skan /* Change pointer to function to the function itself for 2368169689Skan diagnostics. */ 2369169689Skan if (TREE_CODE (function) == ADDR_EXPR 2370169689Skan && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL) 2371169689Skan function = TREE_OPERAND (function, 0); 2372169689Skan 2373169689Skan /* Handle an ObjC selector specially for diagnostics. */ 2374169689Skan selector = objc_message_selector (); 2375169689Skan 237618334Speter /* Scan the given expressions and types, producing individual 237718334Speter converted arguments and pushing them on RESULT in reverse order. */ 237818334Speter 237918334Speter for (valtail = values, typetail = typelist, parmnum = 0; 238018334Speter valtail; 238118334Speter valtail = TREE_CHAIN (valtail), parmnum++) 238218334Speter { 238390075Sobrien tree type = typetail ? TREE_VALUE (typetail) : 0; 238490075Sobrien tree val = TREE_VALUE (valtail); 2385169689Skan tree rname = function; 2386169689Skan int argnum = parmnum + 1; 2387169689Skan const char *invalid_func_diag; 238818334Speter 238918334Speter if (type == void_type_node) 239018334Speter { 2391169689Skan error ("too many arguments to function %qE", function); 239218334Speter break; 239318334Speter } 239418334Speter 2395169689Skan if (selector && argnum > 2) 2396169689Skan { 2397169689Skan rname = selector; 2398169689Skan argnum -= 2; 2399169689Skan } 240018334Speter 2401169689Skan STRIP_TYPE_NOPS (val); 240218334Speter 240318334Speter val = require_complete_type (val); 240418334Speter 240518334Speter if (type != 0) 240618334Speter { 240718334Speter /* Formal parm type is specified by a function prototype. */ 240818334Speter tree parmval; 240918334Speter 2410169689Skan if (type == error_mark_node || !COMPLETE_TYPE_P (type)) 241118334Speter { 241218334Speter error ("type of formal parameter %d is incomplete", parmnum + 1); 241318334Speter parmval = val; 241418334Speter } 241518334Speter else 241618334Speter { 241718334Speter /* Optionally warn about conversions that 241818334Speter differ from the default conversions. */ 241990075Sobrien if (warn_conversion || warn_traditional) 242018334Speter { 2421169689Skan unsigned int formal_prec = TYPE_PRECISION (type); 242218334Speter 242318334Speter if (INTEGRAL_TYPE_P (type) 242418334Speter && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) 2425169689Skan warning (0, "passing argument %d of %qE as integer " 2426169689Skan "rather than floating due to prototype", 2427169689Skan argnum, rname); 242890075Sobrien if (INTEGRAL_TYPE_P (type) 242990075Sobrien && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE) 2430169689Skan warning (0, "passing argument %d of %qE as integer " 2431169689Skan "rather than complex due to prototype", 2432169689Skan argnum, rname); 243318334Speter else if (TREE_CODE (type) == COMPLEX_TYPE 243418334Speter && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) 2435169689Skan warning (0, "passing argument %d of %qE as complex " 2436169689Skan "rather than floating due to prototype", 2437169689Skan argnum, rname); 243818334Speter else if (TREE_CODE (type) == REAL_TYPE 243918334Speter && INTEGRAL_TYPE_P (TREE_TYPE (val))) 2440169689Skan warning (0, "passing argument %d of %qE as floating " 2441169689Skan "rather than integer due to prototype", 2442169689Skan argnum, rname); 244390075Sobrien else if (TREE_CODE (type) == COMPLEX_TYPE 244490075Sobrien && INTEGRAL_TYPE_P (TREE_TYPE (val))) 2445169689Skan warning (0, "passing argument %d of %qE as complex " 2446169689Skan "rather than integer due to prototype", 2447169689Skan argnum, rname); 244818334Speter else if (TREE_CODE (type) == REAL_TYPE 244918334Speter && TREE_CODE (TREE_TYPE (val)) == COMPLEX_TYPE) 2450169689Skan warning (0, "passing argument %d of %qE as floating " 2451169689Skan "rather than complex due to prototype", 2452169689Skan argnum, rname); 245318334Speter /* ??? At some point, messages should be written about 245418334Speter conversions between complex types, but that's too messy 245518334Speter to do now. */ 245618334Speter else if (TREE_CODE (type) == REAL_TYPE 245718334Speter && TREE_CODE (TREE_TYPE (val)) == REAL_TYPE) 245818334Speter { 245918334Speter /* Warn if any argument is passed as `float', 246018334Speter since without a prototype it would be `double'. */ 2461169689Skan if (formal_prec == TYPE_PRECISION (float_type_node) 2462169689Skan && type != dfloat32_type_node) 2463169689Skan warning (0, "passing argument %d of %qE as %<float%> " 2464169689Skan "rather than %<double%> due to prototype", 2465169689Skan argnum, rname); 2466169689Skan 2467169689Skan /* Warn if mismatch between argument and prototype 2468169689Skan for decimal float types. Warn of conversions with 2469169689Skan binary float types and of precision narrowing due to 2470169689Skan prototype. */ 2471169689Skan else if (type != TREE_TYPE (val) 2472169689Skan && (type == dfloat32_type_node 2473169689Skan || type == dfloat64_type_node 2474169689Skan || type == dfloat128_type_node 2475169689Skan || TREE_TYPE (val) == dfloat32_type_node 2476169689Skan || TREE_TYPE (val) == dfloat64_type_node 2477169689Skan || TREE_TYPE (val) == dfloat128_type_node) 2478169689Skan && (formal_prec 2479169689Skan <= TYPE_PRECISION (TREE_TYPE (val)) 2480169689Skan || (type == dfloat128_type_node 2481169689Skan && (TREE_TYPE (val) 2482169689Skan != dfloat64_type_node 2483169689Skan && (TREE_TYPE (val) 2484169689Skan != dfloat32_type_node))) 2485169689Skan || (type == dfloat64_type_node 2486169689Skan && (TREE_TYPE (val) 2487169689Skan != dfloat32_type_node)))) 2488169689Skan warning (0, "passing argument %d of %qE as %qT " 2489169689Skan "rather than %qT due to prototype", 2490169689Skan argnum, rname, type, TREE_TYPE (val)); 2491169689Skan 249218334Speter } 249390075Sobrien /* Detect integer changing in width or signedness. 249490075Sobrien These warnings are only activated with 249590075Sobrien -Wconversion, not with -Wtraditional. */ 249690075Sobrien else if (warn_conversion && INTEGRAL_TYPE_P (type) 249718334Speter && INTEGRAL_TYPE_P (TREE_TYPE (val))) 249818334Speter { 249918334Speter tree would_have_been = default_conversion (val); 250018334Speter tree type1 = TREE_TYPE (would_have_been); 250118334Speter 250218334Speter if (TREE_CODE (type) == ENUMERAL_TYPE 250390075Sobrien && (TYPE_MAIN_VARIANT (type) 250490075Sobrien == TYPE_MAIN_VARIANT (TREE_TYPE (val)))) 250518334Speter /* No warning if function asks for enum 250618334Speter and the actual arg is that enum type. */ 250718334Speter ; 250818334Speter else if (formal_prec != TYPE_PRECISION (type1)) 2509169689Skan warning (OPT_Wconversion, "passing argument %d of %qE " 2510169689Skan "with different width due to prototype", 2511169689Skan argnum, rname); 2512169689Skan else if (TYPE_UNSIGNED (type) == TYPE_UNSIGNED (type1)) 251318334Speter ; 251418334Speter /* Don't complain if the formal parameter type 251518334Speter is an enum, because we can't tell now whether 251618334Speter the value was an enum--even the same enum. */ 251718334Speter else if (TREE_CODE (type) == ENUMERAL_TYPE) 251818334Speter ; 251918334Speter else if (TREE_CODE (val) == INTEGER_CST 252018334Speter && int_fits_type_p (val, type)) 252118334Speter /* Change in signedness doesn't matter 252218334Speter if a constant value is unaffected. */ 252318334Speter ; 252418334Speter /* If the value is extended from a narrower 252518334Speter unsigned type, it doesn't matter whether we 252618334Speter pass it as signed or unsigned; the value 252718334Speter certainly is the same either way. */ 252818334Speter else if (TYPE_PRECISION (TREE_TYPE (val)) < TYPE_PRECISION (type) 2529169689Skan && TYPE_UNSIGNED (TREE_TYPE (val))) 253018334Speter ; 2531169689Skan else if (TYPE_UNSIGNED (type)) 2532169689Skan warning (OPT_Wconversion, "passing argument %d of %qE " 2533169689Skan "as unsigned due to prototype", 2534169689Skan argnum, rname); 253518334Speter else 2536169689Skan warning (OPT_Wconversion, "passing argument %d of %qE " 2537169689Skan "as signed due to prototype", argnum, rname); 253818334Speter } 253918334Speter } 254018334Speter 2541169689Skan parmval = convert_for_assignment (type, val, ic_argpass, 2542169689Skan fundecl, function, 2543169689Skan parmnum + 1); 2544132718Skan 2545132718Skan if (targetm.calls.promote_prototypes (fundecl ? TREE_TYPE (fundecl) : 0) 254690075Sobrien && INTEGRAL_TYPE_P (type) 254718334Speter && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))) 254818334Speter parmval = default_conversion (parmval); 254918334Speter } 255018334Speter result = tree_cons (NULL_TREE, parmval, result); 255118334Speter } 255218334Speter else if (TREE_CODE (TREE_TYPE (val)) == REAL_TYPE 2553169689Skan && (TYPE_PRECISION (TREE_TYPE (val)) 2554169689Skan < TYPE_PRECISION (double_type_node)) 2555169689Skan && !DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (val)))) 255618334Speter /* Convert `float' to `double'. */ 255718334Speter result = tree_cons (NULL_TREE, convert (double_type_node, val), result); 2558169689Skan else if ((invalid_func_diag = 2559169689Skan targetm.calls.invalid_arg_for_unprototyped_fn (typelist, fundecl, val))) 2560169689Skan { 2561169689Skan error (invalid_func_diag); 2562169689Skan return error_mark_node; 2563169689Skan } 256418334Speter else 256518334Speter /* Convert `short' and `char' to full-size `int'. */ 256618334Speter result = tree_cons (NULL_TREE, default_conversion (val), result); 256718334Speter 256818334Speter if (typetail) 256918334Speter typetail = TREE_CHAIN (typetail); 257018334Speter } 257118334Speter 257218334Speter if (typetail != 0 && TREE_VALUE (typetail) != void_type_node) 257318334Speter { 2574169689Skan error ("too few arguments to function %qE", function); 2575169689Skan return error_mark_node; 257618334Speter } 257718334Speter 257818334Speter return nreverse (result); 257918334Speter} 258018334Speter 2581169689Skan/* This is the entry point used by the parser to build unary operators 2582169689Skan in the input. CODE, a tree_code, specifies the unary operator, and 2583169689Skan ARG is the operand. For unary plus, the C parser currently uses 2584169689Skan CONVERT_EXPR for code. */ 258518334Speter 2586169689Skanstruct c_expr 2587169689Skanparser_build_unary_op (enum tree_code code, struct c_expr arg) 258818334Speter{ 2589169689Skan struct c_expr result; 259018334Speter 2591169689Skan result.original_code = ERROR_MARK; 2592169689Skan result.value = build_unary_op (code, arg.value, 0); 2593169689Skan overflow_warning (result.value); 2594169689Skan return result; 2595169689Skan} 259618334Speter 2597169689Skan/* This is the entry point used by the parser to build binary operators 2598169689Skan in the input. CODE, a tree_code, specifies the binary operator, and 2599169689Skan ARG1 and ARG2 are the operands. In addition to constructing the 2600169689Skan expression, we check for operands that were written with other binary 2601169689Skan operators in a way that is likely to confuse the user. */ 260290075Sobrien 2603169689Skanstruct c_expr 2604169689Skanparser_build_binary_op (enum tree_code code, struct c_expr arg1, 2605169689Skan struct c_expr arg2) 2606169689Skan{ 2607169689Skan struct c_expr result; 260818334Speter 2609169689Skan enum tree_code code1 = arg1.original_code; 2610169689Skan enum tree_code code2 = arg2.original_code; 2611169689Skan 2612169689Skan result.value = build_binary_op (code, arg1.value, arg2.value, 1); 2613169689Skan result.original_code = code; 2614169689Skan 2615169689Skan if (TREE_CODE (result.value) == ERROR_MARK) 2616169689Skan return result; 2617169689Skan 261818334Speter /* Check for cases such as x+y<<z which users are likely 2619169689Skan to misinterpret. */ 262018334Speter if (warn_parentheses) 262118334Speter { 262218334Speter if (code == LSHIFT_EXPR || code == RSHIFT_EXPR) 262318334Speter { 262418334Speter if (code1 == PLUS_EXPR || code1 == MINUS_EXPR 262518334Speter || code2 == PLUS_EXPR || code2 == MINUS_EXPR) 2626169689Skan warning (OPT_Wparentheses, 2627169689Skan "suggest parentheses around + or - inside shift"); 262818334Speter } 262918334Speter 263018334Speter if (code == TRUTH_ORIF_EXPR) 263118334Speter { 263218334Speter if (code1 == TRUTH_ANDIF_EXPR 263318334Speter || code2 == TRUTH_ANDIF_EXPR) 2634169689Skan warning (OPT_Wparentheses, 2635169689Skan "suggest parentheses around && within ||"); 263618334Speter } 263718334Speter 263818334Speter if (code == BIT_IOR_EXPR) 263918334Speter { 264018334Speter if (code1 == BIT_AND_EXPR || code1 == BIT_XOR_EXPR 264118334Speter || code1 == PLUS_EXPR || code1 == MINUS_EXPR 264218334Speter || code2 == BIT_AND_EXPR || code2 == BIT_XOR_EXPR 264318334Speter || code2 == PLUS_EXPR || code2 == MINUS_EXPR) 2644169689Skan warning (OPT_Wparentheses, 2645169689Skan "suggest parentheses around arithmetic in operand of |"); 264618334Speter /* Check cases like x|y==z */ 2647169689Skan if (TREE_CODE_CLASS (code1) == tcc_comparison 2648169689Skan || TREE_CODE_CLASS (code2) == tcc_comparison) 2649169689Skan warning (OPT_Wparentheses, 2650169689Skan "suggest parentheses around comparison in operand of |"); 265118334Speter } 265218334Speter 265318334Speter if (code == BIT_XOR_EXPR) 265418334Speter { 265518334Speter if (code1 == BIT_AND_EXPR 265618334Speter || code1 == PLUS_EXPR || code1 == MINUS_EXPR 265718334Speter || code2 == BIT_AND_EXPR 265818334Speter || code2 == PLUS_EXPR || code2 == MINUS_EXPR) 2659169689Skan warning (OPT_Wparentheses, 2660169689Skan "suggest parentheses around arithmetic in operand of ^"); 266118334Speter /* Check cases like x^y==z */ 2662169689Skan if (TREE_CODE_CLASS (code1) == tcc_comparison 2663169689Skan || TREE_CODE_CLASS (code2) == tcc_comparison) 2664169689Skan warning (OPT_Wparentheses, 2665169689Skan "suggest parentheses around comparison in operand of ^"); 266618334Speter } 266718334Speter 266818334Speter if (code == BIT_AND_EXPR) 266918334Speter { 267018334Speter if (code1 == PLUS_EXPR || code1 == MINUS_EXPR 267118334Speter || code2 == PLUS_EXPR || code2 == MINUS_EXPR) 2672169689Skan warning (OPT_Wparentheses, 2673169689Skan "suggest parentheses around + or - in operand of &"); 267418334Speter /* Check cases like x&y==z */ 2675169689Skan if (TREE_CODE_CLASS (code1) == tcc_comparison 2676169689Skan || TREE_CODE_CLASS (code2) == tcc_comparison) 2677169689Skan warning (OPT_Wparentheses, 2678169689Skan "suggest parentheses around comparison in operand of &"); 267918334Speter } 2680169689Skan /* Similarly, check for cases like 1<=i<=10 that are probably errors. */ 2681169689Skan if (TREE_CODE_CLASS (code) == tcc_comparison 2682169689Skan && (TREE_CODE_CLASS (code1) == tcc_comparison 2683169689Skan || TREE_CODE_CLASS (code2) == tcc_comparison)) 2684169689Skan warning (OPT_Wparentheses, "comparisons like X<=Y<=Z do not " 2685169689Skan "have their mathematical meaning"); 2686169689Skan 268718334Speter } 268818334Speter 2689169689Skan /* Warn about comparisons against string literals, with the exception 2690169689Skan of testing for equality or inequality of a string literal with NULL. */ 2691169689Skan if (code == EQ_EXPR || code == NE_EXPR) 269218334Speter { 2693169689Skan if ((code1 == STRING_CST && !integer_zerop (arg2.value)) 2694169689Skan || (code2 == STRING_CST && !integer_zerop (arg1.value))) 2695169689Skan warning (OPT_Waddress, 2696169689Skan "comparison with string literal results in unspecified behaviour"); 269718334Speter } 2698169689Skan else if (TREE_CODE_CLASS (code) == tcc_comparison 2699169689Skan && (code1 == STRING_CST || code2 == STRING_CST)) 2700169689Skan warning (OPT_Waddress, 2701169689Skan "comparison with string literal results in unspecified behaviour"); 270218334Speter 2703169689Skan overflow_warning (result.value); 2704169689Skan 270518334Speter return result; 270618334Speter} 270718334Speter 270818334Speter/* Return a tree for the difference of pointers OP0 and OP1. 270918334Speter The resulting tree has type int. */ 271018334Speter 271118334Speterstatic tree 2712132718Skanpointer_diff (tree op0, tree op1) 271318334Speter{ 271418334Speter tree restype = ptrdiff_type_node; 271518334Speter 271618334Speter tree target_type = TREE_TYPE (TREE_TYPE (op0)); 271790075Sobrien tree con0, con1, lit0, lit1; 271890075Sobrien tree orig_op1 = op1; 271918334Speter 272018334Speter if (pedantic || warn_pointer_arith) 272118334Speter { 272218334Speter if (TREE_CODE (target_type) == VOID_TYPE) 2723169689Skan pedwarn ("pointer of type %<void *%> used in subtraction"); 272418334Speter if (TREE_CODE (target_type) == FUNCTION_TYPE) 272518334Speter pedwarn ("pointer to a function used in subtraction"); 272618334Speter } 272718334Speter 272890075Sobrien /* If the conversion to ptrdiff_type does anything like widening or 272990075Sobrien converting a partial to an integral mode, we get a convert_expression 273090075Sobrien that is in the way to do any simplifications. 273190075Sobrien (fold-const.c doesn't know that the extra bits won't be needed. 273290075Sobrien split_tree uses STRIP_SIGN_NOPS, which leaves conversions to a 273390075Sobrien different mode in place.) 273490075Sobrien So first try to find a common term here 'by hand'; we want to cover 273590075Sobrien at least the cases that occur in legal static initializers. */ 2736169689Skan if ((TREE_CODE (op0) == NOP_EXPR || TREE_CODE (op0) == CONVERT_EXPR) 2737169689Skan && (TYPE_PRECISION (TREE_TYPE (op0)) 2738169689Skan == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op0, 0))))) 2739169689Skan con0 = TREE_OPERAND (op0, 0); 2740169689Skan else 2741169689Skan con0 = op0; 2742169689Skan if ((TREE_CODE (op1) == NOP_EXPR || TREE_CODE (op1) == CONVERT_EXPR) 2743169689Skan && (TYPE_PRECISION (TREE_TYPE (op1)) 2744169689Skan == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op1, 0))))) 2745169689Skan con1 = TREE_OPERAND (op1, 0); 2746169689Skan else 2747169689Skan con1 = op1; 274890075Sobrien 274990075Sobrien if (TREE_CODE (con0) == PLUS_EXPR) 275090075Sobrien { 275190075Sobrien lit0 = TREE_OPERAND (con0, 1); 275290075Sobrien con0 = TREE_OPERAND (con0, 0); 275390075Sobrien } 275490075Sobrien else 275590075Sobrien lit0 = integer_zero_node; 275690075Sobrien 275790075Sobrien if (TREE_CODE (con1) == PLUS_EXPR) 275890075Sobrien { 275990075Sobrien lit1 = TREE_OPERAND (con1, 1); 276090075Sobrien con1 = TREE_OPERAND (con1, 0); 276190075Sobrien } 276290075Sobrien else 276390075Sobrien lit1 = integer_zero_node; 276490075Sobrien 276590075Sobrien if (operand_equal_p (con0, con1, 0)) 276690075Sobrien { 276790075Sobrien op0 = lit0; 276890075Sobrien op1 = lit1; 276990075Sobrien } 277090075Sobrien 277190075Sobrien 277218334Speter /* First do the subtraction as integers; 277350397Sobrien then drop through to build the divide operator. 277450397Sobrien Do not do default conversions on the minus operator 277550397Sobrien in case restype is a short type. */ 277618334Speter 277718334Speter op0 = build_binary_op (MINUS_EXPR, convert (restype, op0), 277850397Sobrien convert (restype, op1), 0); 277918334Speter /* This generates an error if op1 is pointer to incomplete type. */ 278090075Sobrien if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (TREE_TYPE (orig_op1)))) 278118334Speter error ("arithmetic on pointer to an incomplete type"); 278218334Speter 278318334Speter /* This generates an error if op0 is pointer to incomplete type. */ 278418334Speter op1 = c_size_in_bytes (target_type); 278518334Speter 278618334Speter /* Divide by the size, in easiest possible way. */ 2787169689Skan return fold_build2 (EXACT_DIV_EXPR, restype, op0, convert (restype, op1)); 278818334Speter} 278918334Speter 279018334Speter/* Construct and perhaps optimize a tree representation 279118334Speter for a unary operation. CODE, a tree_code, specifies the operation 279290075Sobrien and XARG is the operand. 279390075Sobrien For any CODE other than ADDR_EXPR, FLAG nonzero suppresses 279490075Sobrien the default promotions (such as from short to int). 279590075Sobrien For ADDR_EXPR, the default promotions are not applied; FLAG nonzero 279690075Sobrien allows non-lvalues; this is only used to handle conversion of non-lvalue 279790075Sobrien arrays to pointers in C99. */ 279818334Speter 279918334Spetertree 2800132718Skanbuild_unary_op (enum tree_code code, tree xarg, int flag) 280118334Speter{ 280218334Speter /* No default_conversion here. It causes trouble for ADDR_EXPR. */ 280390075Sobrien tree arg = xarg; 280490075Sobrien tree argtype = 0; 280590075Sobrien enum tree_code typecode = TREE_CODE (TREE_TYPE (arg)); 280618334Speter tree val; 280790075Sobrien int noconvert = flag; 2808169689Skan const char *invalid_op_diag; 280918334Speter 281018334Speter if (typecode == ERROR_MARK) 281118334Speter return error_mark_node; 281290075Sobrien if (typecode == ENUMERAL_TYPE || typecode == BOOLEAN_TYPE) 281318334Speter typecode = INTEGER_TYPE; 281418334Speter 2815169689Skan if ((invalid_op_diag 2816169689Skan = targetm.invalid_unary_op (code, TREE_TYPE (xarg)))) 2817169689Skan { 2818169689Skan error (invalid_op_diag); 2819169689Skan return error_mark_node; 2820169689Skan } 2821169689Skan 282218334Speter switch (code) 282318334Speter { 282418334Speter case CONVERT_EXPR: 282518334Speter /* This is used for unary plus, because a CONVERT_EXPR 282618334Speter is enough to prevent anybody from looking inside for 282718334Speter associativity, but won't generate any code. */ 282818334Speter if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE 2829169689Skan || typecode == COMPLEX_TYPE 2830169689Skan || typecode == VECTOR_TYPE)) 283152284Sobrien { 283252284Sobrien error ("wrong type argument to unary plus"); 283352284Sobrien return error_mark_node; 283452284Sobrien } 283518334Speter else if (!noconvert) 283618334Speter arg = default_conversion (arg); 2837117395Skan arg = non_lvalue (arg); 283818334Speter break; 283918334Speter 284018334Speter case NEGATE_EXPR: 284118334Speter if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE 2842117395Skan || typecode == COMPLEX_TYPE 2843117395Skan || typecode == VECTOR_TYPE)) 284452284Sobrien { 284552284Sobrien error ("wrong type argument to unary minus"); 284652284Sobrien return error_mark_node; 284752284Sobrien } 284818334Speter else if (!noconvert) 284918334Speter arg = default_conversion (arg); 285018334Speter break; 285118334Speter 285218334Speter case BIT_NOT_EXPR: 2853117395Skan if (typecode == INTEGER_TYPE || typecode == VECTOR_TYPE) 285418334Speter { 2855117395Skan if (!noconvert) 2856117395Skan arg = default_conversion (arg); 2857117395Skan } 2858117395Skan else if (typecode == COMPLEX_TYPE) 2859117395Skan { 286018334Speter code = CONJ_EXPR; 286190075Sobrien if (pedantic) 2862169689Skan pedwarn ("ISO C does not support %<~%> for complex conjugation"); 286318334Speter if (!noconvert) 286418334Speter arg = default_conversion (arg); 286518334Speter } 2866117395Skan else 286752284Sobrien { 286852284Sobrien error ("wrong type argument to bit-complement"); 286952284Sobrien return error_mark_node; 287052284Sobrien } 287118334Speter break; 287218334Speter 287318334Speter case ABS_EXPR: 2874132718Skan if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE)) 287552284Sobrien { 287652284Sobrien error ("wrong type argument to abs"); 287752284Sobrien return error_mark_node; 287852284Sobrien } 287918334Speter else if (!noconvert) 288018334Speter arg = default_conversion (arg); 288118334Speter break; 288218334Speter 288318334Speter case CONJ_EXPR: 288418334Speter /* Conjugating a real value is a no-op, but allow it anyway. */ 288518334Speter if (!(typecode == INTEGER_TYPE || typecode == REAL_TYPE 288618334Speter || typecode == COMPLEX_TYPE)) 288752284Sobrien { 288852284Sobrien error ("wrong type argument to conjugation"); 288952284Sobrien return error_mark_node; 289052284Sobrien } 289118334Speter else if (!noconvert) 289218334Speter arg = default_conversion (arg); 289318334Speter break; 289418334Speter 289518334Speter case TRUTH_NOT_EXPR: 289618334Speter if (typecode != INTEGER_TYPE 289718334Speter && typecode != REAL_TYPE && typecode != POINTER_TYPE 2898169689Skan && typecode != COMPLEX_TYPE) 289918334Speter { 290052284Sobrien error ("wrong type argument to unary exclamation mark"); 290152284Sobrien return error_mark_node; 290218334Speter } 2903169689Skan arg = c_objc_common_truthvalue_conversion (arg); 290418334Speter return invert_truthvalue (arg); 290518334Speter 290618334Speter case REALPART_EXPR: 290718334Speter if (TREE_CODE (arg) == COMPLEX_CST) 290818334Speter return TREE_REALPART (arg); 290918334Speter else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE) 2910169689Skan return fold_build1 (REALPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg); 291118334Speter else 291218334Speter return arg; 291318334Speter 291418334Speter case IMAGPART_EXPR: 291518334Speter if (TREE_CODE (arg) == COMPLEX_CST) 291618334Speter return TREE_IMAGPART (arg); 291718334Speter else if (TREE_CODE (TREE_TYPE (arg)) == COMPLEX_TYPE) 2918169689Skan return fold_build1 (IMAGPART_EXPR, TREE_TYPE (TREE_TYPE (arg)), arg); 291918334Speter else 292018334Speter return convert (TREE_TYPE (arg), integer_zero_node); 2921132718Skan 292218334Speter case PREINCREMENT_EXPR: 292318334Speter case POSTINCREMENT_EXPR: 292418334Speter case PREDECREMENT_EXPR: 292518334Speter case POSTDECREMENT_EXPR: 292618334Speter 292718334Speter /* Increment or decrement the real part of the value, 292818334Speter and don't change the imaginary part. */ 292918334Speter if (typecode == COMPLEX_TYPE) 293018334Speter { 293118334Speter tree real, imag; 293218334Speter 293390075Sobrien if (pedantic) 2934169689Skan pedwarn ("ISO C does not support %<++%> and %<--%>" 2935169689Skan " on complex types"); 293690075Sobrien 293718334Speter arg = stabilize_reference (arg); 293818334Speter real = build_unary_op (REALPART_EXPR, arg, 1); 293918334Speter imag = build_unary_op (IMAGPART_EXPR, arg, 1); 2940169689Skan return build2 (COMPLEX_EXPR, TREE_TYPE (arg), 2941169689Skan build_unary_op (code, real, 1), imag); 294218334Speter } 294318334Speter 294418334Speter /* Report invalid types. */ 294518334Speter 294618334Speter if (typecode != POINTER_TYPE 294718334Speter && typecode != INTEGER_TYPE && typecode != REAL_TYPE) 294818334Speter { 294990075Sobrien if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) 2950169689Skan error ("wrong type argument to increment"); 2951169689Skan else 2952169689Skan error ("wrong type argument to decrement"); 295390075Sobrien 295452284Sobrien return error_mark_node; 295518334Speter } 295618334Speter 295718334Speter { 295890075Sobrien tree inc; 295918334Speter tree result_type = TREE_TYPE (arg); 296018334Speter 2961117395Skan arg = get_unwidened (arg, 0); 2962117395Skan argtype = TREE_TYPE (arg); 2963117395Skan 296418334Speter /* Compute the increment. */ 296518334Speter 296618334Speter if (typecode == POINTER_TYPE) 296718334Speter { 296818334Speter /* If pointer target is an undefined struct, 296918334Speter we just cannot know how to do the arithmetic. */ 297090075Sobrien if (!COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (result_type))) 297190075Sobrien { 297290075Sobrien if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) 297390075Sobrien error ("increment of pointer to unknown structure"); 297490075Sobrien else 297590075Sobrien error ("decrement of pointer to unknown structure"); 297690075Sobrien } 297718334Speter else if ((pedantic || warn_pointer_arith) 297818334Speter && (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE 297918334Speter || TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)) 2980169689Skan { 298190075Sobrien if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) 298290075Sobrien pedwarn ("wrong type argument to increment"); 298390075Sobrien else 298490075Sobrien pedwarn ("wrong type argument to decrement"); 298590075Sobrien } 298690075Sobrien 298718334Speter inc = c_size_in_bytes (TREE_TYPE (result_type)); 298818334Speter } 298918334Speter else 299018334Speter inc = integer_one_node; 299118334Speter 299218334Speter inc = convert (argtype, inc); 299318334Speter 299418334Speter /* Complain about anything else that is not a true lvalue. */ 299518334Speter if (!lvalue_or_else (arg, ((code == PREINCREMENT_EXPR 299618334Speter || code == POSTINCREMENT_EXPR) 2997169689Skan ? lv_increment 2998169689Skan : lv_decrement))) 299918334Speter return error_mark_node; 300018334Speter 300118334Speter /* Report a read-only lvalue. */ 300218334Speter if (TREE_READONLY (arg)) 3003169689Skan { 3004169689Skan readonly_error (arg, 3005169689Skan ((code == PREINCREMENT_EXPR 3006169689Skan || code == POSTINCREMENT_EXPR) 3007169689Skan ? lv_increment : lv_decrement)); 3008169689Skan return error_mark_node; 3009169689Skan } 301018334Speter 301190075Sobrien if (TREE_CODE (TREE_TYPE (arg)) == BOOLEAN_TYPE) 301290075Sobrien val = boolean_increment (code, arg); 301390075Sobrien else 3014169689Skan val = build2 (code, TREE_TYPE (arg), arg, inc); 301518334Speter TREE_SIDE_EFFECTS (val) = 1; 301618334Speter val = convert (result_type, val); 301718334Speter if (TREE_CODE (val) != code) 3018169689Skan TREE_NO_WARNING (val) = 1; 301918334Speter return val; 302018334Speter } 302118334Speter 302218334Speter case ADDR_EXPR: 302390075Sobrien /* Note that this operation never does default_conversion. */ 302418334Speter 302518334Speter /* Let &* cancel out to simplify resulting code. */ 302618334Speter if (TREE_CODE (arg) == INDIRECT_REF) 302718334Speter { 302818334Speter /* Don't let this be an lvalue. */ 302918334Speter if (lvalue_p (TREE_OPERAND (arg, 0))) 303018334Speter return non_lvalue (TREE_OPERAND (arg, 0)); 303118334Speter return TREE_OPERAND (arg, 0); 303218334Speter } 303318334Speter 303418334Speter /* For &x[y], return x+y */ 303518334Speter if (TREE_CODE (arg) == ARRAY_REF) 303618334Speter { 3037169689Skan tree op0 = TREE_OPERAND (arg, 0); 3038169689Skan if (!c_mark_addressable (op0)) 303918334Speter return error_mark_node; 3040169689Skan return build_binary_op (PLUS_EXPR, 3041169689Skan (TREE_CODE (TREE_TYPE (op0)) == ARRAY_TYPE 3042169689Skan ? array_to_pointer_conversion (op0) 3043169689Skan : op0), 304418334Speter TREE_OPERAND (arg, 1), 1); 304518334Speter } 304618334Speter 304718334Speter /* Anything not already handled and not a true memory reference 304890075Sobrien or a non-lvalue array is an error. */ 304990075Sobrien else if (typecode != FUNCTION_TYPE && !flag 3050169689Skan && !lvalue_or_else (arg, lv_addressof)) 305118334Speter return error_mark_node; 305218334Speter 305318334Speter /* Ordinary case; arg is a COMPONENT_REF or a decl. */ 305418334Speter argtype = TREE_TYPE (arg); 305590075Sobrien 305652284Sobrien /* If the lvalue is const or volatile, merge that into the type 3057169689Skan to which the address will point. Note that you can't get a 305852284Sobrien restricted pointer by taking the address of something, so we 305952284Sobrien only have to deal with `const' and `volatile' here. */ 3060169689Skan if ((DECL_P (arg) || REFERENCE_CLASS_P (arg)) 306190075Sobrien && (TREE_READONLY (arg) || TREE_THIS_VOLATILE (arg))) 306290075Sobrien argtype = c_build_type_variant (argtype, 306390075Sobrien TREE_READONLY (arg), 306490075Sobrien TREE_THIS_VOLATILE (arg)); 306518334Speter 3066117395Skan if (!c_mark_addressable (arg)) 306718334Speter return error_mark_node; 306818334Speter 3069169689Skan gcc_assert (TREE_CODE (arg) != COMPONENT_REF 3070169689Skan || !DECL_C_BIT_FIELD (TREE_OPERAND (arg, 1))); 307118334Speter 3072169689Skan argtype = build_pointer_type (argtype); 307318334Speter 3074169689Skan /* ??? Cope with user tricks that amount to offsetof. Delete this 3075169689Skan when we have proper support for integer constant expressions. */ 3076169689Skan val = get_base_address (arg); 3077169689Skan if (val && TREE_CODE (val) == INDIRECT_REF 3078169689Skan && TREE_CONSTANT (TREE_OPERAND (val, 0))) 3079169689Skan { 3080169689Skan tree op0 = fold_convert (argtype, fold_offsetof (arg, val)), op1; 308118334Speter 3082169689Skan op1 = fold_convert (argtype, TREE_OPERAND (val, 0)); 3083169689Skan return fold_build2 (PLUS_EXPR, argtype, op0, op1); 3084169689Skan } 308518334Speter 3086169689Skan val = build1 (ADDR_EXPR, argtype, arg); 308718334Speter 3088169689Skan return val; 308950397Sobrien 309050397Sobrien default: 3091169689Skan gcc_unreachable (); 309218334Speter } 309318334Speter 309452284Sobrien if (argtype == 0) 309552284Sobrien argtype = TREE_TYPE (arg); 3096169689Skan return require_constant_value ? fold_build1_initializer (code, argtype, arg) 3097169689Skan : fold_build1 (code, argtype, arg); 309818334Speter} 309918334Speter 310018334Speter/* Return nonzero if REF is an lvalue valid for this language. 310118334Speter Lvalues can be assigned, unless their type has TYPE_READONLY. 3102169689Skan Lvalues can have their address taken, unless they have C_DECL_REGISTER. */ 310318334Speter 3104169689Skanstatic int 3105132718Skanlvalue_p (tree ref) 310618334Speter{ 310790075Sobrien enum tree_code code = TREE_CODE (ref); 310818334Speter 310918334Speter switch (code) 311018334Speter { 311118334Speter case REALPART_EXPR: 311218334Speter case IMAGPART_EXPR: 311318334Speter case COMPONENT_REF: 311418334Speter return lvalue_p (TREE_OPERAND (ref, 0)); 311518334Speter 311690075Sobrien case COMPOUND_LITERAL_EXPR: 311718334Speter case STRING_CST: 311818334Speter return 1; 311918334Speter 312018334Speter case INDIRECT_REF: 312118334Speter case ARRAY_REF: 312218334Speter case VAR_DECL: 312318334Speter case PARM_DECL: 312418334Speter case RESULT_DECL: 312518334Speter case ERROR_MARK: 312650397Sobrien return (TREE_CODE (TREE_TYPE (ref)) != FUNCTION_TYPE 312750397Sobrien && TREE_CODE (TREE_TYPE (ref)) != METHOD_TYPE); 312850397Sobrien 312950397Sobrien case BIND_EXPR: 313050397Sobrien return TREE_CODE (TREE_TYPE (ref)) == ARRAY_TYPE; 313150397Sobrien 313250397Sobrien default: 313350397Sobrien return 0; 313418334Speter } 313518334Speter} 3136169689Skan 3137169689Skan/* Give an error for storing in something that is 'const'. */ 313818334Speter 313918334Speterstatic void 3140169689Skanreadonly_error (tree arg, enum lvalue_use use) 314118334Speter{ 3142169689Skan gcc_assert (use == lv_assign || use == lv_increment || use == lv_decrement 3143169689Skan || use == lv_asm); 3144169689Skan /* Using this macro rather than (for example) arrays of messages 3145169689Skan ensures that all the format strings are checked at compile 3146169689Skan time. */ 3147169689Skan#define READONLY_MSG(A, I, D, AS) (use == lv_assign ? (A) \ 3148169689Skan : (use == lv_increment ? (I) \ 3149169689Skan : (use == lv_decrement ? (D) : (AS)))) 315018334Speter if (TREE_CODE (arg) == COMPONENT_REF) 315118334Speter { 315218334Speter if (TYPE_READONLY (TREE_TYPE (TREE_OPERAND (arg, 0)))) 3153169689Skan readonly_error (TREE_OPERAND (arg, 0), use); 315418334Speter else 3155169689Skan error (READONLY_MSG (G_("assignment of read-only member %qD"), 3156169689Skan G_("increment of read-only member %qD"), 3157169689Skan G_("decrement of read-only member %qD"), 3158169689Skan G_("read-only member %qD used as %<asm%> output")), 3159169689Skan TREE_OPERAND (arg, 1)); 316018334Speter } 316118334Speter else if (TREE_CODE (arg) == VAR_DECL) 3162169689Skan error (READONLY_MSG (G_("assignment of read-only variable %qD"), 3163169689Skan G_("increment of read-only variable %qD"), 3164169689Skan G_("decrement of read-only variable %qD"), 3165169689Skan G_("read-only variable %qD used as %<asm%> output")), 3166169689Skan arg); 316718334Speter else 3168169689Skan error (READONLY_MSG (G_("assignment of read-only location"), 3169169689Skan G_("increment of read-only location"), 3170169689Skan G_("decrement of read-only location"), 3171169689Skan G_("read-only location used as %<asm%> output"))); 317218334Speter} 3173169689Skan 3174169689Skan 3175169689Skan/* Return nonzero if REF is an lvalue valid for this language; 3176169689Skan otherwise, print an error message and return zero. USE says 3177169689Skan how the lvalue is being used and so selects the error message. */ 3178169689Skan 3179169689Skanstatic int 3180169689Skanlvalue_or_else (tree ref, enum lvalue_use use) 3181169689Skan{ 3182169689Skan int win = lvalue_p (ref); 3183169689Skan 3184169689Skan if (!win) 3185169689Skan lvalue_error (use); 3186169689Skan 3187169689Skan return win; 3188169689Skan} 318918334Speter 319018334Speter/* Mark EXP saying that we need to be able to take the 319118334Speter address of it; it should not be allocated in a register. 3192117395Skan Returns true if successful. */ 319318334Speter 3194117395Skanbool 3195132718Skanc_mark_addressable (tree exp) 319618334Speter{ 319790075Sobrien tree x = exp; 3198117395Skan 319918334Speter while (1) 320018334Speter switch (TREE_CODE (x)) 320118334Speter { 320250397Sobrien case COMPONENT_REF: 320350397Sobrien if (DECL_C_BIT_FIELD (TREE_OPERAND (x, 1))) 320450397Sobrien { 3205169689Skan error 3206169689Skan ("cannot take address of bit-field %qD", TREE_OPERAND (x, 1)); 3207117395Skan return false; 320850397Sobrien } 320950397Sobrien 321050397Sobrien /* ... fall through ... */ 321150397Sobrien 321218334Speter case ADDR_EXPR: 321318334Speter case ARRAY_REF: 321418334Speter case REALPART_EXPR: 321518334Speter case IMAGPART_EXPR: 321618334Speter x = TREE_OPERAND (x, 0); 321718334Speter break; 321818334Speter 321990075Sobrien case COMPOUND_LITERAL_EXPR: 322018334Speter case CONSTRUCTOR: 322118334Speter TREE_ADDRESSABLE (x) = 1; 3222117395Skan return true; 322318334Speter 322418334Speter case VAR_DECL: 322518334Speter case CONST_DECL: 322618334Speter case PARM_DECL: 322718334Speter case RESULT_DECL: 3228169689Skan if (C_DECL_REGISTER (x) 322918334Speter && DECL_NONLOCAL (x)) 323018334Speter { 3231132718Skan if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x)) 323218334Speter { 3233169689Skan error 3234169689Skan ("global register variable %qD used in nested function", x); 3235117395Skan return false; 323618334Speter } 3237169689Skan pedwarn ("register variable %qD used in nested function", x); 323818334Speter } 3239169689Skan else if (C_DECL_REGISTER (x)) 324018334Speter { 3241132718Skan if (TREE_PUBLIC (x) || TREE_STATIC (x) || DECL_EXTERNAL (x)) 3242169689Skan error ("address of global register variable %qD requested", x); 3243169689Skan else 3244169689Skan error ("address of register variable %qD requested", x); 3245169689Skan return false; 324618334Speter } 324718334Speter 324818334Speter /* drops in */ 324918334Speter case FUNCTION_DECL: 325018334Speter TREE_ADDRESSABLE (x) = 1; 3251132718Skan /* drops out */ 325218334Speter default: 3253117395Skan return true; 325418334Speter } 325518334Speter} 325618334Speter 325718334Speter/* Build and return a conditional expression IFEXP ? OP1 : OP2. */ 325818334Speter 325918334Spetertree 3260132718Skanbuild_conditional_expr (tree ifexp, tree op1, tree op2) 326118334Speter{ 326290075Sobrien tree type1; 326390075Sobrien tree type2; 326490075Sobrien enum tree_code code1; 326590075Sobrien enum tree_code code2; 326690075Sobrien tree result_type = NULL; 326718334Speter tree orig_op1 = op1, orig_op2 = op2; 326818334Speter 326918334Speter /* Promote both alternatives. */ 327018334Speter 327118334Speter if (TREE_CODE (TREE_TYPE (op1)) != VOID_TYPE) 327218334Speter op1 = default_conversion (op1); 327318334Speter if (TREE_CODE (TREE_TYPE (op2)) != VOID_TYPE) 327418334Speter op2 = default_conversion (op2); 327518334Speter 327618334Speter if (TREE_CODE (ifexp) == ERROR_MARK 327718334Speter || TREE_CODE (TREE_TYPE (op1)) == ERROR_MARK 327818334Speter || TREE_CODE (TREE_TYPE (op2)) == ERROR_MARK) 327918334Speter return error_mark_node; 328018334Speter 328118334Speter type1 = TREE_TYPE (op1); 328218334Speter code1 = TREE_CODE (type1); 328318334Speter type2 = TREE_TYPE (op2); 328418334Speter code2 = TREE_CODE (type2); 3285132718Skan 3286169689Skan /* C90 does not permit non-lvalue arrays in conditional expressions. 3287169689Skan In C99 they will be pointers by now. */ 3288169689Skan if (code1 == ARRAY_TYPE || code2 == ARRAY_TYPE) 3289169689Skan { 3290169689Skan error ("non-lvalue array in conditional expression"); 3291169689Skan return error_mark_node; 3292169689Skan } 3293169689Skan 329418334Speter /* Quickly detect the usual case where op1 and op2 have the same type 329518334Speter after promotion. */ 329618334Speter if (TYPE_MAIN_VARIANT (type1) == TYPE_MAIN_VARIANT (type2)) 329718334Speter { 329818334Speter if (type1 == type2) 329918334Speter result_type = type1; 330018334Speter else 330118334Speter result_type = TYPE_MAIN_VARIANT (type1); 330218334Speter } 330390075Sobrien else if ((code1 == INTEGER_TYPE || code1 == REAL_TYPE 3304169689Skan || code1 == COMPLEX_TYPE) 3305169689Skan && (code2 == INTEGER_TYPE || code2 == REAL_TYPE 3306169689Skan || code2 == COMPLEX_TYPE)) 330718334Speter { 3308169689Skan result_type = c_common_type (type1, type2); 330990075Sobrien 331090075Sobrien /* If -Wsign-compare, warn here if type1 and type2 have 331190075Sobrien different signedness. We'll promote the signed to unsigned 331290075Sobrien and later code won't know it used to be different. 331390075Sobrien Do this check on the original types, so that explicit casts 331490075Sobrien will be considered, but default promotions won't. */ 3315132718Skan if (warn_sign_compare && !skip_evaluation) 331690075Sobrien { 3317169689Skan int unsigned_op1 = TYPE_UNSIGNED (TREE_TYPE (orig_op1)); 3318169689Skan int unsigned_op2 = TYPE_UNSIGNED (TREE_TYPE (orig_op2)); 331990075Sobrien 332090075Sobrien if (unsigned_op1 ^ unsigned_op2) 332190075Sobrien { 3322169689Skan bool ovf; 3323169689Skan 332490075Sobrien /* Do not warn if the result type is signed, since the 332590075Sobrien signed type will only be chosen if it can represent 332690075Sobrien all the values of the unsigned type. */ 3327169689Skan if (!TYPE_UNSIGNED (result_type)) 332890075Sobrien /* OK */; 332990075Sobrien /* Do not warn if the signed quantity is an unsuffixed 333090075Sobrien integer literal (or some static constant expression 333190075Sobrien involving such literals) and it is non-negative. */ 3332169689Skan else if ((unsigned_op2 3333169689Skan && tree_expr_nonnegative_warnv_p (op1, &ovf)) 3334169689Skan || (unsigned_op1 3335169689Skan && tree_expr_nonnegative_warnv_p (op2, &ovf))) 333690075Sobrien /* OK */; 333790075Sobrien else 3338169689Skan warning (0, "signed and unsigned type in conditional expression"); 333990075Sobrien } 334090075Sobrien } 334118334Speter } 334218334Speter else if (code1 == VOID_TYPE || code2 == VOID_TYPE) 334318334Speter { 334418334Speter if (pedantic && (code1 != VOID_TYPE || code2 != VOID_TYPE)) 334590075Sobrien pedwarn ("ISO C forbids conditional expr with only one void side"); 334618334Speter result_type = void_type_node; 334718334Speter } 334818334Speter else if (code1 == POINTER_TYPE && code2 == POINTER_TYPE) 334918334Speter { 3350169689Skan if (comp_target_types (type1, type2)) 3351169689Skan result_type = common_pointer_type (type1, type2); 3352169689Skan else if (null_pointer_constant_p (orig_op1)) 335318334Speter result_type = qualify_type (type2, type1); 3354169689Skan else if (null_pointer_constant_p (orig_op2)) 335518334Speter result_type = qualify_type (type1, type2); 335690075Sobrien else if (VOID_TYPE_P (TREE_TYPE (type1))) 335718334Speter { 335818334Speter if (pedantic && TREE_CODE (TREE_TYPE (type2)) == FUNCTION_TYPE) 3359169689Skan pedwarn ("ISO C forbids conditional expr between " 3360169689Skan "%<void *%> and function pointer"); 336190075Sobrien result_type = build_pointer_type (qualify_type (TREE_TYPE (type1), 336290075Sobrien TREE_TYPE (type2))); 336318334Speter } 336490075Sobrien else if (VOID_TYPE_P (TREE_TYPE (type2))) 336518334Speter { 336618334Speter if (pedantic && TREE_CODE (TREE_TYPE (type1)) == FUNCTION_TYPE) 3367169689Skan pedwarn ("ISO C forbids conditional expr between " 3368169689Skan "%<void *%> and function pointer"); 336990075Sobrien result_type = build_pointer_type (qualify_type (TREE_TYPE (type2), 337090075Sobrien TREE_TYPE (type1))); 337118334Speter } 337218334Speter else 337318334Speter { 337418334Speter pedwarn ("pointer type mismatch in conditional expression"); 337518334Speter result_type = build_pointer_type (void_type_node); 337618334Speter } 337718334Speter } 337818334Speter else if (code1 == POINTER_TYPE && code2 == INTEGER_TYPE) 337918334Speter { 3380169689Skan if (!null_pointer_constant_p (orig_op2)) 338118334Speter pedwarn ("pointer/integer type mismatch in conditional expression"); 338218334Speter else 338318334Speter { 338418334Speter op2 = null_pointer_node; 338518334Speter } 338618334Speter result_type = type1; 338718334Speter } 338818334Speter else if (code2 == POINTER_TYPE && code1 == INTEGER_TYPE) 338918334Speter { 3390169689Skan if (!null_pointer_constant_p (orig_op1)) 339118334Speter pedwarn ("pointer/integer type mismatch in conditional expression"); 339218334Speter else 339318334Speter { 339418334Speter op1 = null_pointer_node; 339518334Speter } 339618334Speter result_type = type2; 339718334Speter } 339818334Speter 339918334Speter if (!result_type) 340018334Speter { 340118334Speter if (flag_cond_mismatch) 340218334Speter result_type = void_type_node; 340318334Speter else 340418334Speter { 340518334Speter error ("type mismatch in conditional expression"); 340618334Speter return error_mark_node; 340718334Speter } 340818334Speter } 340918334Speter 341018334Speter /* Merge const and volatile flags of the incoming types. */ 341118334Speter result_type 341218334Speter = build_type_variant (result_type, 341318334Speter TREE_READONLY (op1) || TREE_READONLY (op2), 341418334Speter TREE_THIS_VOLATILE (op1) || TREE_THIS_VOLATILE (op2)); 341518334Speter 341618334Speter if (result_type != TREE_TYPE (op1)) 341718334Speter op1 = convert_and_check (result_type, op1); 341818334Speter if (result_type != TREE_TYPE (op2)) 341918334Speter op2 = convert_and_check (result_type, op2); 3420132718Skan 3421169689Skan return fold_build3 (COND_EXPR, result_type, ifexp, op1, op2); 342218334Speter} 342318334Speter 3424169689Skan/* Return a compound expression that performs two expressions and 3425169689Skan returns the value of the second of them. */ 342618334Speter 342718334Spetertree 3428169689Skanbuild_compound_expr (tree expr1, tree expr2) 342918334Speter{ 3430169689Skan if (!TREE_SIDE_EFFECTS (expr1)) 343118334Speter { 343218334Speter /* The left-hand operand of a comma expression is like an expression 3433169689Skan statement: with -Wextra or -Wunused, we should warn if it doesn't have 343418334Speter any side-effects, unless it was explicitly cast to (void). */ 3435169689Skan if (warn_unused_value) 3436169689Skan { 3437169689Skan if (VOID_TYPE_P (TREE_TYPE (expr1)) 3438169689Skan && (TREE_CODE (expr1) == NOP_EXPR 3439169689Skan || TREE_CODE (expr1) == CONVERT_EXPR)) 3440169689Skan ; /* (void) a, b */ 3441169689Skan else if (VOID_TYPE_P (TREE_TYPE (expr1)) 3442169689Skan && TREE_CODE (expr1) == COMPOUND_EXPR 3443169689Skan && (TREE_CODE (TREE_OPERAND (expr1, 1)) == CONVERT_EXPR 3444169689Skan || TREE_CODE (TREE_OPERAND (expr1, 1)) == NOP_EXPR)) 3445169689Skan ; /* (void) a, (void) b, c */ 3446169689Skan else 3447169689Skan warning (0, "left-hand operand of comma expression has no effect"); 3448169689Skan } 344918334Speter } 345018334Speter 345118334Speter /* With -Wunused, we should also warn if the left-hand operand does have 345218334Speter side-effects, but computes a value which is not used. For example, in 345318334Speter `foo() + bar(), baz()' the result of the `+' operator is not used, 345418334Speter so we should issue a warning. */ 345590075Sobrien else if (warn_unused_value) 3456169689Skan warn_if_unused_value (expr1, input_location); 345718334Speter 3458169689Skan if (expr2 == error_mark_node) 3459169689Skan return error_mark_node; 3460169689Skan 3461169689Skan return build2 (COMPOUND_EXPR, TREE_TYPE (expr2), expr1, expr2); 346218334Speter} 346318334Speter 346418334Speter/* Build an expression representing a cast to type TYPE of expression EXPR. */ 346518334Speter 346618334Spetertree 3467132718Skanbuild_c_cast (tree type, tree expr) 346818334Speter{ 346990075Sobrien tree value = expr; 3470132718Skan 347118334Speter if (type == error_mark_node || expr == error_mark_node) 347218334Speter return error_mark_node; 347318334Speter 3474117395Skan /* The ObjC front-end uses TYPE_MAIN_VARIANT to tie together types differing 3475117395Skan only in <protocol> qualifications. But when constructing cast expressions, 3476117395Skan the protocols do matter and must be kept around. */ 3477169689Skan if (objc_is_object_ptr (type) && objc_is_object_ptr (TREE_TYPE (expr))) 3478169689Skan return build1 (NOP_EXPR, type, expr); 3479117395Skan 3480169689Skan type = TYPE_MAIN_VARIANT (type); 3481169689Skan 348218334Speter if (TREE_CODE (type) == ARRAY_TYPE) 348318334Speter { 348418334Speter error ("cast specifies array type"); 348518334Speter return error_mark_node; 348618334Speter } 348718334Speter 348818334Speter if (TREE_CODE (type) == FUNCTION_TYPE) 348918334Speter { 349018334Speter error ("cast specifies function type"); 349118334Speter return error_mark_node; 349218334Speter } 349318334Speter 349490075Sobrien if (type == TYPE_MAIN_VARIANT (TREE_TYPE (value))) 349518334Speter { 349618334Speter if (pedantic) 349718334Speter { 349818334Speter if (TREE_CODE (type) == RECORD_TYPE 349918334Speter || TREE_CODE (type) == UNION_TYPE) 350090075Sobrien pedwarn ("ISO C forbids casting nonscalar to the same type"); 350118334Speter } 350218334Speter } 350318334Speter else if (TREE_CODE (type) == UNION_TYPE) 350418334Speter { 350518334Speter tree field; 350618334Speter 350718334Speter for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field)) 350818334Speter if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (field)), 3509169689Skan TYPE_MAIN_VARIANT (TREE_TYPE (value)))) 351018334Speter break; 351118334Speter 351218334Speter if (field) 351318334Speter { 351418334Speter tree t; 351518334Speter 351618334Speter if (pedantic) 351790075Sobrien pedwarn ("ISO C forbids casts to union type"); 3518132718Skan t = digest_init (type, 3519169689Skan build_constructor_single (type, field, value), 3520169689Skan true, 0); 352118334Speter TREE_CONSTANT (t) = TREE_CONSTANT (value); 3522169689Skan TREE_INVARIANT (t) = TREE_INVARIANT (value); 352318334Speter return t; 352418334Speter } 352518334Speter error ("cast to union type from type not present in union"); 352618334Speter return error_mark_node; 352718334Speter } 352818334Speter else 352918334Speter { 353018334Speter tree otype, ovalue; 353118334Speter 353218334Speter if (type == void_type_node) 353318334Speter return build1 (CONVERT_EXPR, type, value); 353418334Speter 353518334Speter otype = TREE_TYPE (value); 353618334Speter 353718334Speter /* Optionally warn about potentially worrisome casts. */ 353818334Speter 353918334Speter if (warn_cast_qual 354018334Speter && TREE_CODE (type) == POINTER_TYPE 354118334Speter && TREE_CODE (otype) == POINTER_TYPE) 354218334Speter { 354350397Sobrien tree in_type = type; 354450397Sobrien tree in_otype = otype; 354596263Sobrien int added = 0; 354696263Sobrien int discarded = 0; 354750397Sobrien 354890075Sobrien /* Check that the qualifiers on IN_TYPE are a superset of 354990075Sobrien the qualifiers of IN_OTYPE. The outermost level of 355090075Sobrien POINTER_TYPE nodes is uninteresting and we stop as soon 355190075Sobrien as we hit a non-POINTER_TYPE node on either type. */ 355290075Sobrien do 355390075Sobrien { 355490075Sobrien in_otype = TREE_TYPE (in_otype); 355590075Sobrien in_type = TREE_TYPE (in_type); 355696263Sobrien 355796263Sobrien /* GNU C allows cv-qualified function types. 'const' 355896263Sobrien means the function is very pure, 'volatile' means it 355996263Sobrien can't return. We need to warn when such qualifiers 356096263Sobrien are added, not when they're taken away. */ 356196263Sobrien if (TREE_CODE (in_otype) == FUNCTION_TYPE 356296263Sobrien && TREE_CODE (in_type) == FUNCTION_TYPE) 356396263Sobrien added |= (TYPE_QUALS (in_type) & ~TYPE_QUALS (in_otype)); 356496263Sobrien else 356596263Sobrien discarded |= (TYPE_QUALS (in_otype) & ~TYPE_QUALS (in_type)); 356690075Sobrien } 356790075Sobrien while (TREE_CODE (in_type) == POINTER_TYPE 356890075Sobrien && TREE_CODE (in_otype) == POINTER_TYPE); 356990075Sobrien 357096263Sobrien if (added) 3571169689Skan warning (0, "cast adds new qualifiers to function type"); 357296263Sobrien 357396263Sobrien if (discarded) 357452284Sobrien /* There are qualifiers present in IN_OTYPE that are not 357552284Sobrien present in IN_TYPE. */ 3576169689Skan warning (0, "cast discards qualifiers from pointer target type"); 357718334Speter } 357818334Speter 357918334Speter /* Warn about possible alignment problems. */ 3580169689Skan if (STRICT_ALIGNMENT 358118334Speter && TREE_CODE (type) == POINTER_TYPE 358218334Speter && TREE_CODE (otype) == POINTER_TYPE 358318334Speter && TREE_CODE (TREE_TYPE (otype)) != VOID_TYPE 358418334Speter && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE 358550397Sobrien /* Don't warn about opaque types, where the actual alignment 358650397Sobrien restriction is unknown. */ 358750397Sobrien && !((TREE_CODE (TREE_TYPE (otype)) == UNION_TYPE 358850397Sobrien || TREE_CODE (TREE_TYPE (otype)) == RECORD_TYPE) 358950397Sobrien && TYPE_MODE (TREE_TYPE (otype)) == VOIDmode) 359018334Speter && TYPE_ALIGN (TREE_TYPE (type)) > TYPE_ALIGN (TREE_TYPE (otype))) 3591169689Skan warning (OPT_Wcast_align, 3592169689Skan "cast increases required alignment of target type"); 359318334Speter 359418334Speter if (TREE_CODE (type) == INTEGER_TYPE 359518334Speter && TREE_CODE (otype) == POINTER_TYPE 3596169689Skan && TYPE_PRECISION (type) != TYPE_PRECISION (otype)) 3597169689Skan /* Unlike conversion of integers to pointers, where the 3598169689Skan warning is disabled for converting constants because 3599169689Skan of cases such as SIG_*, warn about converting constant 3600169689Skan pointers to integers. In some cases it may cause unwanted 3601169689Skan sign extension, and a warning is appropriate. */ 3602169689Skan warning (OPT_Wpointer_to_int_cast, 3603169689Skan "cast from pointer to integer of different size"); 360418334Speter 3605169689Skan if (TREE_CODE (value) == CALL_EXPR 360618334Speter && TREE_CODE (type) != TREE_CODE (otype)) 3607169689Skan warning (OPT_Wbad_function_cast, "cast from function call of type %qT " 3608169689Skan "to non-matching type %qT", otype, type); 360918334Speter 361018334Speter if (TREE_CODE (type) == POINTER_TYPE 361118334Speter && TREE_CODE (otype) == INTEGER_TYPE 361218334Speter && TYPE_PRECISION (type) != TYPE_PRECISION (otype) 361318334Speter /* Don't warn about converting any constant. */ 361418334Speter && !TREE_CONSTANT (value)) 3615169689Skan warning (OPT_Wint_to_pointer_cast, "cast to pointer from integer " 3616169689Skan "of different size"); 361718334Speter 3618169689Skan strict_aliasing_warning (otype, type, expr); 3619132718Skan 3620132718Skan /* If pedantic, warn for conversions between function and object 3621132718Skan pointer types, except for converting a null pointer constant 3622132718Skan to function pointer type. */ 3623132718Skan if (pedantic 3624132718Skan && TREE_CODE (type) == POINTER_TYPE 3625132718Skan && TREE_CODE (otype) == POINTER_TYPE 3626132718Skan && TREE_CODE (TREE_TYPE (otype)) == FUNCTION_TYPE 3627132718Skan && TREE_CODE (TREE_TYPE (type)) != FUNCTION_TYPE) 3628132718Skan pedwarn ("ISO C forbids conversion of function pointer to object pointer type"); 3629132718Skan 3630132718Skan if (pedantic 3631132718Skan && TREE_CODE (type) == POINTER_TYPE 3632132718Skan && TREE_CODE (otype) == POINTER_TYPE 3633132718Skan && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE 3634132718Skan && TREE_CODE (TREE_TYPE (otype)) != FUNCTION_TYPE 3635169689Skan && !null_pointer_constant_p (value)) 3636132718Skan pedwarn ("ISO C forbids conversion of object pointer to function pointer type"); 3637132718Skan 363818334Speter ovalue = value; 363918334Speter value = convert (type, value); 364018334Speter 364118334Speter /* Ignore any integer overflow caused by the cast. */ 364218334Speter if (TREE_CODE (value) == INTEGER_CST) 364318334Speter { 3644169689Skan if (CONSTANT_CLASS_P (ovalue) 3645169689Skan && (TREE_OVERFLOW (ovalue) || TREE_CONSTANT_OVERFLOW (ovalue))) 3646169689Skan { 3647169689Skan /* Avoid clobbering a shared constant. */ 3648169689Skan value = copy_node (value); 3649169689Skan TREE_OVERFLOW (value) = TREE_OVERFLOW (ovalue); 3650169689Skan TREE_CONSTANT_OVERFLOW (value) = TREE_CONSTANT_OVERFLOW (ovalue); 3651169689Skan } 3652169689Skan else if (TREE_OVERFLOW (value) || TREE_CONSTANT_OVERFLOW (value)) 3653169689Skan /* Reset VALUE's overflow flags, ensuring constant sharing. */ 3654169689Skan value = build_int_cst_wide (TREE_TYPE (value), 3655169689Skan TREE_INT_CST_LOW (value), 3656169689Skan TREE_INT_CST_HIGH (value)); 365718334Speter } 365818334Speter } 365918334Speter 3660169689Skan /* Don't let a cast be an lvalue. */ 3661169689Skan if (value == expr) 366218334Speter value = non_lvalue (value); 366318334Speter 366418334Speter return value; 366518334Speter} 366690075Sobrien 366790075Sobrien/* Interpret a cast of expression EXPR to type TYPE. */ 366890075Sobrientree 3669169689Skanc_cast_expr (struct c_type_name *type_name, tree expr) 367090075Sobrien{ 3671169689Skan tree type; 367290075Sobrien int saved_wsp = warn_strict_prototypes; 367390075Sobrien 367490075Sobrien /* This avoids warnings about unprototyped casts on 367590075Sobrien integers. E.g. "#define SIG_DFL (void(*)())0". */ 367690075Sobrien if (TREE_CODE (expr) == INTEGER_CST) 367790075Sobrien warn_strict_prototypes = 0; 3678169689Skan type = groktypename (type_name); 367990075Sobrien warn_strict_prototypes = saved_wsp; 368090075Sobrien 368190075Sobrien return build_c_cast (type, expr); 368290075Sobrien} 368318334Speter 368418334Speter/* Build an assignment expression of lvalue LHS from value RHS. 368518334Speter MODIFYCODE is the code for a binary operator that we use 368618334Speter to combine the old value of LHS with RHS to get the new value. 368718334Speter Or else MODIFYCODE is NOP_EXPR meaning do a simple assignment. */ 368818334Speter 368918334Spetertree 3690132718Skanbuild_modify_expr (tree lhs, enum tree_code modifycode, tree rhs) 369118334Speter{ 369290075Sobrien tree result; 369318334Speter tree newrhs; 369418334Speter tree lhstype = TREE_TYPE (lhs); 369518334Speter tree olhstype = lhstype; 369618334Speter 369718334Speter /* Types that aren't fully specified cannot be used in assignments. */ 369818334Speter lhs = require_complete_type (lhs); 369918334Speter 370018334Speter /* Avoid duplicate error messages from operands that had errors. */ 370118334Speter if (TREE_CODE (lhs) == ERROR_MARK || TREE_CODE (rhs) == ERROR_MARK) 370218334Speter return error_mark_node; 370318334Speter 3704169689Skan if (!lvalue_or_else (lhs, lv_assign)) 3705169689Skan return error_mark_node; 370618334Speter 3707169689Skan STRIP_TYPE_NOPS (rhs); 3708169689Skan 370918334Speter newrhs = rhs; 371018334Speter 371118334Speter /* If a binary op has been requested, combine the old LHS value with the RHS 371218334Speter producing the value we should actually store into the LHS. */ 371318334Speter 371418334Speter if (modifycode != NOP_EXPR) 371518334Speter { 371618334Speter lhs = stabilize_reference (lhs); 371718334Speter newrhs = build_binary_op (modifycode, lhs, rhs, 1); 371818334Speter } 371918334Speter 3720169689Skan /* Give an error for storing in something that is 'const'. */ 372118334Speter 372218334Speter if (TREE_READONLY (lhs) || TYPE_READONLY (lhstype) 372318334Speter || ((TREE_CODE (lhstype) == RECORD_TYPE 372418334Speter || TREE_CODE (lhstype) == UNION_TYPE) 372518334Speter && C_TYPE_FIELDS_READONLY (lhstype))) 3726169689Skan { 3727169689Skan readonly_error (lhs, lv_assign); 3728169689Skan return error_mark_node; 3729169689Skan } 373018334Speter 373118334Speter /* If storing into a structure or union member, 373218334Speter it has probably been given type `int'. 373318334Speter Compute the type that would go with 373418334Speter the actual amount of storage the member occupies. */ 373518334Speter 373618334Speter if (TREE_CODE (lhs) == COMPONENT_REF 373718334Speter && (TREE_CODE (lhstype) == INTEGER_TYPE 373890075Sobrien || TREE_CODE (lhstype) == BOOLEAN_TYPE 373918334Speter || TREE_CODE (lhstype) == REAL_TYPE 374018334Speter || TREE_CODE (lhstype) == ENUMERAL_TYPE)) 374118334Speter lhstype = TREE_TYPE (get_unwidened (lhs, 0)); 374218334Speter 374318334Speter /* If storing in a field that is in actuality a short or narrower than one, 374418334Speter we must store in the field in its actual type. */ 374518334Speter 374618334Speter if (lhstype != TREE_TYPE (lhs)) 374718334Speter { 374818334Speter lhs = copy_node (lhs); 374918334Speter TREE_TYPE (lhs) = lhstype; 375018334Speter } 375118334Speter 375218334Speter /* Convert new value to destination type. */ 375318334Speter 3754169689Skan newrhs = convert_for_assignment (lhstype, newrhs, ic_assign, 375518334Speter NULL_TREE, NULL_TREE, 0); 375618334Speter if (TREE_CODE (newrhs) == ERROR_MARK) 375718334Speter return error_mark_node; 375818334Speter 3759169689Skan /* Emit ObjC write barrier, if necessary. */ 3760169689Skan if (c_dialect_objc () && flag_objc_gc) 3761169689Skan { 3762169689Skan result = objc_generate_write_barrier (lhs, modifycode, newrhs); 3763169689Skan if (result) 3764169689Skan return result; 3765169689Skan } 376690075Sobrien 3767169689Skan /* Scan operands. */ 3768169689Skan 3769169689Skan result = build2 (MODIFY_EXPR, lhstype, lhs, newrhs); 377018334Speter TREE_SIDE_EFFECTS (result) = 1; 377118334Speter 377218334Speter /* If we got the LHS in a different type for storing in, 377318334Speter convert the result back to the nominal type of LHS 377418334Speter so that the value we return always has the same type 377518334Speter as the LHS argument. */ 377618334Speter 377718334Speter if (olhstype == TREE_TYPE (result)) 377818334Speter return result; 3779169689Skan return convert_for_assignment (olhstype, result, ic_assign, 378018334Speter NULL_TREE, NULL_TREE, 0); 378118334Speter} 378218334Speter 378318334Speter/* Convert value RHS to type TYPE as preparation for an assignment 378418334Speter to an lvalue of type TYPE. 378518334Speter The real work of conversion is done by `convert'. 378618334Speter The purpose of this function is to generate error messages 378718334Speter for assignments that are not allowed in C. 3788169689Skan ERRTYPE says whether it is argument passing, assignment, 3789169689Skan initialization or return. 379018334Speter 3791169689Skan FUNCTION is a tree for the function being called. 379218334Speter PARMNUM is the number of the argument, for printing in error messages. */ 379318334Speter 379418334Speterstatic tree 3795169689Skanconvert_for_assignment (tree type, tree rhs, enum impl_conv errtype, 3796169689Skan tree fundecl, tree function, int parmnum) 379718334Speter{ 379890075Sobrien enum tree_code codel = TREE_CODE (type); 379990075Sobrien tree rhstype; 380090075Sobrien enum tree_code coder; 3801169689Skan tree rname = NULL_TREE; 3802169689Skan bool objc_ok = false; 380318334Speter 3804169689Skan if (errtype == ic_argpass || errtype == ic_argpass_nonproto) 3805169689Skan { 3806169689Skan tree selector; 3807169689Skan /* Change pointer to function to the function itself for 3808169689Skan diagnostics. */ 3809169689Skan if (TREE_CODE (function) == ADDR_EXPR 3810169689Skan && TREE_CODE (TREE_OPERAND (function, 0)) == FUNCTION_DECL) 3811169689Skan function = TREE_OPERAND (function, 0); 381218334Speter 3813169689Skan /* Handle an ObjC selector specially for diagnostics. */ 3814169689Skan selector = objc_message_selector (); 3815169689Skan rname = function; 3816169689Skan if (selector && parmnum > 2) 3817169689Skan { 3818169689Skan rname = selector; 3819169689Skan parmnum -= 2; 3820169689Skan } 3821169689Skan } 3822169689Skan 3823169689Skan /* This macro is used to emit diagnostics to ensure that all format 3824169689Skan strings are complete sentences, visible to gettext and checked at 3825169689Skan compile time. */ 3826169689Skan#define WARN_FOR_ASSIGNMENT(AR, AS, IN, RE) \ 3827169689Skan do { \ 3828169689Skan switch (errtype) \ 3829169689Skan { \ 3830169689Skan case ic_argpass: \ 3831169689Skan pedwarn (AR, parmnum, rname); \ 3832169689Skan break; \ 3833169689Skan case ic_argpass_nonproto: \ 3834169689Skan warning (0, AR, parmnum, rname); \ 3835169689Skan break; \ 3836169689Skan case ic_assign: \ 3837169689Skan pedwarn (AS); \ 3838169689Skan break; \ 3839169689Skan case ic_init: \ 3840169689Skan pedwarn (IN); \ 3841169689Skan break; \ 3842169689Skan case ic_return: \ 3843169689Skan pedwarn (RE); \ 3844169689Skan break; \ 3845169689Skan default: \ 3846169689Skan gcc_unreachable (); \ 3847169689Skan } \ 3848169689Skan } while (0) 3849169689Skan 3850169689Skan STRIP_TYPE_NOPS (rhs); 3851169689Skan 3852169689Skan if (optimize && TREE_CODE (rhs) == VAR_DECL 3853169689Skan && TREE_CODE (TREE_TYPE (rhs)) != ARRAY_TYPE) 385490075Sobrien rhs = decl_constant_value_for_broken_optimization (rhs); 385518334Speter 385618334Speter rhstype = TREE_TYPE (rhs); 385718334Speter coder = TREE_CODE (rhstype); 385818334Speter 385918334Speter if (coder == ERROR_MARK) 386018334Speter return error_mark_node; 386118334Speter 3862169689Skan if (c_dialect_objc ()) 3863169689Skan { 3864169689Skan int parmno; 3865169689Skan 3866169689Skan switch (errtype) 3867169689Skan { 3868169689Skan case ic_return: 3869169689Skan parmno = 0; 3870169689Skan break; 3871169689Skan 3872169689Skan case ic_assign: 3873169689Skan parmno = -1; 3874169689Skan break; 3875169689Skan 3876169689Skan case ic_init: 3877169689Skan parmno = -2; 3878169689Skan break; 3879169689Skan 3880169689Skan default: 3881169689Skan parmno = parmnum; 3882169689Skan break; 3883169689Skan } 3884169689Skan 3885169689Skan objc_ok = objc_compare_types (type, rhstype, parmno, rname); 3886169689Skan } 3887169689Skan 388818334Speter if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (rhstype)) 388918334Speter { 389018334Speter overflow_warning (rhs); 389118334Speter return rhs; 389218334Speter } 389318334Speter 389418334Speter if (coder == VOID_TYPE) 389518334Speter { 3896169689Skan /* Except for passing an argument to an unprototyped function, 3897169689Skan this is a constraint violation. When passing an argument to 3898169689Skan an unprototyped function, it is compile-time undefined; 3899169689Skan making it a constraint in that case was rejected in 3900169689Skan DR#252. */ 390118334Speter error ("void value not ignored as it ought to be"); 390218334Speter return error_mark_node; 390318334Speter } 3904132718Skan /* A type converts to a reference to it. 390590075Sobrien This code doesn't fully support references, it's just for the 390690075Sobrien special case of va_start and va_copy. */ 390790075Sobrien if (codel == REFERENCE_TYPE 3908169689Skan && comptypes (TREE_TYPE (type), TREE_TYPE (rhs)) == 1) 390990075Sobrien { 3910117395Skan if (!lvalue_p (rhs)) 3911117395Skan { 3912117395Skan error ("cannot pass rvalue to reference parameter"); 3913117395Skan return error_mark_node; 3914117395Skan } 3915117395Skan if (!c_mark_addressable (rhs)) 391690075Sobrien return error_mark_node; 391790075Sobrien rhs = build1 (ADDR_EXPR, build_pointer_type (TREE_TYPE (rhs)), rhs); 391890075Sobrien 391990075Sobrien /* We already know that these two types are compatible, but they 392090075Sobrien may not be exactly identical. In fact, `TREE_TYPE (type)' is 392190075Sobrien likely to be __builtin_va_list and `TREE_TYPE (rhs)' is 392290075Sobrien likely to be va_list, a typedef to __builtin_va_list, which 392390075Sobrien is different enough that it will cause problems later. */ 392490075Sobrien if (TREE_TYPE (TREE_TYPE (rhs)) != TREE_TYPE (type)) 392590075Sobrien rhs = build1 (NOP_EXPR, build_pointer_type (TREE_TYPE (type)), rhs); 392690075Sobrien 392790075Sobrien rhs = build1 (NOP_EXPR, type, rhs); 392890075Sobrien return rhs; 392990075Sobrien } 3930132718Skan /* Some types can interconvert without explicit casts. */ 3931132718Skan else if (codel == VECTOR_TYPE && coder == VECTOR_TYPE 3932169689Skan && vector_types_convertible_p (type, TREE_TYPE (rhs))) 3933132718Skan return convert (type, rhs); 393418334Speter /* Arithmetic types all interconvert, and enum is treated like int. */ 3935132718Skan else if ((codel == INTEGER_TYPE || codel == REAL_TYPE 393690075Sobrien || codel == ENUMERAL_TYPE || codel == COMPLEX_TYPE 393790075Sobrien || codel == BOOLEAN_TYPE) 3938117395Skan && (coder == INTEGER_TYPE || coder == REAL_TYPE 393990075Sobrien || coder == ENUMERAL_TYPE || coder == COMPLEX_TYPE 394090075Sobrien || coder == BOOLEAN_TYPE)) 394118334Speter return convert_and_check (type, rhs); 394218334Speter 3943169689Skan /* Aggregates in different TUs might need conversion. */ 3944169689Skan if ((codel == RECORD_TYPE || codel == UNION_TYPE) 3945169689Skan && codel == coder 3946169689Skan && comptypes (type, rhstype)) 3947169689Skan return convert_and_check (type, rhs); 3948169689Skan 394950397Sobrien /* Conversion to a transparent union from its member types. 395050397Sobrien This applies only to function arguments. */ 3951169689Skan if (codel == UNION_TYPE && TYPE_TRANSPARENT_UNION (type) 3952169689Skan && (errtype == ic_argpass || errtype == ic_argpass_nonproto)) 395318334Speter { 3954169689Skan tree memb, marginal_memb = NULL_TREE; 395518334Speter 3956169689Skan for (memb = TYPE_FIELDS (type); memb ; memb = TREE_CHAIN (memb)) 395718334Speter { 3958169689Skan tree memb_type = TREE_TYPE (memb); 395918334Speter 396050397Sobrien if (comptypes (TYPE_MAIN_VARIANT (memb_type), 3961169689Skan TYPE_MAIN_VARIANT (rhstype))) 396250397Sobrien break; 396350397Sobrien 396450397Sobrien if (TREE_CODE (memb_type) != POINTER_TYPE) 396550397Sobrien continue; 396650397Sobrien 396750397Sobrien if (coder == POINTER_TYPE) 396818334Speter { 396990075Sobrien tree ttl = TREE_TYPE (memb_type); 397090075Sobrien tree ttr = TREE_TYPE (rhstype); 397118334Speter 397218334Speter /* Any non-function converts to a [const][volatile] void * 397318334Speter and vice versa; otherwise, targets must be the same. 397418334Speter Meanwhile, the lhs target must have all the qualifiers of 397518334Speter the rhs. */ 397690075Sobrien if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr) 3977169689Skan || comp_target_types (memb_type, rhstype)) 397818334Speter { 397950397Sobrien /* If this type won't generate any warnings, use it. */ 398052284Sobrien if (TYPE_QUALS (ttl) == TYPE_QUALS (ttr) 398152284Sobrien || ((TREE_CODE (ttr) == FUNCTION_TYPE 398252284Sobrien && TREE_CODE (ttl) == FUNCTION_TYPE) 398352284Sobrien ? ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr)) 398452284Sobrien == TYPE_QUALS (ttr)) 398552284Sobrien : ((TYPE_QUALS (ttl) | TYPE_QUALS (ttr)) 398652284Sobrien == TYPE_QUALS (ttl)))) 398750397Sobrien break; 398818334Speter 398950397Sobrien /* Keep looking for a better type, but remember this one. */ 3990169689Skan if (!marginal_memb) 3991169689Skan marginal_memb = memb; 399218334Speter } 399318334Speter } 399418334Speter 399518334Speter /* Can convert integer zero to any pointer type. */ 3996169689Skan if (null_pointer_constant_p (rhs)) 399750397Sobrien { 399850397Sobrien rhs = null_pointer_node; 399950397Sobrien break; 400050397Sobrien } 400118334Speter } 400250397Sobrien 4003169689Skan if (memb || marginal_memb) 400450397Sobrien { 4005169689Skan if (!memb) 400650397Sobrien { 400750397Sobrien /* We have only a marginally acceptable member type; 400850397Sobrien it needs a warning. */ 4009169689Skan tree ttl = TREE_TYPE (TREE_TYPE (marginal_memb)); 401090075Sobrien tree ttr = TREE_TYPE (rhstype); 401150397Sobrien 401250397Sobrien /* Const and volatile mean something different for function 401350397Sobrien types, so the usual warnings are not appropriate. */ 401450397Sobrien if (TREE_CODE (ttr) == FUNCTION_TYPE 401550397Sobrien && TREE_CODE (ttl) == FUNCTION_TYPE) 401650397Sobrien { 401750397Sobrien /* Because const and volatile on functions are 401850397Sobrien restrictions that say the function will not do 401950397Sobrien certain things, it is okay to use a const or volatile 402050397Sobrien function where an ordinary one is wanted, but not 402150397Sobrien vice-versa. */ 402252284Sobrien if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr)) 4023169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE " 4024169689Skan "makes qualified function " 4025169689Skan "pointer from unqualified"), 4026169689Skan G_("assignment makes qualified " 4027169689Skan "function pointer from " 4028169689Skan "unqualified"), 4029169689Skan G_("initialization makes qualified " 4030169689Skan "function pointer from " 4031169689Skan "unqualified"), 4032169689Skan G_("return makes qualified function " 4033169689Skan "pointer from unqualified")); 403450397Sobrien } 403552284Sobrien else if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl)) 4036169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE discards " 4037169689Skan "qualifiers from pointer target type"), 4038169689Skan G_("assignment discards qualifiers " 4039169689Skan "from pointer target type"), 4040169689Skan G_("initialization discards qualifiers " 4041169689Skan "from pointer target type"), 4042169689Skan G_("return discards qualifiers from " 4043169689Skan "pointer target type")); 4044169689Skan 4045169689Skan memb = marginal_memb; 404650397Sobrien } 4047132718Skan 4048169689Skan if (pedantic && (!fundecl || !DECL_IN_SYSTEM_HEADER (fundecl))) 404990075Sobrien pedwarn ("ISO C prohibits argument conversion to union type"); 405050397Sobrien 4051169689Skan return build_constructor_single (type, memb, rhs); 405250397Sobrien } 405318334Speter } 405418334Speter 405518334Speter /* Conversions among pointers */ 405690075Sobrien else if ((codel == POINTER_TYPE || codel == REFERENCE_TYPE) 4057117395Skan && (coder == codel)) 405818334Speter { 405990075Sobrien tree ttl = TREE_TYPE (type); 406090075Sobrien tree ttr = TREE_TYPE (rhstype); 4061169689Skan tree mvl = ttl; 4062169689Skan tree mvr = ttr; 4063132718Skan bool is_opaque_pointer; 4064132718Skan int target_cmp = 0; /* Cache comp_target_types () result. */ 406518334Speter 4066169689Skan if (TREE_CODE (mvl) != ARRAY_TYPE) 4067169689Skan mvl = TYPE_MAIN_VARIANT (mvl); 4068169689Skan if (TREE_CODE (mvr) != ARRAY_TYPE) 4069169689Skan mvr = TYPE_MAIN_VARIANT (mvr); 4070132718Skan /* Opaque pointers are treated like void pointers. */ 4071169689Skan is_opaque_pointer = (targetm.vector_opaque_p (type) 4072169689Skan || targetm.vector_opaque_p (rhstype)) 4073169689Skan && TREE_CODE (ttl) == VECTOR_TYPE 4074169689Skan && TREE_CODE (ttr) == VECTOR_TYPE; 4075132718Skan 4076169689Skan /* C++ does not allow the implicit conversion void* -> T*. However, 4077169689Skan for the purpose of reducing the number of false positives, we 4078169689Skan tolerate the special case of 4079169689Skan 4080169689Skan int *p = NULL; 4081169689Skan 4082169689Skan where NULL is typically defined in C to be '(void *) 0'. */ 4083169689Skan if (VOID_TYPE_P (ttr) && rhs != null_pointer_node && !VOID_TYPE_P (ttl)) 4084169689Skan warning (OPT_Wc___compat, "request for implicit conversion from " 4085169689Skan "%qT to %qT not permitted in C++", rhstype, type); 4086169689Skan 4087169689Skan /* Check if the right-hand side has a format attribute but the 4088169689Skan left-hand side doesn't. */ 4089169689Skan if (warn_missing_format_attribute 4090169689Skan && check_missing_format_attribute (type, rhstype)) 4091169689Skan { 4092169689Skan switch (errtype) 4093169689Skan { 4094169689Skan case ic_argpass: 4095169689Skan case ic_argpass_nonproto: 4096169689Skan warning (OPT_Wmissing_format_attribute, 4097169689Skan "argument %d of %qE might be " 4098169689Skan "a candidate for a format attribute", 4099169689Skan parmnum, rname); 4100169689Skan break; 4101169689Skan case ic_assign: 4102169689Skan warning (OPT_Wmissing_format_attribute, 4103169689Skan "assignment left-hand side might be " 4104169689Skan "a candidate for a format attribute"); 4105169689Skan break; 4106169689Skan case ic_init: 4107169689Skan warning (OPT_Wmissing_format_attribute, 4108169689Skan "initialization left-hand side might be " 4109169689Skan "a candidate for a format attribute"); 4110169689Skan break; 4111169689Skan case ic_return: 4112169689Skan warning (OPT_Wmissing_format_attribute, 4113169689Skan "return type might be " 4114169689Skan "a candidate for a format attribute"); 4115169689Skan break; 4116169689Skan default: 4117169689Skan gcc_unreachable (); 4118169689Skan } 4119169689Skan } 4120169689Skan 412118334Speter /* Any non-function converts to a [const][volatile] void * 412218334Speter and vice versa; otherwise, targets must be the same. 412318334Speter Meanwhile, the lhs target must have all the qualifiers of the rhs. */ 412490075Sobrien if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr) 4125169689Skan || (target_cmp = comp_target_types (type, rhstype)) 4126132718Skan || is_opaque_pointer 4127169689Skan || (c_common_unsigned_type (mvl) 4128169689Skan == c_common_unsigned_type (mvr))) 412918334Speter { 413018334Speter if (pedantic 413190075Sobrien && ((VOID_TYPE_P (ttl) && TREE_CODE (ttr) == FUNCTION_TYPE) 413218334Speter || 413390075Sobrien (VOID_TYPE_P (ttr) 4134169689Skan && !null_pointer_constant_p (rhs) 413518334Speter && TREE_CODE (ttl) == FUNCTION_TYPE))) 4136169689Skan WARN_FOR_ASSIGNMENT (G_("ISO C forbids passing argument %d of " 4137169689Skan "%qE between function pointer " 4138169689Skan "and %<void *%>"), 4139169689Skan G_("ISO C forbids assignment between " 4140169689Skan "function pointer and %<void *%>"), 4141169689Skan G_("ISO C forbids initialization between " 4142169689Skan "function pointer and %<void *%>"), 4143169689Skan G_("ISO C forbids return between function " 4144169689Skan "pointer and %<void *%>")); 414518334Speter /* Const and volatile mean something different for function types, 414618334Speter so the usual warnings are not appropriate. */ 414718334Speter else if (TREE_CODE (ttr) != FUNCTION_TYPE 414818334Speter && TREE_CODE (ttl) != FUNCTION_TYPE) 414918334Speter { 415052284Sobrien if (TYPE_QUALS (ttr) & ~TYPE_QUALS (ttl)) 4151169689Skan { 4152169689Skan /* Types differing only by the presence of the 'volatile' 4153169689Skan qualifier are acceptable if the 'volatile' has been added 4154169689Skan in by the Objective-C EH machinery. */ 4155169689Skan if (!objc_type_quals_match (ttl, ttr)) 4156169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE discards " 4157169689Skan "qualifiers from pointer target type"), 4158169689Skan G_("assignment discards qualifiers " 4159169689Skan "from pointer target type"), 4160169689Skan G_("initialization discards qualifiers " 4161169689Skan "from pointer target type"), 4162169689Skan G_("return discards qualifiers from " 4163169689Skan "pointer target type")); 4164169689Skan } 416518334Speter /* If this is not a case of ignoring a mismatch in signedness, 416618334Speter no warning. */ 416790075Sobrien else if (VOID_TYPE_P (ttl) || VOID_TYPE_P (ttr) 4168132718Skan || target_cmp) 416918334Speter ; 417018334Speter /* If there is a mismatch, do warn. */ 4171169689Skan else if (warn_pointer_sign) 4172169689Skan WARN_FOR_ASSIGNMENT (G_("pointer targets in passing argument " 4173169689Skan "%d of %qE differ in signedness"), 4174169689Skan G_("pointer targets in assignment " 4175169689Skan "differ in signedness"), 4176169689Skan G_("pointer targets in initialization " 4177169689Skan "differ in signedness"), 4178169689Skan G_("pointer targets in return differ " 4179169689Skan "in signedness")); 418018334Speter } 418118334Speter else if (TREE_CODE (ttl) == FUNCTION_TYPE 418218334Speter && TREE_CODE (ttr) == FUNCTION_TYPE) 418318334Speter { 418418334Speter /* Because const and volatile on functions are restrictions 418518334Speter that say the function will not do certain things, 418618334Speter it is okay to use a const or volatile function 418718334Speter where an ordinary one is wanted, but not vice-versa. */ 418852284Sobrien if (TYPE_QUALS (ttl) & ~TYPE_QUALS (ttr)) 4189169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes " 4190169689Skan "qualified function pointer " 4191169689Skan "from unqualified"), 4192169689Skan G_("assignment makes qualified function " 4193169689Skan "pointer from unqualified"), 4194169689Skan G_("initialization makes qualified " 4195169689Skan "function pointer from unqualified"), 4196169689Skan G_("return makes qualified function " 4197169689Skan "pointer from unqualified")); 419818334Speter } 419918334Speter } 420018334Speter else 4201169689Skan /* Avoid warning about the volatile ObjC EH puts on decls. */ 4202169689Skan if (!objc_ok) 4203169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE from " 4204169689Skan "incompatible pointer type"), 4205169689Skan G_("assignment from incompatible pointer type"), 4206169689Skan G_("initialization from incompatible " 4207169689Skan "pointer type"), 4208169689Skan G_("return from incompatible pointer type")); 4209169689Skan 421018334Speter return convert (type, rhs); 421118334Speter } 4212122180Skan else if (codel == POINTER_TYPE && coder == ARRAY_TYPE) 4213122180Skan { 4214169689Skan /* ??? This should not be an error when inlining calls to 4215169689Skan unprototyped functions. */ 4216122180Skan error ("invalid use of non-lvalue array"); 4217122180Skan return error_mark_node; 4218122180Skan } 421918334Speter else if (codel == POINTER_TYPE && coder == INTEGER_TYPE) 422018334Speter { 422118334Speter /* An explicit constant 0 can convert to a pointer, 422218334Speter or one that results from arithmetic, even including 422318334Speter a cast to integer type. */ 4224169689Skan if (!null_pointer_constant_p (rhs)) 4225169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes " 4226169689Skan "pointer from integer without a cast"), 4227169689Skan G_("assignment makes pointer from integer " 4228169689Skan "without a cast"), 4229169689Skan G_("initialization makes pointer from " 4230169689Skan "integer without a cast"), 4231169689Skan G_("return makes pointer from integer " 4232169689Skan "without a cast")); 4233132718Skan 4234132718Skan return convert (type, rhs); 423518334Speter } 423618334Speter else if (codel == INTEGER_TYPE && coder == POINTER_TYPE) 423718334Speter { 4238169689Skan WARN_FOR_ASSIGNMENT (G_("passing argument %d of %qE makes integer " 4239169689Skan "from pointer without a cast"), 4240169689Skan G_("assignment makes integer from pointer " 4241169689Skan "without a cast"), 4242169689Skan G_("initialization makes integer from pointer " 4243169689Skan "without a cast"), 4244169689Skan G_("return makes integer from pointer " 4245169689Skan "without a cast")); 424618334Speter return convert (type, rhs); 424718334Speter } 424890075Sobrien else if (codel == BOOLEAN_TYPE && coder == POINTER_TYPE) 424990075Sobrien return convert (type, rhs); 425018334Speter 4251169689Skan switch (errtype) 425218334Speter { 4253169689Skan case ic_argpass: 4254169689Skan case ic_argpass_nonproto: 4255169689Skan /* ??? This should not be an error when inlining calls to 4256169689Skan unprototyped functions. */ 4257169689Skan error ("incompatible type for argument %d of %qE", parmnum, rname); 4258169689Skan break; 4259169689Skan case ic_assign: 4260169689Skan error ("incompatible types in assignment"); 4261169689Skan break; 4262169689Skan case ic_init: 4263169689Skan error ("incompatible types in initialization"); 4264169689Skan break; 4265169689Skan case ic_return: 4266169689Skan error ("incompatible types in return"); 4267169689Skan break; 4268169689Skan default: 4269169689Skan gcc_unreachable (); 427018334Speter } 427118334Speter 427218334Speter return error_mark_node; 427318334Speter} 427418334Speter 4275132718Skan/* Convert VALUE for assignment into inlined parameter PARM. ARGNUM 4276169689Skan is used for error and warning reporting and indicates which argument 4277132718Skan is being processed. */ 427896263Sobrien 427996263Sobrientree 4280132718Skanc_convert_parm_for_inlining (tree parm, tree value, tree fn, int argnum) 428196263Sobrien{ 428296263Sobrien tree ret, type; 428396263Sobrien 4284169689Skan /* If FN was prototyped at the call site, the value has been converted 4285169689Skan already in convert_arguments. 4286169689Skan However, we might see a prototype now that was not in place when 4287169689Skan the function call was seen, so check that the VALUE actually matches 4288169689Skan PARM before taking an early exit. */ 4289169689Skan if (!value 4290169689Skan || (TYPE_ARG_TYPES (TREE_TYPE (fn)) 4291169689Skan && (TYPE_MAIN_VARIANT (TREE_TYPE (parm)) 4292169689Skan == TYPE_MAIN_VARIANT (TREE_TYPE (value))))) 429396263Sobrien return value; 429496263Sobrien 429596263Sobrien type = TREE_TYPE (parm); 4296132718Skan ret = convert_for_assignment (type, value, 4297169689Skan ic_argpass_nonproto, fn, 4298169689Skan fn, argnum); 4299132718Skan if (targetm.calls.promote_prototypes (TREE_TYPE (fn)) 430096263Sobrien && INTEGRAL_TYPE_P (type) 430196263Sobrien && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))) 430296263Sobrien ret = default_conversion (ret); 430396263Sobrien return ret; 430496263Sobrien} 430518334Speter 430618334Speter/* If VALUE is a compound expr all of whose expressions are constant, then 430718334Speter return its value. Otherwise, return error_mark_node. 430818334Speter 430918334Speter This is for handling COMPOUND_EXPRs as initializer elements 431018334Speter which is allowed with a warning when -pedantic is specified. */ 431118334Speter 431218334Speterstatic tree 4313132718Skanvalid_compound_expr_initializer (tree value, tree endtype) 431418334Speter{ 431518334Speter if (TREE_CODE (value) == COMPOUND_EXPR) 431618334Speter { 431718334Speter if (valid_compound_expr_initializer (TREE_OPERAND (value, 0), endtype) 431818334Speter == error_mark_node) 431918334Speter return error_mark_node; 432018334Speter return valid_compound_expr_initializer (TREE_OPERAND (value, 1), 432118334Speter endtype); 432218334Speter } 4323169689Skan else if (!initializer_constant_valid_p (value, endtype)) 432418334Speter return error_mark_node; 432518334Speter else 432618334Speter return value; 432718334Speter} 432818334Speter 432918334Speter/* Perform appropriate conversions on the initial value of a variable, 433018334Speter store it in the declaration DECL, 433118334Speter and print any error messages that are appropriate. 433218334Speter If the init is invalid, store an ERROR_MARK. */ 433318334Speter 433418334Spetervoid 4335132718Skanstore_init_value (tree decl, tree init) 433618334Speter{ 433790075Sobrien tree value, type; 433818334Speter 433918334Speter /* If variable's type was invalidly declared, just ignore it. */ 434018334Speter 434118334Speter type = TREE_TYPE (decl); 434218334Speter if (TREE_CODE (type) == ERROR_MARK) 434318334Speter return; 434418334Speter 434518334Speter /* Digest the specified initializer into an expression. */ 434618334Speter 4347169689Skan value = digest_init (type, init, true, TREE_STATIC (decl)); 434818334Speter 434918334Speter /* Store the expression if valid; else report error. */ 435018334Speter 4351169689Skan if (!in_system_header 4352169689Skan && AGGREGATE_TYPE_P (TREE_TYPE (decl)) && !TREE_STATIC (decl)) 4353169689Skan warning (OPT_Wtraditional, "traditional C rejects automatic " 4354169689Skan "aggregate initialization"); 435590075Sobrien 435618334Speter DECL_INITIAL (decl) = value; 435718334Speter 435818334Speter /* ANSI wants warnings about out-of-range constant initializers. */ 435918334Speter STRIP_TYPE_NOPS (value); 436018334Speter constant_expression_warning (value); 436190075Sobrien 436290075Sobrien /* Check if we need to set array size from compound literal size. */ 436390075Sobrien if (TREE_CODE (type) == ARRAY_TYPE 436490075Sobrien && TYPE_DOMAIN (type) == 0 436590075Sobrien && value != error_mark_node) 436690075Sobrien { 436790075Sobrien tree inside_init = init; 436890075Sobrien 4369169689Skan STRIP_TYPE_NOPS (inside_init); 437090075Sobrien inside_init = fold (inside_init); 437190075Sobrien 437290075Sobrien if (TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR) 437390075Sobrien { 4374169689Skan tree cldecl = COMPOUND_LITERAL_EXPR_DECL (inside_init); 437590075Sobrien 4376169689Skan if (TYPE_DOMAIN (TREE_TYPE (cldecl))) 437790075Sobrien { 437890075Sobrien /* For int foo[] = (int [3]){1}; we need to set array size 437990075Sobrien now since later on array initializer will be just the 438090075Sobrien brace enclosed list of the compound literal. */ 4381169689Skan type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type)); 4382169689Skan TREE_TYPE (decl) = type; 4383169689Skan TYPE_DOMAIN (type) = TYPE_DOMAIN (TREE_TYPE (cldecl)); 438490075Sobrien layout_type (type); 4385169689Skan layout_decl (cldecl, 0); 438690075Sobrien } 438790075Sobrien } 438890075Sobrien } 438918334Speter} 439018334Speter 439118334Speter/* Methods for storing and printing names for error messages. */ 439218334Speter 439318334Speter/* Implement a spelling stack that allows components of a name to be pushed 439418334Speter and popped. Each element on the stack is this structure. */ 439518334Speter 439618334Speterstruct spelling 439718334Speter{ 439818334Speter int kind; 439918334Speter union 440018334Speter { 4401169689Skan unsigned HOST_WIDE_INT i; 440252284Sobrien const char *s; 440318334Speter } u; 440418334Speter}; 440518334Speter 440618334Speter#define SPELLING_STRING 1 440718334Speter#define SPELLING_MEMBER 2 440818334Speter#define SPELLING_BOUNDS 3 440918334Speter 441018334Speterstatic struct spelling *spelling; /* Next stack element (unused). */ 441118334Speterstatic struct spelling *spelling_base; /* Spelling stack base. */ 441218334Speterstatic int spelling_size; /* Size of the spelling stack. */ 441318334Speter 441418334Speter/* Macros to save and restore the spelling stack around push_... functions. 441518334Speter Alternative to SAVE_SPELLING_STACK. */ 441618334Speter 441718334Speter#define SPELLING_DEPTH() (spelling - spelling_base) 441890075Sobrien#define RESTORE_SPELLING_DEPTH(DEPTH) (spelling = spelling_base + (DEPTH)) 441918334Speter 442018334Speter/* Push an element on the spelling stack with type KIND and assign VALUE 442118334Speter to MEMBER. */ 442218334Speter 442318334Speter#define PUSH_SPELLING(KIND, VALUE, MEMBER) \ 442418334Speter{ \ 442518334Speter int depth = SPELLING_DEPTH (); \ 442618334Speter \ 442718334Speter if (depth >= spelling_size) \ 442818334Speter { \ 442918334Speter spelling_size += 10; \ 4430169689Skan spelling_base = XRESIZEVEC (struct spelling, spelling_base, \ 4431169689Skan spelling_size); \ 443218334Speter RESTORE_SPELLING_DEPTH (depth); \ 443318334Speter } \ 443418334Speter \ 443518334Speter spelling->kind = (KIND); \ 443618334Speter spelling->MEMBER = (VALUE); \ 443718334Speter spelling++; \ 443818334Speter} 443918334Speter 444018334Speter/* Push STRING on the stack. Printed literally. */ 444118334Speter 444218334Speterstatic void 4443132718Skanpush_string (const char *string) 444418334Speter{ 444518334Speter PUSH_SPELLING (SPELLING_STRING, string, u.s); 444618334Speter} 444718334Speter 444818334Speter/* Push a member name on the stack. Printed as '.' STRING. */ 444918334Speter 445018334Speterstatic void 4451132718Skanpush_member_name (tree decl) 445218334Speter{ 445390075Sobrien const char *const string 445418334Speter = DECL_NAME (decl) ? IDENTIFIER_POINTER (DECL_NAME (decl)) : "<anonymous>"; 445518334Speter PUSH_SPELLING (SPELLING_MEMBER, string, u.s); 445618334Speter} 445718334Speter 445818334Speter/* Push an array bounds on the stack. Printed as [BOUNDS]. */ 445918334Speter 446018334Speterstatic void 4461169689Skanpush_array_bounds (unsigned HOST_WIDE_INT bounds) 446218334Speter{ 446318334Speter PUSH_SPELLING (SPELLING_BOUNDS, bounds, u.i); 446418334Speter} 446518334Speter 446618334Speter/* Compute the maximum size in bytes of the printed spelling. */ 446718334Speter 446818334Speterstatic int 4469132718Skanspelling_length (void) 447018334Speter{ 447190075Sobrien int size = 0; 447290075Sobrien struct spelling *p; 447318334Speter 447418334Speter for (p = spelling_base; p < spelling; p++) 447518334Speter { 447618334Speter if (p->kind == SPELLING_BOUNDS) 447718334Speter size += 25; 447818334Speter else 447918334Speter size += strlen (p->u.s) + 1; 448018334Speter } 448118334Speter 448218334Speter return size; 448318334Speter} 448418334Speter 448518334Speter/* Print the spelling to BUFFER and return it. */ 448618334Speter 448718334Speterstatic char * 4488132718Skanprint_spelling (char *buffer) 448918334Speter{ 449090075Sobrien char *d = buffer; 449190075Sobrien struct spelling *p; 449218334Speter 449318334Speter for (p = spelling_base; p < spelling; p++) 449418334Speter if (p->kind == SPELLING_BOUNDS) 449518334Speter { 4496169689Skan sprintf (d, "[" HOST_WIDE_INT_PRINT_UNSIGNED "]", p->u.i); 449718334Speter d += strlen (d); 449818334Speter } 449918334Speter else 450018334Speter { 450190075Sobrien const char *s; 450218334Speter if (p->kind == SPELLING_MEMBER) 450318334Speter *d++ = '.'; 450450397Sobrien for (s = p->u.s; (*d = *s++); d++) 450518334Speter ; 450618334Speter } 450718334Speter *d++ = '\0'; 450818334Speter return buffer; 450918334Speter} 451018334Speter 451118334Speter/* Issue an error message for a bad initializer component. 451252284Sobrien MSGID identifies the message. 451352284Sobrien The component name is taken from the spelling stack. */ 451418334Speter 451518334Spetervoid 4516132718Skanerror_init (const char *msgid) 451718334Speter{ 451852284Sobrien char *ofwhat; 451918334Speter 452090075Sobrien error ("%s", _(msgid)); 4521169689Skan ofwhat = print_spelling ((char *) alloca (spelling_length () + 1)); 452218334Speter if (*ofwhat) 4523169689Skan error ("(near initialization for %qs)", ofwhat); 452418334Speter} 452518334Speter 452618334Speter/* Issue a pedantic warning for a bad initializer component. 452752284Sobrien MSGID identifies the message. 452852284Sobrien The component name is taken from the spelling stack. */ 452918334Speter 453018334Spetervoid 4531132718Skanpedwarn_init (const char *msgid) 453218334Speter{ 453352284Sobrien char *ofwhat; 453418334Speter 453590075Sobrien pedwarn ("%s", _(msgid)); 4536169689Skan ofwhat = print_spelling ((char *) alloca (spelling_length () + 1)); 453718334Speter if (*ofwhat) 4538169689Skan pedwarn ("(near initialization for %qs)", ofwhat); 453918334Speter} 454018334Speter 454118334Speter/* Issue a warning for a bad initializer component. 454252284Sobrien MSGID identifies the message. 454352284Sobrien The component name is taken from the spelling stack. */ 454418334Speter 454518334Speterstatic void 4546132718Skanwarning_init (const char *msgid) 454718334Speter{ 454852284Sobrien char *ofwhat; 454918334Speter 4550169689Skan warning (0, "%s", _(msgid)); 4551169689Skan ofwhat = print_spelling ((char *) alloca (spelling_length () + 1)); 455218334Speter if (*ofwhat) 4553169689Skan warning (0, "(near initialization for %qs)", ofwhat); 455418334Speter} 455518334Speter 4556169689Skan/* If TYPE is an array type and EXPR is a parenthesized string 4557169689Skan constant, warn if pedantic that EXPR is being used to initialize an 4558169689Skan object of type TYPE. */ 4559169689Skan 4560169689Skanvoid 4561169689Skanmaybe_warn_string_init (tree type, struct c_expr expr) 4562169689Skan{ 4563169689Skan if (pedantic 4564169689Skan && TREE_CODE (type) == ARRAY_TYPE 4565169689Skan && TREE_CODE (expr.value) == STRING_CST 4566169689Skan && expr.original_code != STRING_CST) 4567169689Skan pedwarn_init ("array initialized from parenthesized string constant"); 4568169689Skan} 4569169689Skan 457018334Speter/* Digest the parser output INIT as an initializer for type TYPE. 457118334Speter Return a C expression of type TYPE to represent the initial value. 457218334Speter 4573169689Skan If INIT is a string constant, STRICT_STRING is true if it is 4574169689Skan unparenthesized or we should not warn here for it being parenthesized. 4575169689Skan For other types of INIT, STRICT_STRING is not used. 4576169689Skan 4577117395Skan REQUIRE_CONSTANT requests an error if non-constant initializers or 4578117395Skan elements are seen. */ 457918334Speter 458018334Speterstatic tree 4581169689Skandigest_init (tree type, tree init, bool strict_string, int require_constant) 458218334Speter{ 458318334Speter enum tree_code code = TREE_CODE (type); 458418334Speter tree inside_init = init; 458518334Speter 458690075Sobrien if (type == error_mark_node 4587169689Skan || !init 458890075Sobrien || init == error_mark_node 458990075Sobrien || TREE_TYPE (init) == error_mark_node) 459090075Sobrien return error_mark_node; 459118334Speter 4592169689Skan STRIP_TYPE_NOPS (inside_init); 459318334Speter 459490075Sobrien inside_init = fold (inside_init); 459590075Sobrien 459618334Speter /* Initialization of an array of chars from a string constant 459718334Speter optionally enclosed in braces. */ 459818334Speter 4599169689Skan if (code == ARRAY_TYPE && inside_init 4600169689Skan && TREE_CODE (inside_init) == STRING_CST) 460118334Speter { 460218334Speter tree typ1 = TYPE_MAIN_VARIANT (TREE_TYPE (type)); 4603169689Skan /* Note that an array could be both an array of character type 4604169689Skan and an array of wchar_t if wchar_t is signed char or unsigned 4605169689Skan char. */ 4606169689Skan bool char_array = (typ1 == char_type_node 4607169689Skan || typ1 == signed_char_type_node 4608169689Skan || typ1 == unsigned_char_type_node); 4609169689Skan bool wchar_array = !!comptypes (typ1, wchar_type_node); 4610169689Skan if (char_array || wchar_array) 461118334Speter { 4612169689Skan struct c_expr expr; 4613169689Skan bool char_string; 4614169689Skan expr.value = inside_init; 4615169689Skan expr.original_code = (strict_string ? STRING_CST : ERROR_MARK); 4616169689Skan maybe_warn_string_init (type, expr); 4617169689Skan 4618169689Skan char_string 4619169689Skan = (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (inside_init))) 4620169689Skan == char_type_node); 4621169689Skan 462218334Speter if (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), 4623169689Skan TYPE_MAIN_VARIANT (type))) 462418334Speter return inside_init; 462518334Speter 4626169689Skan if (!wchar_array && !char_string) 462718334Speter { 462852284Sobrien error_init ("char-array initialized from wide string"); 462918334Speter return error_mark_node; 463018334Speter } 4631169689Skan if (char_string && !char_array) 463218334Speter { 4633169689Skan error_init ("wchar_t-array initialized from non-wide string"); 463418334Speter return error_mark_node; 463518334Speter } 463618334Speter 463718334Speter TREE_TYPE (inside_init) = type; 463818334Speter if (TYPE_DOMAIN (type) != 0 463990075Sobrien && TYPE_SIZE (type) != 0 464090075Sobrien && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST 464118334Speter /* Subtract 1 (or sizeof (wchar_t)) 464218334Speter because it's ok to ignore the terminating null char 464318334Speter that is counted in the length of the constant. */ 464490075Sobrien && 0 > compare_tree_int (TYPE_SIZE_UNIT (type), 464590075Sobrien TREE_STRING_LENGTH (inside_init) 464690075Sobrien - ((TYPE_PRECISION (typ1) 464790075Sobrien != TYPE_PRECISION (char_type_node)) 464890075Sobrien ? (TYPE_PRECISION (wchar_type_node) 464990075Sobrien / BITS_PER_UNIT) 465090075Sobrien : 1))) 465190075Sobrien pedwarn_init ("initializer-string for array of chars is too long"); 465290075Sobrien 465318334Speter return inside_init; 465418334Speter } 4655169689Skan else if (INTEGRAL_TYPE_P (typ1)) 4656169689Skan { 4657169689Skan error_init ("array of inappropriate type initialized " 4658169689Skan "from string constant"); 4659169689Skan return error_mark_node; 4660169689Skan } 466118334Speter } 4662132718Skan 4663119256Skan /* Build a VECTOR_CST from a *constant* vector constructor. If the 4664119256Skan vector constructor is not constant (e.g. {1,2,3,foo()}) then punt 4665119256Skan below and handle as a constructor. */ 4666146895Skan if (code == VECTOR_TYPE 4667161651Skan && TREE_CODE (TREE_TYPE (inside_init)) == VECTOR_TYPE 4668161651Skan && vector_types_convertible_p (TREE_TYPE (inside_init), type) 4669146895Skan && TREE_CONSTANT (inside_init)) 4670146895Skan { 4671146895Skan if (TREE_CODE (inside_init) == VECTOR_CST 4672146895Skan && comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), 4673169689Skan TYPE_MAIN_VARIANT (type))) 4674146895Skan return inside_init; 467518334Speter 4676146895Skan if (TREE_CODE (inside_init) == CONSTRUCTOR) 4677146895Skan { 4678169689Skan unsigned HOST_WIDE_INT ix; 4679169689Skan tree value; 4680169689Skan bool constant_p = true; 4681169689Skan 4682169689Skan /* Iterate through elements and check if all constructor 4683169689Skan elements are *_CSTs. */ 4684169689Skan FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (inside_init), ix, value) 4685169689Skan if (!CONSTANT_CLASS_P (value)) 4686169689Skan { 4687169689Skan constant_p = false; 4688169689Skan break; 4689169689Skan } 4690169689Skan 4691169689Skan if (constant_p) 4692169689Skan return build_vector_from_ctor (type, 4693169689Skan CONSTRUCTOR_ELTS (inside_init)); 4694169689Skan } 4695146895Skan } 4696146895Skan 469718334Speter /* Any type can be initialized 469818334Speter from an expression of the same type, optionally with braces. */ 469918334Speter 470018334Speter if (inside_init && TREE_TYPE (inside_init) != 0 470118334Speter && (comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (inside_init)), 4702169689Skan TYPE_MAIN_VARIANT (type)) 470318334Speter || (code == ARRAY_TYPE 4704169689Skan && comptypes (TREE_TYPE (inside_init), type)) 470596263Sobrien || (code == VECTOR_TYPE 4706169689Skan && comptypes (TREE_TYPE (inside_init), type)) 470718334Speter || (code == POINTER_TYPE 4708132718Skan && TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE 470918334Speter && comptypes (TREE_TYPE (TREE_TYPE (inside_init)), 4710169689Skan TREE_TYPE (type))))) 471118334Speter { 471290075Sobrien if (code == POINTER_TYPE) 4713122180Skan { 4714122180Skan if (TREE_CODE (TREE_TYPE (inside_init)) == ARRAY_TYPE) 4715122180Skan { 4716169689Skan if (TREE_CODE (inside_init) == STRING_CST 4717169689Skan || TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR) 4718169689Skan inside_init = array_to_pointer_conversion (inside_init); 4719169689Skan else 4720169689Skan { 4721169689Skan error_init ("invalid use of non-lvalue array"); 4722169689Skan return error_mark_node; 4723169689Skan } 4724122180Skan } 4725169689Skan } 4726132718Skan 4727132718Skan if (code == VECTOR_TYPE) 4728132718Skan /* Although the types are compatible, we may require a 4729132718Skan conversion. */ 4730132718Skan inside_init = convert (type, inside_init); 4731132718Skan 4732169689Skan if (require_constant 4733169689Skan && (code == VECTOR_TYPE || !flag_isoc99) 473490075Sobrien && TREE_CODE (inside_init) == COMPOUND_LITERAL_EXPR) 473518334Speter { 473690075Sobrien /* As an extension, allow initializing objects with static storage 473790075Sobrien duration with compound literals (which are then treated just as 4738169689Skan the brace enclosed list they contain). Also allow this for 4739169689Skan vectors, as we can only assign them with compound literals. */ 474090075Sobrien tree decl = COMPOUND_LITERAL_EXPR_DECL (inside_init); 474190075Sobrien inside_init = DECL_INITIAL (decl); 474290075Sobrien } 474390075Sobrien 474490075Sobrien if (code == ARRAY_TYPE && TREE_CODE (inside_init) != STRING_CST 474590075Sobrien && TREE_CODE (inside_init) != CONSTRUCTOR) 474690075Sobrien { 474752284Sobrien error_init ("array initialized from non-constant array expression"); 474818334Speter return error_mark_node; 474918334Speter } 475018334Speter 475118334Speter if (optimize && TREE_CODE (inside_init) == VAR_DECL) 475290075Sobrien inside_init = decl_constant_value_for_broken_optimization (inside_init); 475318334Speter 475418334Speter /* Compound expressions can only occur here if -pedantic or 475518334Speter -pedantic-errors is specified. In the later case, we always want 475618334Speter an error. In the former case, we simply want a warning. */ 475718334Speter if (require_constant && pedantic 475818334Speter && TREE_CODE (inside_init) == COMPOUND_EXPR) 475918334Speter { 476018334Speter inside_init 476118334Speter = valid_compound_expr_initializer (inside_init, 476218334Speter TREE_TYPE (inside_init)); 476318334Speter if (inside_init == error_mark_node) 476452284Sobrien error_init ("initializer element is not constant"); 476518334Speter else 476652284Sobrien pedwarn_init ("initializer element is not constant"); 476718334Speter if (flag_pedantic_errors) 476818334Speter inside_init = error_mark_node; 476918334Speter } 4770132718Skan else if (require_constant 4771169689Skan && !initializer_constant_valid_p (inside_init, 4772169689Skan TREE_TYPE (inside_init))) 477318334Speter { 477452284Sobrien error_init ("initializer element is not constant"); 477518334Speter inside_init = error_mark_node; 477618334Speter } 477718334Speter 4778169689Skan /* Added to enable additional -Wmissing-format-attribute warnings. */ 4779169689Skan if (TREE_CODE (TREE_TYPE (inside_init)) == POINTER_TYPE) 4780169689Skan inside_init = convert_for_assignment (type, inside_init, ic_init, NULL_TREE, 4781169689Skan NULL_TREE, 0); 478218334Speter return inside_init; 478318334Speter } 478418334Speter 478518334Speter /* Handle scalar types, including conversions. */ 478618334Speter 478718334Speter if (code == INTEGER_TYPE || code == REAL_TYPE || code == POINTER_TYPE 4788169689Skan || code == ENUMERAL_TYPE || code == BOOLEAN_TYPE || code == COMPLEX_TYPE 4789169689Skan || code == VECTOR_TYPE) 479018334Speter { 4791169689Skan if (TREE_CODE (TREE_TYPE (init)) == ARRAY_TYPE 4792169689Skan && (TREE_CODE (init) == STRING_CST 4793169689Skan || TREE_CODE (init) == COMPOUND_LITERAL_EXPR)) 4794169689Skan init = array_to_pointer_conversion (init); 479518334Speter inside_init 4796169689Skan = convert_for_assignment (type, init, ic_init, 479718334Speter NULL_TREE, NULL_TREE, 0); 479818334Speter 4799169689Skan /* Check to see if we have already given an error message. */ 4800169689Skan if (inside_init == error_mark_node) 4801169689Skan ; 4802169689Skan else if (require_constant && !TREE_CONSTANT (inside_init)) 480318334Speter { 480452284Sobrien error_init ("initializer element is not constant"); 480518334Speter inside_init = error_mark_node; 480618334Speter } 480718334Speter else if (require_constant 4808169689Skan && !initializer_constant_valid_p (inside_init, 4809169689Skan TREE_TYPE (inside_init))) 481018334Speter { 481152284Sobrien error_init ("initializer element is not computable at load time"); 481218334Speter inside_init = error_mark_node; 481318334Speter } 481418334Speter 481518334Speter return inside_init; 481618334Speter } 481718334Speter 481818334Speter /* Come here only for records and arrays. */ 481918334Speter 482090075Sobrien if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST) 482118334Speter { 482252284Sobrien error_init ("variable-sized object may not be initialized"); 482318334Speter return error_mark_node; 482418334Speter } 482518334Speter 482652284Sobrien error_init ("invalid initializer"); 482718334Speter return error_mark_node; 482818334Speter} 482918334Speter 483018334Speter/* Handle initializers that use braces. */ 483118334Speter 483218334Speter/* Type of object we are accumulating a constructor for. 483318334Speter This type is always a RECORD_TYPE, UNION_TYPE or ARRAY_TYPE. */ 483418334Speterstatic tree constructor_type; 483518334Speter 483618334Speter/* For a RECORD_TYPE or UNION_TYPE, this is the chain of fields 483718334Speter left to fill. */ 483818334Speterstatic tree constructor_fields; 483918334Speter 484018334Speter/* For an ARRAY_TYPE, this is the specified index 484190075Sobrien at which to store the next element we get. */ 484218334Speterstatic tree constructor_index; 484318334Speter 484418334Speter/* For an ARRAY_TYPE, this is the maximum index. */ 484518334Speterstatic tree constructor_max_index; 484618334Speter 484718334Speter/* For a RECORD_TYPE, this is the first field not yet written out. */ 484818334Speterstatic tree constructor_unfilled_fields; 484918334Speter 485018334Speter/* For an ARRAY_TYPE, this is the index of the first element 485190075Sobrien not yet written out. */ 485218334Speterstatic tree constructor_unfilled_index; 485318334Speter 485418334Speter/* In a RECORD_TYPE, the byte index of the next consecutive field. 485590075Sobrien This is so we can generate gaps between fields, when appropriate. */ 485618334Speterstatic tree constructor_bit_index; 485718334Speter 485818334Speter/* If we are saving up the elements rather than allocating them, 485918334Speter this is the list of elements so far (in reverse order, 486018334Speter most recent first). */ 4861169689Skanstatic VEC(constructor_elt,gc) *constructor_elements; 486218334Speter 486390075Sobrien/* 1 if constructor should be incrementally stored into a constructor chain, 486490075Sobrien 0 if all the elements should be kept in AVL tree. */ 486590075Sobrienstatic int constructor_incremental; 486690075Sobrien 486718334Speter/* 1 if so far this constructor's elements are all compile-time constants. */ 486818334Speterstatic int constructor_constant; 486918334Speter 487018334Speter/* 1 if so far this constructor's elements are all valid address constants. */ 487118334Speterstatic int constructor_simple; 487218334Speter 487318334Speter/* 1 if this constructor is erroneous so far. */ 487418334Speterstatic int constructor_erroneous; 487518334Speter 487650397Sobrien/* Structure for managing pending initializer elements, organized as an 487750397Sobrien AVL tree. */ 487850397Sobrien 487950397Sobrienstruct init_node 488050397Sobrien{ 488150397Sobrien struct init_node *left, *right; 488250397Sobrien struct init_node *parent; 488350397Sobrien int balance; 488450397Sobrien tree purpose; 488550397Sobrien tree value; 488650397Sobrien}; 488750397Sobrien 488850397Sobrien/* Tree of pending elements at this constructor level. 488918334Speter These are elements encountered out of order 489018334Speter which belong at places we haven't reached yet in actually 489190075Sobrien writing the output. 489290075Sobrien Will never hold tree nodes across GC runs. */ 489350397Sobrienstatic struct init_node *constructor_pending_elts; 489418334Speter 489518334Speter/* The SPELLING_DEPTH of this constructor. */ 489618334Speterstatic int constructor_depth; 489718334Speter 489818334Speter/* DECL node for which an initializer is being read. 489918334Speter 0 means we are reading a constructor expression 490018334Speter such as (struct foo) {...}. */ 490118334Speterstatic tree constructor_decl; 490218334Speter 490318334Speter/* Nonzero if this is an initializer for a top-level decl. */ 490418334Speterstatic int constructor_top_level; 490518334Speter 490690075Sobrien/* Nonzero if there were any member designators in this initializer. */ 490790075Sobrienstatic int constructor_designated; 490890075Sobrien 490990075Sobrien/* Nesting depth of designator list. */ 491090075Sobrienstatic int designator_depth; 491190075Sobrien 491290075Sobrien/* Nonzero if there were diagnosed errors in this designator list. */ 4913169689Skanstatic int designator_erroneous; 491490075Sobrien 491518334Speter 491618334Speter/* This stack has a level for each implicit or explicit level of 491718334Speter structuring in the initializer, including the outermost one. It 491818334Speter saves the values of most of the variables above. */ 491918334Speter 492090075Sobrienstruct constructor_range_stack; 492190075Sobrien 492218334Speterstruct constructor_stack 492318334Speter{ 492418334Speter struct constructor_stack *next; 492518334Speter tree type; 492618334Speter tree fields; 492718334Speter tree index; 492818334Speter tree max_index; 492918334Speter tree unfilled_index; 493018334Speter tree unfilled_fields; 493118334Speter tree bit_index; 4932169689Skan VEC(constructor_elt,gc) *elements; 493390075Sobrien struct init_node *pending_elts; 493418334Speter int offset; 493518334Speter int depth; 4936169689Skan /* If value nonzero, this value should replace the entire 493718334Speter constructor at this level. */ 4938169689Skan struct c_expr replacement_value; 493990075Sobrien struct constructor_range_stack *range_stack; 494018334Speter char constant; 494118334Speter char simple; 494218334Speter char implicit; 494318334Speter char erroneous; 494418334Speter char outer; 494590075Sobrien char incremental; 494690075Sobrien char designated; 494718334Speter}; 494818334Speter 4949169689Skanstatic struct constructor_stack *constructor_stack; 495018334Speter 495190075Sobrien/* This stack represents designators from some range designator up to 495290075Sobrien the last designator in the list. */ 495390075Sobrien 495490075Sobrienstruct constructor_range_stack 495590075Sobrien{ 495690075Sobrien struct constructor_range_stack *next, *prev; 495790075Sobrien struct constructor_stack *stack; 495890075Sobrien tree range_start; 495990075Sobrien tree index; 496090075Sobrien tree range_end; 496190075Sobrien tree fields; 496290075Sobrien}; 496390075Sobrien 4964169689Skanstatic struct constructor_range_stack *constructor_range_stack; 496590075Sobrien 496618334Speter/* This stack records separate initializers that are nested. 496718334Speter Nested initializers can't happen in ANSI C, but GNU C allows them 496818334Speter in cases like { ... (struct foo) { ... } ... }. */ 496918334Speter 497018334Speterstruct initializer_stack 497118334Speter{ 497218334Speter struct initializer_stack *next; 497318334Speter tree decl; 497418334Speter struct constructor_stack *constructor_stack; 497590075Sobrien struct constructor_range_stack *constructor_range_stack; 4976169689Skan VEC(constructor_elt,gc) *elements; 497718334Speter struct spelling *spelling; 497818334Speter struct spelling *spelling_base; 497918334Speter int spelling_size; 498018334Speter char top_level; 498118334Speter char require_constant_value; 498218334Speter char require_constant_elements; 498318334Speter}; 498418334Speter 4985169689Skanstatic struct initializer_stack *initializer_stack; 498618334Speter 498718334Speter/* Prepare to parse and output the initializer for variable DECL. */ 498818334Speter 498918334Spetervoid 4990169689Skanstart_init (tree decl, tree asmspec_tree ATTRIBUTE_UNUSED, int top_level) 499118334Speter{ 499252284Sobrien const char *locus; 4993169689Skan struct initializer_stack *p = XNEW (struct initializer_stack); 499418334Speter 499518334Speter p->decl = constructor_decl; 499618334Speter p->require_constant_value = require_constant_value; 499718334Speter p->require_constant_elements = require_constant_elements; 499818334Speter p->constructor_stack = constructor_stack; 499990075Sobrien p->constructor_range_stack = constructor_range_stack; 500018334Speter p->elements = constructor_elements; 500118334Speter p->spelling = spelling; 500218334Speter p->spelling_base = spelling_base; 500318334Speter p->spelling_size = spelling_size; 500418334Speter p->top_level = constructor_top_level; 500518334Speter p->next = initializer_stack; 500618334Speter initializer_stack = p; 500718334Speter 500818334Speter constructor_decl = decl; 500990075Sobrien constructor_designated = 0; 501018334Speter constructor_top_level = top_level; 501118334Speter 5012169689Skan if (decl != 0 && decl != error_mark_node) 501318334Speter { 501418334Speter require_constant_value = TREE_STATIC (decl); 501518334Speter require_constant_elements 501690075Sobrien = ((TREE_STATIC (decl) || (pedantic && !flag_isoc99)) 501718334Speter /* For a scalar, you can always use any value to initialize, 501818334Speter even within braces. */ 501918334Speter && (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE 502018334Speter || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE 502118334Speter || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE 502218334Speter || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE)); 502318334Speter locus = IDENTIFIER_POINTER (DECL_NAME (decl)); 502418334Speter } 502518334Speter else 502618334Speter { 502718334Speter require_constant_value = 0; 502818334Speter require_constant_elements = 0; 502918334Speter locus = "(anonymous)"; 503018334Speter } 503118334Speter 503218334Speter constructor_stack = 0; 503390075Sobrien constructor_range_stack = 0; 503418334Speter 503518334Speter missing_braces_mentioned = 0; 503618334Speter 503718334Speter spelling_base = 0; 503818334Speter spelling_size = 0; 503918334Speter RESTORE_SPELLING_DEPTH (0); 504018334Speter 504118334Speter if (locus) 504218334Speter push_string (locus); 504318334Speter} 504418334Speter 504518334Spetervoid 5046132718Skanfinish_init (void) 504718334Speter{ 504818334Speter struct initializer_stack *p = initializer_stack; 504918334Speter 505018334Speter /* Free the whole constructor stack of this initializer. */ 505118334Speter while (constructor_stack) 505218334Speter { 505318334Speter struct constructor_stack *q = constructor_stack; 505418334Speter constructor_stack = q->next; 505518334Speter free (q); 505618334Speter } 505718334Speter 5058169689Skan gcc_assert (!constructor_range_stack); 505990075Sobrien 506018334Speter /* Pop back to the data of the outer initializer (if any). */ 5061132718Skan free (spelling_base); 5062132718Skan 506318334Speter constructor_decl = p->decl; 506418334Speter require_constant_value = p->require_constant_value; 506518334Speter require_constant_elements = p->require_constant_elements; 506618334Speter constructor_stack = p->constructor_stack; 506790075Sobrien constructor_range_stack = p->constructor_range_stack; 506818334Speter constructor_elements = p->elements; 506918334Speter spelling = p->spelling; 507018334Speter spelling_base = p->spelling_base; 507118334Speter spelling_size = p->spelling_size; 507218334Speter constructor_top_level = p->top_level; 507318334Speter initializer_stack = p->next; 507418334Speter free (p); 507518334Speter} 507618334Speter 507718334Speter/* Call here when we see the initializer is surrounded by braces. 507818334Speter This is instead of a call to push_init_level; 507918334Speter it is matched by a call to pop_init_level. 508018334Speter 508118334Speter TYPE is the type to initialize, for a constructor expression. 508218334Speter For an initializer for a decl, TYPE is zero. */ 508318334Speter 508418334Spetervoid 5085132718Skanreally_start_incremental_init (tree type) 508618334Speter{ 5087169689Skan struct constructor_stack *p = XNEW (struct constructor_stack); 508818334Speter 508918334Speter if (type == 0) 509018334Speter type = TREE_TYPE (constructor_decl); 509118334Speter 5092169689Skan if (targetm.vector_opaque_p (type)) 5093132718Skan error ("opaque vector types cannot be initialized"); 5094132718Skan 509518334Speter p->type = constructor_type; 509618334Speter p->fields = constructor_fields; 509718334Speter p->index = constructor_index; 509818334Speter p->max_index = constructor_max_index; 509918334Speter p->unfilled_index = constructor_unfilled_index; 510018334Speter p->unfilled_fields = constructor_unfilled_fields; 510118334Speter p->bit_index = constructor_bit_index; 510218334Speter p->elements = constructor_elements; 510318334Speter p->constant = constructor_constant; 510418334Speter p->simple = constructor_simple; 510518334Speter p->erroneous = constructor_erroneous; 510618334Speter p->pending_elts = constructor_pending_elts; 510718334Speter p->depth = constructor_depth; 5108169689Skan p->replacement_value.value = 0; 5109169689Skan p->replacement_value.original_code = ERROR_MARK; 511018334Speter p->implicit = 0; 511190075Sobrien p->range_stack = 0; 511290075Sobrien p->outer = 0; 511318334Speter p->incremental = constructor_incremental; 511490075Sobrien p->designated = constructor_designated; 511518334Speter p->next = 0; 511618334Speter constructor_stack = p; 511718334Speter 511818334Speter constructor_constant = 1; 511918334Speter constructor_simple = 1; 512018334Speter constructor_depth = SPELLING_DEPTH (); 512118334Speter constructor_elements = 0; 512218334Speter constructor_pending_elts = 0; 512318334Speter constructor_type = type; 512490075Sobrien constructor_incremental = 1; 512590075Sobrien constructor_designated = 0; 512690075Sobrien designator_depth = 0; 5127169689Skan designator_erroneous = 0; 512818334Speter 512918334Speter if (TREE_CODE (constructor_type) == RECORD_TYPE 513018334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 513118334Speter { 513218334Speter constructor_fields = TYPE_FIELDS (constructor_type); 513318334Speter /* Skip any nameless bit fields at the beginning. */ 513450397Sobrien while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields) 513518334Speter && DECL_NAME (constructor_fields) == 0) 513618334Speter constructor_fields = TREE_CHAIN (constructor_fields); 513790075Sobrien 513818334Speter constructor_unfilled_fields = constructor_fields; 513990075Sobrien constructor_bit_index = bitsize_zero_node; 514018334Speter } 514118334Speter else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 514218334Speter { 514318334Speter if (TYPE_DOMAIN (constructor_type)) 514418334Speter { 514518334Speter constructor_max_index 514618334Speter = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)); 514790075Sobrien 514890075Sobrien /* Detect non-empty initializations of zero-length arrays. */ 514990075Sobrien if (constructor_max_index == NULL_TREE 515090075Sobrien && TYPE_SIZE (constructor_type)) 5151169689Skan constructor_max_index = build_int_cst (NULL_TREE, -1); 515290075Sobrien 515390075Sobrien /* constructor_max_index needs to be an INTEGER_CST. Attempts 5154117395Skan to initialize VLAs will cause a proper error; avoid tree 515590075Sobrien checking errors as well by setting a safe value. */ 515690075Sobrien if (constructor_max_index 515790075Sobrien && TREE_CODE (constructor_max_index) != INTEGER_CST) 5158169689Skan constructor_max_index = build_int_cst (NULL_TREE, -1); 515990075Sobrien 516018334Speter constructor_index 516190075Sobrien = convert (bitsizetype, 516290075Sobrien TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type))); 516318334Speter } 516418334Speter else 5165169689Skan { 5166169689Skan constructor_index = bitsize_zero_node; 5167169689Skan constructor_max_index = NULL_TREE; 5168169689Skan } 516990075Sobrien 517090075Sobrien constructor_unfilled_index = constructor_index; 517118334Speter } 517296263Sobrien else if (TREE_CODE (constructor_type) == VECTOR_TYPE) 517396263Sobrien { 517496263Sobrien /* Vectors are like simple fixed-size arrays. */ 517596263Sobrien constructor_max_index = 5176169689Skan build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1); 5177169689Skan constructor_index = bitsize_zero_node; 517896263Sobrien constructor_unfilled_index = constructor_index; 517996263Sobrien } 518018334Speter else 518118334Speter { 518218334Speter /* Handle the case of int x = {5}; */ 518318334Speter constructor_fields = constructor_type; 518418334Speter constructor_unfilled_fields = constructor_type; 518518334Speter } 518618334Speter} 518718334Speter 518818334Speter/* Push down into a subobject, for initialization. 518918334Speter If this is for an explicit set of braces, IMPLICIT is 0. 519018334Speter If it is because the next element belongs at a lower level, 519190075Sobrien IMPLICIT is 1 (or 2 if the push is because of designator list). */ 519218334Speter 519318334Spetervoid 5194132718Skanpush_init_level (int implicit) 519518334Speter{ 519618334Speter struct constructor_stack *p; 519790075Sobrien tree value = NULL_TREE; 519818334Speter 519918334Speter /* If we've exhausted any levels that didn't have braces, 5200161651Skan pop them now. If implicit == 1, this will have been done in 5201161651Skan process_init_element; do not repeat it here because in the case 5202161651Skan of excess initializers for an empty aggregate this leads to an 5203161651Skan infinite cycle of popping a level and immediately recreating 5204161651Skan it. */ 5205161651Skan if (implicit != 1) 520618334Speter { 5207161651Skan while (constructor_stack->implicit) 5208161651Skan { 5209161651Skan if ((TREE_CODE (constructor_type) == RECORD_TYPE 5210161651Skan || TREE_CODE (constructor_type) == UNION_TYPE) 5211161651Skan && constructor_fields == 0) 5212161651Skan process_init_element (pop_init_level (1)); 5213161651Skan else if (TREE_CODE (constructor_type) == ARRAY_TYPE 5214161651Skan && constructor_max_index 5215161651Skan && tree_int_cst_lt (constructor_max_index, 5216161651Skan constructor_index)) 5217161651Skan process_init_element (pop_init_level (1)); 5218161651Skan else 5219161651Skan break; 5220161651Skan } 522118334Speter } 522218334Speter 522390075Sobrien /* Unless this is an explicit brace, we need to preserve previous 522490075Sobrien content if any. */ 522590075Sobrien if (implicit) 522618334Speter { 522790075Sobrien if ((TREE_CODE (constructor_type) == RECORD_TYPE 522890075Sobrien || TREE_CODE (constructor_type) == UNION_TYPE) 522990075Sobrien && constructor_fields) 523090075Sobrien value = find_init_member (constructor_fields); 523190075Sobrien else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 523290075Sobrien value = find_init_member (constructor_index); 523318334Speter } 523418334Speter 5235169689Skan p = XNEW (struct constructor_stack); 523618334Speter p->type = constructor_type; 523718334Speter p->fields = constructor_fields; 523818334Speter p->index = constructor_index; 523918334Speter p->max_index = constructor_max_index; 524018334Speter p->unfilled_index = constructor_unfilled_index; 524118334Speter p->unfilled_fields = constructor_unfilled_fields; 524218334Speter p->bit_index = constructor_bit_index; 524318334Speter p->elements = constructor_elements; 524418334Speter p->constant = constructor_constant; 524518334Speter p->simple = constructor_simple; 524618334Speter p->erroneous = constructor_erroneous; 524718334Speter p->pending_elts = constructor_pending_elts; 524818334Speter p->depth = constructor_depth; 5249169689Skan p->replacement_value.value = 0; 5250169689Skan p->replacement_value.original_code = ERROR_MARK; 525118334Speter p->implicit = implicit; 525290075Sobrien p->outer = 0; 525318334Speter p->incremental = constructor_incremental; 525490075Sobrien p->designated = constructor_designated; 525518334Speter p->next = constructor_stack; 525690075Sobrien p->range_stack = 0; 525718334Speter constructor_stack = p; 525818334Speter 525918334Speter constructor_constant = 1; 526018334Speter constructor_simple = 1; 526118334Speter constructor_depth = SPELLING_DEPTH (); 526218334Speter constructor_elements = 0; 526390075Sobrien constructor_incremental = 1; 526490075Sobrien constructor_designated = 0; 526518334Speter constructor_pending_elts = 0; 526690075Sobrien if (!implicit) 526790075Sobrien { 526890075Sobrien p->range_stack = constructor_range_stack; 526990075Sobrien constructor_range_stack = 0; 527090075Sobrien designator_depth = 0; 5271169689Skan designator_erroneous = 0; 527290075Sobrien } 527318334Speter 527418334Speter /* Don't die if an entire brace-pair level is superfluous 527518334Speter in the containing level. */ 527618334Speter if (constructor_type == 0) 527718334Speter ; 527818334Speter else if (TREE_CODE (constructor_type) == RECORD_TYPE 527918334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 528018334Speter { 528118334Speter /* Don't die if there are extra init elts at the end. */ 528218334Speter if (constructor_fields == 0) 528318334Speter constructor_type = 0; 528418334Speter else 528518334Speter { 528618334Speter constructor_type = TREE_TYPE (constructor_fields); 528718334Speter push_member_name (constructor_fields); 528818334Speter constructor_depth++; 528918334Speter } 529018334Speter } 529118334Speter else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 529218334Speter { 529318334Speter constructor_type = TREE_TYPE (constructor_type); 5294169689Skan push_array_bounds (tree_low_cst (constructor_index, 1)); 529518334Speter constructor_depth++; 529618334Speter } 529718334Speter 529818334Speter if (constructor_type == 0) 529918334Speter { 530052284Sobrien error_init ("extra brace group at end of initializer"); 530118334Speter constructor_fields = 0; 530218334Speter constructor_unfilled_fields = 0; 530318334Speter return; 530418334Speter } 530518334Speter 530690075Sobrien if (value && TREE_CODE (value) == CONSTRUCTOR) 530790075Sobrien { 530890075Sobrien constructor_constant = TREE_CONSTANT (value); 530990075Sobrien constructor_simple = TREE_STATIC (value); 5310132718Skan constructor_elements = CONSTRUCTOR_ELTS (value); 5311169689Skan if (!VEC_empty (constructor_elt, constructor_elements) 531290075Sobrien && (TREE_CODE (constructor_type) == RECORD_TYPE 531390075Sobrien || TREE_CODE (constructor_type) == ARRAY_TYPE)) 531490075Sobrien set_nonincremental_init (); 531590075Sobrien } 531618334Speter 531790075Sobrien if (implicit == 1 && warn_missing_braces && !missing_braces_mentioned) 531818334Speter { 531918334Speter missing_braces_mentioned = 1; 532052284Sobrien warning_init ("missing braces around initializer"); 532118334Speter } 532218334Speter 532318334Speter if (TREE_CODE (constructor_type) == RECORD_TYPE 532418334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 532518334Speter { 532618334Speter constructor_fields = TYPE_FIELDS (constructor_type); 532718334Speter /* Skip any nameless bit fields at the beginning. */ 532850397Sobrien while (constructor_fields != 0 && DECL_C_BIT_FIELD (constructor_fields) 532918334Speter && DECL_NAME (constructor_fields) == 0) 533018334Speter constructor_fields = TREE_CHAIN (constructor_fields); 533190075Sobrien 533218334Speter constructor_unfilled_fields = constructor_fields; 533390075Sobrien constructor_bit_index = bitsize_zero_node; 533418334Speter } 533596263Sobrien else if (TREE_CODE (constructor_type) == VECTOR_TYPE) 533696263Sobrien { 533796263Sobrien /* Vectors are like simple fixed-size arrays. */ 533896263Sobrien constructor_max_index = 5339169689Skan build_int_cst (NULL_TREE, TYPE_VECTOR_SUBPARTS (constructor_type) - 1); 534096263Sobrien constructor_index = convert (bitsizetype, integer_zero_node); 534196263Sobrien constructor_unfilled_index = constructor_index; 534296263Sobrien } 534318334Speter else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 534418334Speter { 534518334Speter if (TYPE_DOMAIN (constructor_type)) 534618334Speter { 534718334Speter constructor_max_index 534818334Speter = TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type)); 534990075Sobrien 535090075Sobrien /* Detect non-empty initializations of zero-length arrays. */ 535190075Sobrien if (constructor_max_index == NULL_TREE 535290075Sobrien && TYPE_SIZE (constructor_type)) 5353169689Skan constructor_max_index = build_int_cst (NULL_TREE, -1); 535490075Sobrien 535590075Sobrien /* constructor_max_index needs to be an INTEGER_CST. Attempts 5356117395Skan to initialize VLAs will cause a proper error; avoid tree 535790075Sobrien checking errors as well by setting a safe value. */ 535890075Sobrien if (constructor_max_index 535990075Sobrien && TREE_CODE (constructor_max_index) != INTEGER_CST) 5360169689Skan constructor_max_index = build_int_cst (NULL_TREE, -1); 536190075Sobrien 536218334Speter constructor_index 5363132718Skan = convert (bitsizetype, 536490075Sobrien TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type))); 536518334Speter } 536618334Speter else 536790075Sobrien constructor_index = bitsize_zero_node; 536890075Sobrien 536990075Sobrien constructor_unfilled_index = constructor_index; 537090075Sobrien if (value && TREE_CODE (value) == STRING_CST) 537190075Sobrien { 537290075Sobrien /* We need to split the char/wchar array into individual 537390075Sobrien characters, so that we don't have to special case it 537490075Sobrien everywhere. */ 537590075Sobrien set_nonincremental_init_from_string (value); 537690075Sobrien } 537718334Speter } 537818334Speter else 537918334Speter { 5380169689Skan if (constructor_type != error_mark_node) 5381169689Skan warning_init ("braces around scalar initializer"); 538218334Speter constructor_fields = constructor_type; 538318334Speter constructor_unfilled_fields = constructor_type; 538418334Speter } 538518334Speter} 538618334Speter 5387132718Skan/* At the end of an implicit or explicit brace level, 5388169689Skan finish up that level of constructor. If a single expression 5389169689Skan with redundant braces initialized that level, return the 5390169689Skan c_expr structure for that expression. Otherwise, the original_code 5391169689Skan element is set to ERROR_MARK. 5392169689Skan If we were outputting the elements as they are read, return 0 as the value 539318334Speter from inner levels (process_init_element ignores that), 5394169689Skan but return error_mark_node as the value from the outermost level 539518334Speter (that's what we want to put in DECL_INITIAL). 5396169689Skan Otherwise, return a CONSTRUCTOR expression as the value. */ 539718334Speter 5398169689Skanstruct c_expr 5399132718Skanpop_init_level (int implicit) 540018334Speter{ 540118334Speter struct constructor_stack *p; 5402169689Skan struct c_expr ret; 5403169689Skan ret.value = 0; 5404169689Skan ret.original_code = ERROR_MARK; 540518334Speter 540618334Speter if (implicit == 0) 540718334Speter { 540818334Speter /* When we come to an explicit close brace, 540918334Speter pop any inner levels that didn't have explicit braces. */ 541018334Speter while (constructor_stack->implicit) 541118334Speter process_init_element (pop_init_level (1)); 541290075Sobrien 5413169689Skan gcc_assert (!constructor_range_stack); 541418334Speter } 541518334Speter 5416132718Skan /* Now output all pending elements. */ 5417132718Skan constructor_incremental = 1; 5418132718Skan output_pending_init_elements (1); 5419132718Skan 542018334Speter p = constructor_stack; 542118334Speter 542290075Sobrien /* Error for initializing a flexible array member, or a zero-length 542390075Sobrien array member in an inappropriate context. */ 542490075Sobrien if (constructor_type && constructor_fields 542590075Sobrien && TREE_CODE (constructor_type) == ARRAY_TYPE 542690075Sobrien && TYPE_DOMAIN (constructor_type) 5427169689Skan && !TYPE_MAX_VALUE (TYPE_DOMAIN (constructor_type))) 542890075Sobrien { 542990075Sobrien /* Silently discard empty initializations. The parser will 543090075Sobrien already have pedwarned for empty brackets. */ 543190075Sobrien if (integer_zerop (constructor_unfilled_index)) 543290075Sobrien constructor_type = NULL_TREE; 5433169689Skan else 543490075Sobrien { 5435169689Skan gcc_assert (!TYPE_SIZE (constructor_type)); 5436169689Skan 543790075Sobrien if (constructor_depth > 2) 543890075Sobrien error_init ("initialization of flexible array member in a nested context"); 543990075Sobrien else if (pedantic) 544090075Sobrien pedwarn_init ("initialization of a flexible array member"); 544118334Speter 544290075Sobrien /* We have already issued an error message for the existence 544390075Sobrien of a flexible array member not at the end of the structure. 5444169689Skan Discard the initializer so that we do not die later. */ 544590075Sobrien if (TREE_CHAIN (constructor_fields) != NULL_TREE) 544690075Sobrien constructor_type = NULL_TREE; 544790075Sobrien } 544890075Sobrien } 544990075Sobrien 545050397Sobrien /* Warn when some struct elements are implicitly initialized to zero. */ 5451169689Skan if (warn_missing_field_initializers 545250397Sobrien && constructor_type 545350397Sobrien && TREE_CODE (constructor_type) == RECORD_TYPE 545450397Sobrien && constructor_unfilled_fields) 545550397Sobrien { 545690075Sobrien /* Do not warn for flexible array members or zero-length arrays. */ 545790075Sobrien while (constructor_unfilled_fields 5458169689Skan && (!DECL_SIZE (constructor_unfilled_fields) 545990075Sobrien || integer_zerop (DECL_SIZE (constructor_unfilled_fields)))) 546090075Sobrien constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields); 546190075Sobrien 546290075Sobrien /* Do not warn if this level of the initializer uses member 546390075Sobrien designators; it is likely to be deliberate. */ 546490075Sobrien if (constructor_unfilled_fields && !constructor_designated) 546590075Sobrien { 546690075Sobrien push_member_name (constructor_unfilled_fields); 546790075Sobrien warning_init ("missing initializer"); 546890075Sobrien RESTORE_SPELLING_DEPTH (constructor_depth); 546990075Sobrien } 547050397Sobrien } 547150397Sobrien 547218334Speter /* Pad out the end of the structure. */ 5473169689Skan if (p->replacement_value.value) 547490075Sobrien /* If this closes a superfluous brace pair, 547590075Sobrien just pass out the element between them. */ 5476169689Skan ret = p->replacement_value; 547718334Speter else if (constructor_type == 0) 547818334Speter ; 547918334Speter else if (TREE_CODE (constructor_type) != RECORD_TYPE 548018334Speter && TREE_CODE (constructor_type) != UNION_TYPE 548196263Sobrien && TREE_CODE (constructor_type) != ARRAY_TYPE 548296263Sobrien && TREE_CODE (constructor_type) != VECTOR_TYPE) 548318334Speter { 548418334Speter /* A nonincremental scalar initializer--just return 548518334Speter the element, after verifying there is just one. */ 5486169689Skan if (VEC_empty (constructor_elt,constructor_elements)) 548718334Speter { 548890075Sobrien if (!constructor_erroneous) 548990075Sobrien error_init ("empty scalar initializer"); 5490169689Skan ret.value = error_mark_node; 549118334Speter } 5492169689Skan else if (VEC_length (constructor_elt,constructor_elements) != 1) 549318334Speter { 549452284Sobrien error_init ("extra elements in scalar initializer"); 5495169689Skan ret.value = VEC_index (constructor_elt,constructor_elements,0)->value; 549618334Speter } 549718334Speter else 5498169689Skan ret.value = VEC_index (constructor_elt,constructor_elements,0)->value; 549918334Speter } 550090075Sobrien else 550118334Speter { 550218334Speter if (constructor_erroneous) 5503169689Skan ret.value = error_mark_node; 550418334Speter else 550518334Speter { 5506169689Skan ret.value = build_constructor (constructor_type, 5507169689Skan constructor_elements); 550818334Speter if (constructor_constant) 5509169689Skan TREE_CONSTANT (ret.value) = TREE_INVARIANT (ret.value) = 1; 551018334Speter if (constructor_constant && constructor_simple) 5511169689Skan TREE_STATIC (ret.value) = 1; 551218334Speter } 551318334Speter } 551418334Speter 551518334Speter constructor_type = p->type; 551618334Speter constructor_fields = p->fields; 551718334Speter constructor_index = p->index; 551818334Speter constructor_max_index = p->max_index; 551918334Speter constructor_unfilled_index = p->unfilled_index; 552018334Speter constructor_unfilled_fields = p->unfilled_fields; 552118334Speter constructor_bit_index = p->bit_index; 552218334Speter constructor_elements = p->elements; 552318334Speter constructor_constant = p->constant; 552418334Speter constructor_simple = p->simple; 552518334Speter constructor_erroneous = p->erroneous; 552690075Sobrien constructor_incremental = p->incremental; 552790075Sobrien constructor_designated = p->designated; 552818334Speter constructor_pending_elts = p->pending_elts; 552918334Speter constructor_depth = p->depth; 553090075Sobrien if (!p->implicit) 553190075Sobrien constructor_range_stack = p->range_stack; 553218334Speter RESTORE_SPELLING_DEPTH (constructor_depth); 553318334Speter 553418334Speter constructor_stack = p->next; 553518334Speter free (p); 553618334Speter 5537169689Skan if (ret.value == 0 && constructor_stack == 0) 5538169689Skan ret.value = error_mark_node; 5539169689Skan return ret; 554018334Speter} 554118334Speter 554290075Sobrien/* Common handling for both array range and field name designators. 5543117395Skan ARRAY argument is nonzero for array ranges. Returns zero for success. */ 554490075Sobrien 554590075Sobrienstatic int 5546132718Skanset_designator (int array) 554790075Sobrien{ 554890075Sobrien tree subtype; 554990075Sobrien enum tree_code subcode; 555090075Sobrien 555190075Sobrien /* Don't die if an entire brace-pair level is superfluous 555290075Sobrien in the containing level. */ 555390075Sobrien if (constructor_type == 0) 555490075Sobrien return 1; 555590075Sobrien 5556169689Skan /* If there were errors in this designator list already, bail out 5557169689Skan silently. */ 5558169689Skan if (designator_erroneous) 555990075Sobrien return 1; 556090075Sobrien 556190075Sobrien if (!designator_depth) 556290075Sobrien { 5563169689Skan gcc_assert (!constructor_range_stack); 556490075Sobrien 556590075Sobrien /* Designator list starts at the level of closest explicit 556690075Sobrien braces. */ 556790075Sobrien while (constructor_stack->implicit) 556890075Sobrien process_init_element (pop_init_level (1)); 556990075Sobrien constructor_designated = 1; 557090075Sobrien return 0; 557190075Sobrien } 557290075Sobrien 5573169689Skan switch (TREE_CODE (constructor_type)) 557490075Sobrien { 5575169689Skan case RECORD_TYPE: 5576169689Skan case UNION_TYPE: 557790075Sobrien subtype = TREE_TYPE (constructor_fields); 557890075Sobrien if (subtype != error_mark_node) 557990075Sobrien subtype = TYPE_MAIN_VARIANT (subtype); 5580169689Skan break; 5581169689Skan case ARRAY_TYPE: 558290075Sobrien subtype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type)); 5583169689Skan break; 5584169689Skan default: 5585169689Skan gcc_unreachable (); 558690075Sobrien } 558790075Sobrien 558890075Sobrien subcode = TREE_CODE (subtype); 558990075Sobrien if (array && subcode != ARRAY_TYPE) 559090075Sobrien { 559190075Sobrien error_init ("array index in non-array initializer"); 559290075Sobrien return 1; 559390075Sobrien } 559490075Sobrien else if (!array && subcode != RECORD_TYPE && subcode != UNION_TYPE) 559590075Sobrien { 559690075Sobrien error_init ("field name not in record or union initializer"); 559790075Sobrien return 1; 559890075Sobrien } 559990075Sobrien 560090075Sobrien constructor_designated = 1; 560190075Sobrien push_init_level (2); 560290075Sobrien return 0; 560390075Sobrien} 560490075Sobrien 560590075Sobrien/* If there are range designators in designator list, push a new designator 560690075Sobrien to constructor_range_stack. RANGE_END is end of such stack range or 560790075Sobrien NULL_TREE if there is no range designator at this level. */ 560890075Sobrien 560990075Sobrienstatic void 5610132718Skanpush_range_stack (tree range_end) 561190075Sobrien{ 561290075Sobrien struct constructor_range_stack *p; 561390075Sobrien 5614169689Skan p = GGC_NEW (struct constructor_range_stack); 561590075Sobrien p->prev = constructor_range_stack; 561690075Sobrien p->next = 0; 561790075Sobrien p->fields = constructor_fields; 561890075Sobrien p->range_start = constructor_index; 561990075Sobrien p->index = constructor_index; 562090075Sobrien p->stack = constructor_stack; 562190075Sobrien p->range_end = range_end; 562290075Sobrien if (constructor_range_stack) 562390075Sobrien constructor_range_stack->next = p; 562490075Sobrien constructor_range_stack = p; 562590075Sobrien} 562690075Sobrien 562718334Speter/* Within an array initializer, specify the next index to be initialized. 562818334Speter FIRST is that index. If LAST is nonzero, then initialize a range 562918334Speter of indices, running from FIRST through LAST. */ 563018334Speter 563118334Spetervoid 5632132718Skanset_init_index (tree first, tree last) 563318334Speter{ 563490075Sobrien if (set_designator (1)) 563590075Sobrien return; 563690075Sobrien 5637169689Skan designator_erroneous = 1; 563890075Sobrien 5639169689Skan if (!INTEGRAL_TYPE_P (TREE_TYPE (first)) 5640169689Skan || (last && !INTEGRAL_TYPE_P (TREE_TYPE (last)))) 5641169689Skan { 5642169689Skan error_init ("array index in initializer not of integer type"); 5643169689Skan return; 5644169689Skan } 564590075Sobrien 564618334Speter if (TREE_CODE (first) != INTEGER_CST) 564752284Sobrien error_init ("nonconstant array index in initializer"); 564818334Speter else if (last != 0 && TREE_CODE (last) != INTEGER_CST) 564952284Sobrien error_init ("nonconstant array index in initializer"); 565090075Sobrien else if (TREE_CODE (constructor_type) != ARRAY_TYPE) 565152284Sobrien error_init ("array index in non-array initializer"); 5652122180Skan else if (tree_int_cst_sgn (first) == -1) 5653122180Skan error_init ("array index in initializer exceeds array bounds"); 565490075Sobrien else if (constructor_max_index 565590075Sobrien && tree_int_cst_lt (constructor_max_index, first)) 565690075Sobrien error_init ("array index in initializer exceeds array bounds"); 565718334Speter else 565818334Speter { 565990075Sobrien constructor_index = convert (bitsizetype, first); 566018334Speter 566190075Sobrien if (last) 566218334Speter { 566390075Sobrien if (tree_int_cst_equal (first, last)) 566490075Sobrien last = 0; 566590075Sobrien else if (tree_int_cst_lt (last, first)) 566690075Sobrien { 566790075Sobrien error_init ("empty index range in initializer"); 566890075Sobrien last = 0; 566990075Sobrien } 567090075Sobrien else 567190075Sobrien { 567290075Sobrien last = convert (bitsizetype, last); 567390075Sobrien if (constructor_max_index != 0 567490075Sobrien && tree_int_cst_lt (constructor_max_index, last)) 567590075Sobrien { 567690075Sobrien error_init ("array index range in initializer exceeds array bounds"); 567790075Sobrien last = 0; 567890075Sobrien } 567990075Sobrien } 568018334Speter } 568190075Sobrien 568290075Sobrien designator_depth++; 5683169689Skan designator_erroneous = 0; 568490075Sobrien if (constructor_range_stack || last) 568590075Sobrien push_range_stack (last); 568618334Speter } 568718334Speter} 568818334Speter 568918334Speter/* Within a struct initializer, specify the next field to be initialized. */ 569018334Speter 569118334Spetervoid 5692132718Skanset_init_label (tree fieldname) 569318334Speter{ 569418334Speter tree tail; 569518334Speter 569690075Sobrien if (set_designator (0)) 569718334Speter return; 569818334Speter 5699169689Skan designator_erroneous = 1; 570090075Sobrien 570190075Sobrien if (TREE_CODE (constructor_type) != RECORD_TYPE 570290075Sobrien && TREE_CODE (constructor_type) != UNION_TYPE) 570390075Sobrien { 570490075Sobrien error_init ("field name not in record or union initializer"); 570590075Sobrien return; 570690075Sobrien } 5707132718Skan 570818334Speter for (tail = TYPE_FIELDS (constructor_type); tail; 570918334Speter tail = TREE_CHAIN (tail)) 571018334Speter { 571118334Speter if (DECL_NAME (tail) == fieldname) 571218334Speter break; 571318334Speter } 571418334Speter 571518334Speter if (tail == 0) 5716169689Skan error ("unknown field %qE specified in initializer", fieldname); 571718334Speter else 571818334Speter { 571918334Speter constructor_fields = tail; 572090075Sobrien designator_depth++; 5721169689Skan designator_erroneous = 0; 572290075Sobrien if (constructor_range_stack) 572390075Sobrien push_range_stack (NULL_TREE); 572418334Speter } 572518334Speter} 572618334Speter 572750397Sobrien/* Add a new initializer to the tree of pending initializers. PURPOSE 5728132718Skan identifies the initializer, either array index or field in a structure. 572950397Sobrien VALUE is the value of that index or field. */ 573050397Sobrien 573150397Sobrienstatic void 5732132718Skanadd_pending_init (tree purpose, tree value) 573350397Sobrien{ 573450397Sobrien struct init_node *p, **q, *r; 573550397Sobrien 573650397Sobrien q = &constructor_pending_elts; 573750397Sobrien p = 0; 573850397Sobrien 573950397Sobrien if (TREE_CODE (constructor_type) == ARRAY_TYPE) 574050397Sobrien { 574150397Sobrien while (*q != 0) 574250397Sobrien { 574350397Sobrien p = *q; 574450397Sobrien if (tree_int_cst_lt (purpose, p->purpose)) 574550397Sobrien q = &p->left; 574690075Sobrien else if (tree_int_cst_lt (p->purpose, purpose)) 574750397Sobrien q = &p->right; 574850397Sobrien else 574990075Sobrien { 575090075Sobrien if (TREE_SIDE_EFFECTS (p->value)) 575190075Sobrien warning_init ("initialized field with side-effects overwritten"); 5752169689Skan else if (warn_override_init) 5753169689Skan warning_init ("initialized field overwritten"); 575490075Sobrien p->value = value; 575590075Sobrien return; 575690075Sobrien } 575750397Sobrien } 575850397Sobrien } 575950397Sobrien else 576050397Sobrien { 576190075Sobrien tree bitpos; 576290075Sobrien 576390075Sobrien bitpos = bit_position (purpose); 576450397Sobrien while (*q != NULL) 576550397Sobrien { 576650397Sobrien p = *q; 576790075Sobrien if (tree_int_cst_lt (bitpos, bit_position (p->purpose))) 576850397Sobrien q = &p->left; 576960967Sobrien else if (p->purpose != purpose) 577050397Sobrien q = &p->right; 577150397Sobrien else 577290075Sobrien { 577390075Sobrien if (TREE_SIDE_EFFECTS (p->value)) 577490075Sobrien warning_init ("initialized field with side-effects overwritten"); 5775169689Skan else if (warn_override_init) 5776169689Skan warning_init ("initialized field overwritten"); 577790075Sobrien p->value = value; 577890075Sobrien return; 577990075Sobrien } 578050397Sobrien } 578150397Sobrien } 578250397Sobrien 5783169689Skan r = GGC_NEW (struct init_node); 578450397Sobrien r->purpose = purpose; 578550397Sobrien r->value = value; 578650397Sobrien 578750397Sobrien *q = r; 578850397Sobrien r->parent = p; 578950397Sobrien r->left = 0; 579050397Sobrien r->right = 0; 579150397Sobrien r->balance = 0; 579250397Sobrien 579350397Sobrien while (p) 579450397Sobrien { 579550397Sobrien struct init_node *s; 579650397Sobrien 579750397Sobrien if (r == p->left) 579850397Sobrien { 579950397Sobrien if (p->balance == 0) 580050397Sobrien p->balance = -1; 580150397Sobrien else if (p->balance < 0) 580250397Sobrien { 580350397Sobrien if (r->balance < 0) 580450397Sobrien { 580590075Sobrien /* L rotation. */ 580650397Sobrien p->left = r->right; 580750397Sobrien if (p->left) 580850397Sobrien p->left->parent = p; 580950397Sobrien r->right = p; 581050397Sobrien 581150397Sobrien p->balance = 0; 581250397Sobrien r->balance = 0; 581350397Sobrien 581450397Sobrien s = p->parent; 581550397Sobrien p->parent = r; 581650397Sobrien r->parent = s; 581750397Sobrien if (s) 581850397Sobrien { 581950397Sobrien if (s->left == p) 582050397Sobrien s->left = r; 582150397Sobrien else 582250397Sobrien s->right = r; 582350397Sobrien } 582450397Sobrien else 582550397Sobrien constructor_pending_elts = r; 582650397Sobrien } 582750397Sobrien else 582850397Sobrien { 582990075Sobrien /* LR rotation. */ 583050397Sobrien struct init_node *t = r->right; 583150397Sobrien 583250397Sobrien r->right = t->left; 583350397Sobrien if (r->right) 583450397Sobrien r->right->parent = r; 583550397Sobrien t->left = r; 583650397Sobrien 583750397Sobrien p->left = t->right; 583850397Sobrien if (p->left) 583950397Sobrien p->left->parent = p; 584050397Sobrien t->right = p; 584150397Sobrien 584250397Sobrien p->balance = t->balance < 0; 584350397Sobrien r->balance = -(t->balance > 0); 584450397Sobrien t->balance = 0; 584550397Sobrien 584650397Sobrien s = p->parent; 584750397Sobrien p->parent = t; 584850397Sobrien r->parent = t; 584950397Sobrien t->parent = s; 585050397Sobrien if (s) 585150397Sobrien { 585250397Sobrien if (s->left == p) 585350397Sobrien s->left = t; 585450397Sobrien else 585550397Sobrien s->right = t; 585650397Sobrien } 585750397Sobrien else 585850397Sobrien constructor_pending_elts = t; 585950397Sobrien } 586050397Sobrien break; 586150397Sobrien } 586250397Sobrien else 586350397Sobrien { 586450397Sobrien /* p->balance == +1; growth of left side balances the node. */ 586550397Sobrien p->balance = 0; 586650397Sobrien break; 586750397Sobrien } 586850397Sobrien } 586950397Sobrien else /* r == p->right */ 587050397Sobrien { 587150397Sobrien if (p->balance == 0) 587250397Sobrien /* Growth propagation from right side. */ 587350397Sobrien p->balance++; 587450397Sobrien else if (p->balance > 0) 587550397Sobrien { 587650397Sobrien if (r->balance > 0) 587750397Sobrien { 587890075Sobrien /* R rotation. */ 587950397Sobrien p->right = r->left; 588050397Sobrien if (p->right) 588150397Sobrien p->right->parent = p; 588250397Sobrien r->left = p; 588350397Sobrien 588450397Sobrien p->balance = 0; 588550397Sobrien r->balance = 0; 588650397Sobrien 588750397Sobrien s = p->parent; 588850397Sobrien p->parent = r; 588950397Sobrien r->parent = s; 589050397Sobrien if (s) 589150397Sobrien { 589250397Sobrien if (s->left == p) 589350397Sobrien s->left = r; 589450397Sobrien else 589550397Sobrien s->right = r; 589650397Sobrien } 589750397Sobrien else 589850397Sobrien constructor_pending_elts = r; 589950397Sobrien } 590050397Sobrien else /* r->balance == -1 */ 590150397Sobrien { 590250397Sobrien /* RL rotation */ 590350397Sobrien struct init_node *t = r->left; 590450397Sobrien 590550397Sobrien r->left = t->right; 590650397Sobrien if (r->left) 590750397Sobrien r->left->parent = r; 590850397Sobrien t->right = r; 590950397Sobrien 591050397Sobrien p->right = t->left; 591150397Sobrien if (p->right) 591250397Sobrien p->right->parent = p; 591350397Sobrien t->left = p; 591450397Sobrien 591550397Sobrien r->balance = (t->balance < 0); 591650397Sobrien p->balance = -(t->balance > 0); 591750397Sobrien t->balance = 0; 591850397Sobrien 591950397Sobrien s = p->parent; 592050397Sobrien p->parent = t; 592150397Sobrien r->parent = t; 592250397Sobrien t->parent = s; 592350397Sobrien if (s) 592450397Sobrien { 592550397Sobrien if (s->left == p) 592650397Sobrien s->left = t; 592750397Sobrien else 592850397Sobrien s->right = t; 592950397Sobrien } 593050397Sobrien else 593150397Sobrien constructor_pending_elts = t; 593250397Sobrien } 593350397Sobrien break; 593450397Sobrien } 593550397Sobrien else 593650397Sobrien { 593790075Sobrien /* p->balance == -1; growth of right side balances the node. */ 593850397Sobrien p->balance = 0; 593950397Sobrien break; 594050397Sobrien } 594150397Sobrien } 594250397Sobrien 594350397Sobrien r = p; 594450397Sobrien p = p->parent; 594550397Sobrien } 594650397Sobrien} 594750397Sobrien 594890075Sobrien/* Build AVL tree from a sorted chain. */ 594950397Sobrien 595090075Sobrienstatic void 5951132718Skanset_nonincremental_init (void) 595290075Sobrien{ 5953169689Skan unsigned HOST_WIDE_INT ix; 5954169689Skan tree index, value; 595590075Sobrien 595690075Sobrien if (TREE_CODE (constructor_type) != RECORD_TYPE 595790075Sobrien && TREE_CODE (constructor_type) != ARRAY_TYPE) 595890075Sobrien return; 595990075Sobrien 5960169689Skan FOR_EACH_CONSTRUCTOR_ELT (constructor_elements, ix, index, value) 5961169689Skan add_pending_init (index, value); 596290075Sobrien constructor_elements = 0; 596390075Sobrien if (TREE_CODE (constructor_type) == RECORD_TYPE) 596490075Sobrien { 596590075Sobrien constructor_unfilled_fields = TYPE_FIELDS (constructor_type); 596690075Sobrien /* Skip any nameless bit fields at the beginning. */ 596790075Sobrien while (constructor_unfilled_fields != 0 596890075Sobrien && DECL_C_BIT_FIELD (constructor_unfilled_fields) 596990075Sobrien && DECL_NAME (constructor_unfilled_fields) == 0) 597090075Sobrien constructor_unfilled_fields = TREE_CHAIN (constructor_unfilled_fields); 5971132718Skan 597290075Sobrien } 597390075Sobrien else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 597490075Sobrien { 597590075Sobrien if (TYPE_DOMAIN (constructor_type)) 597690075Sobrien constructor_unfilled_index 597790075Sobrien = convert (bitsizetype, 597890075Sobrien TYPE_MIN_VALUE (TYPE_DOMAIN (constructor_type))); 597990075Sobrien else 598090075Sobrien constructor_unfilled_index = bitsize_zero_node; 598190075Sobrien } 598290075Sobrien constructor_incremental = 0; 598390075Sobrien} 598490075Sobrien 598590075Sobrien/* Build AVL tree from a string constant. */ 598690075Sobrien 598790075Sobrienstatic void 5988132718Skanset_nonincremental_init_from_string (tree str) 598990075Sobrien{ 599090075Sobrien tree value, purpose, type; 599190075Sobrien HOST_WIDE_INT val[2]; 599290075Sobrien const char *p, *end; 599390075Sobrien int byte, wchar_bytes, charwidth, bitpos; 599490075Sobrien 5995169689Skan gcc_assert (TREE_CODE (constructor_type) == ARRAY_TYPE); 599690075Sobrien 599790075Sobrien if (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str))) 599890075Sobrien == TYPE_PRECISION (char_type_node)) 599990075Sobrien wchar_bytes = 1; 600090075Sobrien else 6001169689Skan { 6002169689Skan gcc_assert (TYPE_PRECISION (TREE_TYPE (TREE_TYPE (str))) 6003169689Skan == TYPE_PRECISION (wchar_type_node)); 6004169689Skan wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT; 6005169689Skan } 600690075Sobrien charwidth = TYPE_PRECISION (char_type_node); 600790075Sobrien type = TREE_TYPE (constructor_type); 600890075Sobrien p = TREE_STRING_POINTER (str); 600990075Sobrien end = p + TREE_STRING_LENGTH (str); 601090075Sobrien 601190075Sobrien for (purpose = bitsize_zero_node; 601290075Sobrien p < end && !tree_int_cst_lt (constructor_max_index, purpose); 601390075Sobrien purpose = size_binop (PLUS_EXPR, purpose, bitsize_one_node)) 601490075Sobrien { 601590075Sobrien if (wchar_bytes == 1) 601690075Sobrien { 601790075Sobrien val[1] = (unsigned char) *p++; 601890075Sobrien val[0] = 0; 601990075Sobrien } 602090075Sobrien else 602190075Sobrien { 602290075Sobrien val[0] = 0; 602390075Sobrien val[1] = 0; 602490075Sobrien for (byte = 0; byte < wchar_bytes; byte++) 602590075Sobrien { 602690075Sobrien if (BYTES_BIG_ENDIAN) 602790075Sobrien bitpos = (wchar_bytes - byte - 1) * charwidth; 602890075Sobrien else 602990075Sobrien bitpos = byte * charwidth; 603090075Sobrien val[bitpos < HOST_BITS_PER_WIDE_INT] 603190075Sobrien |= ((unsigned HOST_WIDE_INT) ((unsigned char) *p++)) 603290075Sobrien << (bitpos % HOST_BITS_PER_WIDE_INT); 603390075Sobrien } 603490075Sobrien } 603590075Sobrien 6036169689Skan if (!TYPE_UNSIGNED (type)) 603790075Sobrien { 603890075Sobrien bitpos = ((wchar_bytes - 1) * charwidth) + HOST_BITS_PER_CHAR; 603990075Sobrien if (bitpos < HOST_BITS_PER_WIDE_INT) 604090075Sobrien { 604190075Sobrien if (val[1] & (((HOST_WIDE_INT) 1) << (bitpos - 1))) 604290075Sobrien { 604390075Sobrien val[1] |= ((HOST_WIDE_INT) -1) << bitpos; 604490075Sobrien val[0] = -1; 604590075Sobrien } 604690075Sobrien } 604790075Sobrien else if (bitpos == HOST_BITS_PER_WIDE_INT) 604890075Sobrien { 604990075Sobrien if (val[1] < 0) 6050169689Skan val[0] = -1; 605190075Sobrien } 605290075Sobrien else if (val[0] & (((HOST_WIDE_INT) 1) 605390075Sobrien << (bitpos - 1 - HOST_BITS_PER_WIDE_INT))) 605490075Sobrien val[0] |= ((HOST_WIDE_INT) -1) 605590075Sobrien << (bitpos - HOST_BITS_PER_WIDE_INT); 605690075Sobrien } 605790075Sobrien 6058169689Skan value = build_int_cst_wide (type, val[1], val[0]); 605990075Sobrien add_pending_init (purpose, value); 606090075Sobrien } 606190075Sobrien 606290075Sobrien constructor_incremental = 0; 606390075Sobrien} 606490075Sobrien 606590075Sobrien/* Return value of FIELD in pending initializer or zero if the field was 606690075Sobrien not initialized yet. */ 606790075Sobrien 606890075Sobrienstatic tree 6069132718Skanfind_init_member (tree field) 607050397Sobrien{ 607150397Sobrien struct init_node *p; 607250397Sobrien 607350397Sobrien if (TREE_CODE (constructor_type) == ARRAY_TYPE) 607450397Sobrien { 607590075Sobrien if (constructor_incremental 607690075Sobrien && tree_int_cst_lt (field, constructor_unfilled_index)) 607790075Sobrien set_nonincremental_init (); 607890075Sobrien 607990075Sobrien p = constructor_pending_elts; 608050397Sobrien while (p) 608150397Sobrien { 608290075Sobrien if (tree_int_cst_lt (field, p->purpose)) 608350397Sobrien p = p->left; 608490075Sobrien else if (tree_int_cst_lt (p->purpose, field)) 608590075Sobrien p = p->right; 608650397Sobrien else 608790075Sobrien return p->value; 608850397Sobrien } 608950397Sobrien } 609090075Sobrien else if (TREE_CODE (constructor_type) == RECORD_TYPE) 609150397Sobrien { 609290075Sobrien tree bitpos = bit_position (field); 609390075Sobrien 609490075Sobrien if (constructor_incremental 609590075Sobrien && (!constructor_unfilled_fields 609690075Sobrien || tree_int_cst_lt (bitpos, 609790075Sobrien bit_position (constructor_unfilled_fields)))) 609890075Sobrien set_nonincremental_init (); 609990075Sobrien 610090075Sobrien p = constructor_pending_elts; 610150397Sobrien while (p) 610250397Sobrien { 610350397Sobrien if (field == p->purpose) 610490075Sobrien return p->value; 610590075Sobrien else if (tree_int_cst_lt (bitpos, bit_position (p->purpose))) 610650397Sobrien p = p->left; 610750397Sobrien else 610850397Sobrien p = p->right; 610950397Sobrien } 611050397Sobrien } 611190075Sobrien else if (TREE_CODE (constructor_type) == UNION_TYPE) 611290075Sobrien { 6113169689Skan if (!VEC_empty (constructor_elt, constructor_elements) 6114169689Skan && (VEC_last (constructor_elt, constructor_elements)->index 6115169689Skan == field)) 6116169689Skan return VEC_last (constructor_elt, constructor_elements)->value; 611790075Sobrien } 611850397Sobrien return 0; 611950397Sobrien} 612050397Sobrien 612118334Speter/* "Output" the next constructor element. 612218334Speter At top level, really output it to assembler code now. 612318334Speter Otherwise, collect it in a list from which we will make a CONSTRUCTOR. 612418334Speter TYPE is the data type that the containing data type wants here. 612518334Speter FIELD is the field (a FIELD_DECL) or the index that this element fills. 6126169689Skan If VALUE is a string constant, STRICT_STRING is true if it is 6127169689Skan unparenthesized or we should not warn here for it being parenthesized. 6128169689Skan For other types of VALUE, STRICT_STRING is not used. 612918334Speter 613018334Speter PENDING if non-nil means output pending elements that belong 613118334Speter right after this element. (PENDING is normally 1; 613218334Speter it is 0 while outputting pending elements, to avoid recursion.) */ 613318334Speter 613418334Speterstatic void 6135169689Skanoutput_init_element (tree value, bool strict_string, tree type, tree field, 6136169689Skan int pending) 613718334Speter{ 6138169689Skan constructor_elt *celt; 6139169689Skan 6140169689Skan if (type == error_mark_node || value == error_mark_node) 6141132718Skan { 6142132718Skan constructor_erroneous = 1; 6143132718Skan return; 6144132718Skan } 6145169689Skan if (TREE_CODE (TREE_TYPE (value)) == ARRAY_TYPE 6146169689Skan && (TREE_CODE (value) == STRING_CST 6147169689Skan || TREE_CODE (value) == COMPOUND_LITERAL_EXPR) 6148169689Skan && !(TREE_CODE (value) == STRING_CST 6149169689Skan && TREE_CODE (type) == ARRAY_TYPE 6150169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (type))) 6151169689Skan && !comptypes (TYPE_MAIN_VARIANT (TREE_TYPE (value)), 6152169689Skan TYPE_MAIN_VARIANT (type))) 6153169689Skan value = array_to_pointer_conversion (value); 615418334Speter 615590075Sobrien if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR 615690075Sobrien && require_constant_value && !flag_isoc99 && pending) 615790075Sobrien { 615890075Sobrien /* As an extension, allow initializing objects with static storage 615990075Sobrien duration with compound literals (which are then treated just as 616090075Sobrien the brace enclosed list they contain). */ 616190075Sobrien tree decl = COMPOUND_LITERAL_EXPR_DECL (value); 616290075Sobrien value = DECL_INITIAL (decl); 616390075Sobrien } 616490075Sobrien 616518334Speter if (value == error_mark_node) 616618334Speter constructor_erroneous = 1; 616718334Speter else if (!TREE_CONSTANT (value)) 616818334Speter constructor_constant = 0; 6169169689Skan else if (!initializer_constant_valid_p (value, TREE_TYPE (value)) 617018334Speter || ((TREE_CODE (constructor_type) == RECORD_TYPE 617118334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 617250397Sobrien && DECL_C_BIT_FIELD (field) 617350397Sobrien && TREE_CODE (value) != INTEGER_CST)) 617418334Speter constructor_simple = 0; 617518334Speter 6176169689Skan if (!initializer_constant_valid_p (value, TREE_TYPE (value))) 617718334Speter { 6178169689Skan if (require_constant_value) 6179169689Skan { 6180169689Skan error_init ("initializer element is not constant"); 6181169689Skan value = error_mark_node; 6182169689Skan } 6183169689Skan else if (require_constant_elements) 6184169689Skan pedwarn ("initializer element is not computable at load time"); 618518334Speter } 618618334Speter 618790075Sobrien /* If this field is empty (and not at the end of structure), 618890075Sobrien don't do anything other than checking the initializer. */ 618990075Sobrien if (field 619090075Sobrien && (TREE_TYPE (field) == error_mark_node 619190075Sobrien || (COMPLETE_TYPE_P (TREE_TYPE (field)) 619290075Sobrien && integer_zerop (TYPE_SIZE (TREE_TYPE (field))) 619390075Sobrien && (TREE_CODE (constructor_type) == ARRAY_TYPE 619490075Sobrien || TREE_CHAIN (field))))) 619590075Sobrien return; 619690075Sobrien 6197169689Skan value = digest_init (type, value, strict_string, require_constant_value); 619890075Sobrien if (value == error_mark_node) 619918334Speter { 620090075Sobrien constructor_erroneous = 1; 620190075Sobrien return; 620218334Speter } 620318334Speter 620418334Speter /* If this element doesn't come next in sequence, 620518334Speter put it on constructor_pending_elts. */ 620618334Speter if (TREE_CODE (constructor_type) == ARRAY_TYPE 620790075Sobrien && (!constructor_incremental 620890075Sobrien || !tree_int_cst_equal (field, constructor_unfilled_index))) 620918334Speter { 621090075Sobrien if (constructor_incremental 621190075Sobrien && tree_int_cst_lt (field, constructor_unfilled_index)) 621290075Sobrien set_nonincremental_init (); 621390075Sobrien 621490075Sobrien add_pending_init (field, value); 621590075Sobrien return; 621618334Speter } 621718334Speter else if (TREE_CODE (constructor_type) == RECORD_TYPE 621890075Sobrien && (!constructor_incremental 621990075Sobrien || field != constructor_unfilled_fields)) 622018334Speter { 622118334Speter /* We do this for records but not for unions. In a union, 622218334Speter no matter which field is specified, it can be initialized 622318334Speter right away since it starts at the beginning of the union. */ 622490075Sobrien if (constructor_incremental) 622518334Speter { 622690075Sobrien if (!constructor_unfilled_fields) 622790075Sobrien set_nonincremental_init (); 622818334Speter else 622918334Speter { 623090075Sobrien tree bitpos, unfillpos; 623118334Speter 623290075Sobrien bitpos = bit_position (field); 623390075Sobrien unfillpos = bit_position (constructor_unfilled_fields); 623418334Speter 623590075Sobrien if (tree_int_cst_lt (bitpos, unfillpos)) 623690075Sobrien set_nonincremental_init (); 623718334Speter } 623818334Speter } 623918334Speter 624090075Sobrien add_pending_init (field, value); 624190075Sobrien return; 624290075Sobrien } 624390075Sobrien else if (TREE_CODE (constructor_type) == UNION_TYPE 6244169689Skan && !VEC_empty (constructor_elt, constructor_elements)) 624590075Sobrien { 6246169689Skan if (TREE_SIDE_EFFECTS (VEC_last (constructor_elt, 6247169689Skan constructor_elements)->value)) 624890075Sobrien warning_init ("initialized field with side-effects overwritten"); 6249169689Skan else if (warn_override_init) 6250169689Skan warning_init ("initialized field overwritten"); 625118334Speter 625290075Sobrien /* We can have just one union field set. */ 625390075Sobrien constructor_elements = 0; 625418334Speter } 625590075Sobrien 625690075Sobrien /* Otherwise, output this element either to 625790075Sobrien constructor_elements or to the assembler file. */ 625890075Sobrien 6259169689Skan celt = VEC_safe_push (constructor_elt, gc, constructor_elements, NULL); 6260169689Skan celt->index = field; 6261169689Skan celt->value = value; 626290075Sobrien 626390075Sobrien /* Advance the variable that indicates sequential elements output. */ 626490075Sobrien if (TREE_CODE (constructor_type) == ARRAY_TYPE) 626590075Sobrien constructor_unfilled_index 626690075Sobrien = size_binop (PLUS_EXPR, constructor_unfilled_index, 626790075Sobrien bitsize_one_node); 626890075Sobrien else if (TREE_CODE (constructor_type) == RECORD_TYPE) 626990075Sobrien { 627090075Sobrien constructor_unfilled_fields 627190075Sobrien = TREE_CHAIN (constructor_unfilled_fields); 627290075Sobrien 627390075Sobrien /* Skip any nameless bit fields. */ 627490075Sobrien while (constructor_unfilled_fields != 0 627590075Sobrien && DECL_C_BIT_FIELD (constructor_unfilled_fields) 627690075Sobrien && DECL_NAME (constructor_unfilled_fields) == 0) 627790075Sobrien constructor_unfilled_fields = 627890075Sobrien TREE_CHAIN (constructor_unfilled_fields); 627990075Sobrien } 628090075Sobrien else if (TREE_CODE (constructor_type) == UNION_TYPE) 628190075Sobrien constructor_unfilled_fields = 0; 628290075Sobrien 628390075Sobrien /* Now output any pending elements which have become next. */ 628490075Sobrien if (pending) 628590075Sobrien output_pending_init_elements (0); 628618334Speter} 628718334Speter 628818334Speter/* Output any pending elements which have become next. 628918334Speter As we output elements, constructor_unfilled_{fields,index} 629018334Speter advances, which may cause other elements to become next; 629118334Speter if so, they too are output. 629218334Speter 629318334Speter If ALL is 0, we return when there are 629418334Speter no more pending elements to output now. 629518334Speter 629618334Speter If ALL is 1, we output space as necessary so that 629718334Speter we can output all the pending elements. */ 629818334Speter 629918334Speterstatic void 6300132718Skanoutput_pending_init_elements (int all) 630118334Speter{ 630250397Sobrien struct init_node *elt = constructor_pending_elts; 630318334Speter tree next; 630418334Speter 630518334Speter retry: 630618334Speter 6307132718Skan /* Look through the whole pending tree. 630818334Speter If we find an element that should be output now, 630918334Speter output it. Otherwise, set NEXT to the element 631018334Speter that comes first among those still pending. */ 6311132718Skan 631218334Speter next = 0; 631350397Sobrien while (elt) 631418334Speter { 631518334Speter if (TREE_CODE (constructor_type) == ARRAY_TYPE) 631618334Speter { 631750397Sobrien if (tree_int_cst_equal (elt->purpose, 631818334Speter constructor_unfilled_index)) 6319169689Skan output_init_element (elt->value, true, 632050397Sobrien TREE_TYPE (constructor_type), 632150397Sobrien constructor_unfilled_index, 0); 632250397Sobrien else if (tree_int_cst_lt (constructor_unfilled_index, 632350397Sobrien elt->purpose)) 632418334Speter { 632550397Sobrien /* Advance to the next smaller node. */ 632650397Sobrien if (elt->left) 632750397Sobrien elt = elt->left; 632850397Sobrien else 632950397Sobrien { 633050397Sobrien /* We have reached the smallest node bigger than the 633150397Sobrien current unfilled index. Fill the space first. */ 633250397Sobrien next = elt->purpose; 633350397Sobrien break; 633450397Sobrien } 633518334Speter } 633650397Sobrien else 633750397Sobrien { 633850397Sobrien /* Advance to the next bigger node. */ 633950397Sobrien if (elt->right) 634050397Sobrien elt = elt->right; 634150397Sobrien else 634250397Sobrien { 634350397Sobrien /* We have reached the biggest node in a subtree. Find 634450397Sobrien the parent of it, which is the next bigger node. */ 634550397Sobrien while (elt->parent && elt->parent->right == elt) 634650397Sobrien elt = elt->parent; 634750397Sobrien elt = elt->parent; 634850397Sobrien if (elt && tree_int_cst_lt (constructor_unfilled_index, 634950397Sobrien elt->purpose)) 635050397Sobrien { 635150397Sobrien next = elt->purpose; 635250397Sobrien break; 635350397Sobrien } 635450397Sobrien } 635550397Sobrien } 635618334Speter } 635718334Speter else if (TREE_CODE (constructor_type) == RECORD_TYPE 635818334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 635918334Speter { 636090075Sobrien tree ctor_unfilled_bitpos, elt_bitpos; 636190075Sobrien 636250397Sobrien /* If the current record is complete we are done. */ 636350397Sobrien if (constructor_unfilled_fields == 0) 636450397Sobrien break; 636590075Sobrien 636690075Sobrien ctor_unfilled_bitpos = bit_position (constructor_unfilled_fields); 636790075Sobrien elt_bitpos = bit_position (elt->purpose); 636890075Sobrien /* We can't compare fields here because there might be empty 636990075Sobrien fields in between. */ 637090075Sobrien if (tree_int_cst_equal (elt_bitpos, ctor_unfilled_bitpos)) 637118334Speter { 637290075Sobrien constructor_unfilled_fields = elt->purpose; 6373169689Skan output_init_element (elt->value, true, TREE_TYPE (elt->purpose), 637490075Sobrien elt->purpose, 0); 637518334Speter } 637690075Sobrien else if (tree_int_cst_lt (ctor_unfilled_bitpos, elt_bitpos)) 637750397Sobrien { 637850397Sobrien /* Advance to the next smaller node. */ 637950397Sobrien if (elt->left) 638050397Sobrien elt = elt->left; 638150397Sobrien else 638250397Sobrien { 638350397Sobrien /* We have reached the smallest node bigger than the 638450397Sobrien current unfilled field. Fill the space first. */ 638550397Sobrien next = elt->purpose; 638650397Sobrien break; 638750397Sobrien } 638850397Sobrien } 638950397Sobrien else 639050397Sobrien { 639150397Sobrien /* Advance to the next bigger node. */ 639250397Sobrien if (elt->right) 639350397Sobrien elt = elt->right; 639450397Sobrien else 639550397Sobrien { 639650397Sobrien /* We have reached the biggest node in a subtree. Find 639750397Sobrien the parent of it, which is the next bigger node. */ 639850397Sobrien while (elt->parent && elt->parent->right == elt) 639950397Sobrien elt = elt->parent; 640050397Sobrien elt = elt->parent; 640150397Sobrien if (elt 640290075Sobrien && (tree_int_cst_lt (ctor_unfilled_bitpos, 640390075Sobrien bit_position (elt->purpose)))) 640450397Sobrien { 640550397Sobrien next = elt->purpose; 640650397Sobrien break; 640750397Sobrien } 640850397Sobrien } 640950397Sobrien } 641018334Speter } 641118334Speter } 641218334Speter 641318334Speter /* Ordinarily return, but not if we want to output all 641418334Speter and there are elements left. */ 6415169689Skan if (!(all && next != 0)) 641618334Speter return; 641718334Speter 641890075Sobrien /* If it's not incremental, just skip over the gap, so that after 641990075Sobrien jumping to retry we will output the next successive element. */ 642090075Sobrien if (TREE_CODE (constructor_type) == RECORD_TYPE 642190075Sobrien || TREE_CODE (constructor_type) == UNION_TYPE) 642290075Sobrien constructor_unfilled_fields = next; 642390075Sobrien else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 642490075Sobrien constructor_unfilled_index = next; 642518334Speter 642650397Sobrien /* ELT now points to the node in the pending tree with the next 642750397Sobrien initializer to output. */ 642818334Speter goto retry; 642918334Speter} 643018334Speter 643118334Speter/* Add one non-braced element to the current constructor level. 643218334Speter This adjusts the current position within the constructor's type. 643318334Speter This may also start or terminate implicit levels 643418334Speter to handle a partly-braced initializer. 643518334Speter 643618334Speter Once this has found the correct level for the new element, 643790075Sobrien it calls output_init_element. */ 643818334Speter 643918334Spetervoid 6440169689Skanprocess_init_element (struct c_expr value) 644118334Speter{ 6442169689Skan tree orig_value = value.value; 6443169689Skan int string_flag = orig_value != 0 && TREE_CODE (orig_value) == STRING_CST; 6444169689Skan bool strict_string = value.original_code == STRING_CST; 644518334Speter 644690075Sobrien designator_depth = 0; 6447169689Skan designator_erroneous = 0; 644890075Sobrien 644918334Speter /* Handle superfluous braces around string cst as in 645018334Speter char x[] = {"foo"}; */ 645118334Speter if (string_flag 645218334Speter && constructor_type 645318334Speter && TREE_CODE (constructor_type) == ARRAY_TYPE 6454169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (constructor_type)) 645518334Speter && integer_zerop (constructor_unfilled_index)) 645618334Speter { 6457169689Skan if (constructor_stack->replacement_value.value) 6458169689Skan error_init ("excess elements in char array initializer"); 645918334Speter constructor_stack->replacement_value = value; 646018334Speter return; 646118334Speter } 646218334Speter 6463169689Skan if (constructor_stack->replacement_value.value != 0) 646418334Speter { 646552284Sobrien error_init ("excess elements in struct initializer"); 646618334Speter return; 646718334Speter } 646818334Speter 646918334Speter /* Ignore elements of a brace group if it is entirely superfluous 647018334Speter and has already been diagnosed. */ 647118334Speter if (constructor_type == 0) 647218334Speter return; 647318334Speter 647418334Speter /* If we've exhausted any levels that didn't have braces, 647518334Speter pop them now. */ 647618334Speter while (constructor_stack->implicit) 647718334Speter { 647818334Speter if ((TREE_CODE (constructor_type) == RECORD_TYPE 647918334Speter || TREE_CODE (constructor_type) == UNION_TYPE) 648018334Speter && constructor_fields == 0) 648118334Speter process_init_element (pop_init_level (1)); 648218334Speter else if (TREE_CODE (constructor_type) == ARRAY_TYPE 648350397Sobrien && (constructor_max_index == 0 648450397Sobrien || tree_int_cst_lt (constructor_max_index, 648550397Sobrien constructor_index))) 648618334Speter process_init_element (pop_init_level (1)); 648718334Speter else 648818334Speter break; 648918334Speter } 649018334Speter 649190075Sobrien /* In the case of [LO ... HI] = VALUE, only evaluate VALUE once. */ 649290075Sobrien if (constructor_range_stack) 649390075Sobrien { 649490075Sobrien /* If value is a compound literal and we'll be just using its 649590075Sobrien content, don't put it into a SAVE_EXPR. */ 6496169689Skan if (TREE_CODE (value.value) != COMPOUND_LITERAL_EXPR 649790075Sobrien || !require_constant_value 649890075Sobrien || flag_isoc99) 6499169689Skan value.value = save_expr (value.value); 650090075Sobrien } 650190075Sobrien 650218334Speter while (1) 650318334Speter { 650418334Speter if (TREE_CODE (constructor_type) == RECORD_TYPE) 650518334Speter { 650618334Speter tree fieldtype; 650718334Speter enum tree_code fieldcode; 650818334Speter 650918334Speter if (constructor_fields == 0) 651018334Speter { 651152284Sobrien pedwarn_init ("excess elements in struct initializer"); 651218334Speter break; 651318334Speter } 651418334Speter 651518334Speter fieldtype = TREE_TYPE (constructor_fields); 651618334Speter if (fieldtype != error_mark_node) 651718334Speter fieldtype = TYPE_MAIN_VARIANT (fieldtype); 651818334Speter fieldcode = TREE_CODE (fieldtype); 651918334Speter 652096263Sobrien /* Error for non-static initialization of a flexible array member. */ 652196263Sobrien if (fieldcode == ARRAY_TYPE 652296263Sobrien && !require_constant_value 652396263Sobrien && TYPE_SIZE (fieldtype) == NULL_TREE 652496263Sobrien && TREE_CHAIN (constructor_fields) == NULL_TREE) 652596263Sobrien { 652696263Sobrien error_init ("non-static initialization of a flexible array member"); 652796263Sobrien break; 652896263Sobrien } 652996263Sobrien 653018334Speter /* Accept a string constant to initialize a subarray. */ 6531169689Skan if (value.value != 0 653218334Speter && fieldcode == ARRAY_TYPE 6533169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype)) 653418334Speter && string_flag) 6535169689Skan value.value = orig_value; 653618334Speter /* Otherwise, if we have come to a subaggregate, 653718334Speter and we don't have an element of its type, push into it. */ 6538169689Skan else if (value.value != 0 6539169689Skan && value.value != error_mark_node 6540169689Skan && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype 654118334Speter && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE 654218334Speter || fieldcode == UNION_TYPE)) 654318334Speter { 654418334Speter push_init_level (1); 654518334Speter continue; 654618334Speter } 654718334Speter 6548169689Skan if (value.value) 654918334Speter { 655018334Speter push_member_name (constructor_fields); 6551169689Skan output_init_element (value.value, strict_string, 6552169689Skan fieldtype, constructor_fields, 1); 655318334Speter RESTORE_SPELLING_DEPTH (constructor_depth); 655418334Speter } 655518334Speter else 655618334Speter /* Do the bookkeeping for an element that was 655718334Speter directly output as a constructor. */ 655818334Speter { 655918334Speter /* For a record, keep track of end position of last field. */ 656090075Sobrien if (DECL_SIZE (constructor_fields)) 6561169689Skan constructor_bit_index 656290075Sobrien = size_binop (PLUS_EXPR, 6563169689Skan bit_position (constructor_fields), 6564169689Skan DECL_SIZE (constructor_fields)); 656518334Speter 6566110611Skan /* If the current field was the first one not yet written out, 6567110611Skan it isn't now, so update. */ 6568110611Skan if (constructor_unfilled_fields == constructor_fields) 6569110611Skan { 6570110611Skan constructor_unfilled_fields = TREE_CHAIN (constructor_fields); 6571110611Skan /* Skip any nameless bit fields. */ 6572110611Skan while (constructor_unfilled_fields != 0 6573110611Skan && DECL_C_BIT_FIELD (constructor_unfilled_fields) 6574110611Skan && DECL_NAME (constructor_unfilled_fields) == 0) 6575110611Skan constructor_unfilled_fields = 6576110611Skan TREE_CHAIN (constructor_unfilled_fields); 6577110611Skan } 657818334Speter } 657918334Speter 658018334Speter constructor_fields = TREE_CHAIN (constructor_fields); 658118334Speter /* Skip any nameless bit fields at the beginning. */ 658250397Sobrien while (constructor_fields != 0 658350397Sobrien && DECL_C_BIT_FIELD (constructor_fields) 658418334Speter && DECL_NAME (constructor_fields) == 0) 658518334Speter constructor_fields = TREE_CHAIN (constructor_fields); 658618334Speter } 658790075Sobrien else if (TREE_CODE (constructor_type) == UNION_TYPE) 658818334Speter { 658918334Speter tree fieldtype; 659018334Speter enum tree_code fieldcode; 659118334Speter 659218334Speter if (constructor_fields == 0) 659318334Speter { 659452284Sobrien pedwarn_init ("excess elements in union initializer"); 659518334Speter break; 659618334Speter } 659718334Speter 659818334Speter fieldtype = TREE_TYPE (constructor_fields); 659918334Speter if (fieldtype != error_mark_node) 660018334Speter fieldtype = TYPE_MAIN_VARIANT (fieldtype); 660118334Speter fieldcode = TREE_CODE (fieldtype); 660218334Speter 660390075Sobrien /* Warn that traditional C rejects initialization of unions. 660490075Sobrien We skip the warning if the value is zero. This is done 660590075Sobrien under the assumption that the zero initializer in user 660690075Sobrien code appears conditioned on e.g. __STDC__ to avoid 660790075Sobrien "missing initializer" warnings and relies on default 660890075Sobrien initialization to zero in the traditional C case. 660990075Sobrien We also skip the warning if the initializer is designated, 661090075Sobrien again on the assumption that this must be conditional on 661190075Sobrien __STDC__ anyway (and we've already complained about the 661290075Sobrien member-designator already). */ 6613169689Skan if (!in_system_header && !constructor_designated 6614169689Skan && !(value.value && (integer_zerop (value.value) 6615169689Skan || real_zerop (value.value)))) 6616169689Skan warning (OPT_Wtraditional, "traditional C rejects initialization " 6617169689Skan "of unions"); 661890075Sobrien 661918334Speter /* Accept a string constant to initialize a subarray. */ 6620169689Skan if (value.value != 0 662118334Speter && fieldcode == ARRAY_TYPE 6622169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (fieldtype)) 662318334Speter && string_flag) 6624169689Skan value.value = orig_value; 662518334Speter /* Otherwise, if we have come to a subaggregate, 662618334Speter and we don't have an element of its type, push into it. */ 6627169689Skan else if (value.value != 0 6628169689Skan && value.value != error_mark_node 6629169689Skan && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype 663018334Speter && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE 663118334Speter || fieldcode == UNION_TYPE)) 663218334Speter { 663318334Speter push_init_level (1); 663418334Speter continue; 663518334Speter } 663618334Speter 6637169689Skan if (value.value) 663818334Speter { 663918334Speter push_member_name (constructor_fields); 6640169689Skan output_init_element (value.value, strict_string, 6641169689Skan fieldtype, constructor_fields, 1); 664218334Speter RESTORE_SPELLING_DEPTH (constructor_depth); 664318334Speter } 664418334Speter else 664518334Speter /* Do the bookkeeping for an element that was 664618334Speter directly output as a constructor. */ 664718334Speter { 664890075Sobrien constructor_bit_index = DECL_SIZE (constructor_fields); 664918334Speter constructor_unfilled_fields = TREE_CHAIN (constructor_fields); 665018334Speter } 665118334Speter 665218334Speter constructor_fields = 0; 665318334Speter } 665490075Sobrien else if (TREE_CODE (constructor_type) == ARRAY_TYPE) 665518334Speter { 665618334Speter tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type)); 665718334Speter enum tree_code eltcode = TREE_CODE (elttype); 665818334Speter 665918334Speter /* Accept a string constant to initialize a subarray. */ 6660169689Skan if (value.value != 0 666118334Speter && eltcode == ARRAY_TYPE 6662169689Skan && INTEGRAL_TYPE_P (TREE_TYPE (elttype)) 666318334Speter && string_flag) 6664169689Skan value.value = orig_value; 666518334Speter /* Otherwise, if we have come to a subaggregate, 666618334Speter and we don't have an element of its type, push into it. */ 6667169689Skan else if (value.value != 0 6668169689Skan && value.value != error_mark_node 6669169689Skan && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != elttype 667018334Speter && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE 667118334Speter || eltcode == UNION_TYPE)) 667218334Speter { 667318334Speter push_init_level (1); 667418334Speter continue; 667518334Speter } 667618334Speter 667718334Speter if (constructor_max_index != 0 667890075Sobrien && (tree_int_cst_lt (constructor_max_index, constructor_index) 667990075Sobrien || integer_all_onesp (constructor_max_index))) 668018334Speter { 668152284Sobrien pedwarn_init ("excess elements in array initializer"); 668218334Speter break; 668318334Speter } 668418334Speter 668590075Sobrien /* Now output the actual element. */ 6686169689Skan if (value.value) 668750397Sobrien { 6688169689Skan push_array_bounds (tree_low_cst (constructor_index, 1)); 6689169689Skan output_init_element (value.value, strict_string, 6690169689Skan elttype, constructor_index, 1); 669190075Sobrien RESTORE_SPELLING_DEPTH (constructor_depth); 669250397Sobrien } 669350397Sobrien 669490075Sobrien constructor_index 669590075Sobrien = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node); 669618334Speter 6697169689Skan if (!value.value) 669890075Sobrien /* If we are doing the bookkeeping for an element that was 669990075Sobrien directly output as a constructor, we must update 670090075Sobrien constructor_unfilled_index. */ 670190075Sobrien constructor_unfilled_index = constructor_index; 670218334Speter } 670396263Sobrien else if (TREE_CODE (constructor_type) == VECTOR_TYPE) 670496263Sobrien { 670596263Sobrien tree elttype = TYPE_MAIN_VARIANT (TREE_TYPE (constructor_type)); 670618334Speter 6707169689Skan /* Do a basic check of initializer size. Note that vectors 6708169689Skan always have a fixed size derived from their type. */ 670996263Sobrien if (tree_int_cst_lt (constructor_max_index, constructor_index)) 671096263Sobrien { 671196263Sobrien pedwarn_init ("excess elements in vector initializer"); 671296263Sobrien break; 671396263Sobrien } 671496263Sobrien 671596263Sobrien /* Now output the actual element. */ 6716169689Skan if (value.value) 6717169689Skan output_init_element (value.value, strict_string, 6718169689Skan elttype, constructor_index, 1); 671996263Sobrien 672096263Sobrien constructor_index 672196263Sobrien = size_binop (PLUS_EXPR, constructor_index, bitsize_one_node); 672296263Sobrien 6723169689Skan if (!value.value) 672496263Sobrien /* If we are doing the bookkeeping for an element that was 672596263Sobrien directly output as a constructor, we must update 672696263Sobrien constructor_unfilled_index. */ 672796263Sobrien constructor_unfilled_index = constructor_index; 672896263Sobrien } 672996263Sobrien 673018334Speter /* Handle the sole element allowed in a braced initializer 673118334Speter for a scalar variable. */ 6732169689Skan else if (constructor_type != error_mark_node 6733169689Skan && constructor_fields == 0) 673418334Speter { 673552284Sobrien pedwarn_init ("excess elements in scalar initializer"); 673618334Speter break; 673718334Speter } 673890075Sobrien else 673990075Sobrien { 6740169689Skan if (value.value) 6741169689Skan output_init_element (value.value, strict_string, 6742169689Skan constructor_type, NULL_TREE, 1); 674390075Sobrien constructor_fields = 0; 674490075Sobrien } 674518334Speter 674690075Sobrien /* Handle range initializers either at this level or anywhere higher 674790075Sobrien in the designator stack. */ 674890075Sobrien if (constructor_range_stack) 674990075Sobrien { 675090075Sobrien struct constructor_range_stack *p, *range_stack; 675190075Sobrien int finish = 0; 675290075Sobrien 675390075Sobrien range_stack = constructor_range_stack; 675490075Sobrien constructor_range_stack = 0; 675590075Sobrien while (constructor_stack != range_stack->stack) 675690075Sobrien { 6757169689Skan gcc_assert (constructor_stack->implicit); 675890075Sobrien process_init_element (pop_init_level (1)); 675990075Sobrien } 676090075Sobrien for (p = range_stack; 676190075Sobrien !p->range_end || tree_int_cst_equal (p->index, p->range_end); 676290075Sobrien p = p->prev) 676390075Sobrien { 6764169689Skan gcc_assert (constructor_stack->implicit); 676590075Sobrien process_init_element (pop_init_level (1)); 676690075Sobrien } 676790075Sobrien 676890075Sobrien p->index = size_binop (PLUS_EXPR, p->index, bitsize_one_node); 676990075Sobrien if (tree_int_cst_equal (p->index, p->range_end) && !p->prev) 677090075Sobrien finish = 1; 677190075Sobrien 677290075Sobrien while (1) 677390075Sobrien { 677490075Sobrien constructor_index = p->index; 677590075Sobrien constructor_fields = p->fields; 677690075Sobrien if (finish && p->range_end && p->index == p->range_start) 677790075Sobrien { 677890075Sobrien finish = 0; 677990075Sobrien p->prev = 0; 678090075Sobrien } 678190075Sobrien p = p->next; 678290075Sobrien if (!p) 678390075Sobrien break; 678490075Sobrien push_init_level (2); 678590075Sobrien p->stack = constructor_stack; 678690075Sobrien if (p->range_end && tree_int_cst_equal (p->index, p->range_end)) 678790075Sobrien p->index = p->range_start; 678890075Sobrien } 678990075Sobrien 679090075Sobrien if (!finish) 679190075Sobrien constructor_range_stack = range_stack; 679290075Sobrien continue; 679390075Sobrien } 679490075Sobrien 679518334Speter break; 679618334Speter } 679718334Speter 679890075Sobrien constructor_range_stack = 0; 679918334Speter} 680018334Speter 6801169689Skan/* Build a complete asm-statement, whose components are a CV_QUALIFIER 6802169689Skan (guaranteed to be 'volatile' or null) and ARGS (represented using 6803169689Skan an ASM_EXPR node). */ 680490075Sobrientree 6805169689Skanbuild_asm_stmt (tree cv_qualifier, tree args) 680690075Sobrien{ 6807169689Skan if (!ASM_VOLATILE_P (args) && cv_qualifier) 6808169689Skan ASM_VOLATILE_P (args) = 1; 6809169689Skan return add_stmt (args); 681090075Sobrien} 681190075Sobrien 6812169689Skan/* Build an asm-expr, whose components are a STRING, some OUTPUTS, 6813169689Skan some INPUTS, and some CLOBBERS. The latter three may be NULL. 6814169689Skan SIMPLE indicates whether there was anything at all after the 6815169689Skan string in the asm expression -- asm("blah") and asm("blah" : ) 6816169689Skan are subtly different. We use a ASM_EXPR node to represent this. */ 681790075Sobrientree 6818169689Skanbuild_asm_expr (tree string, tree outputs, tree inputs, tree clobbers, 6819169689Skan bool simple) 682090075Sobrien{ 682190075Sobrien tree tail; 6822169689Skan tree args; 6823169689Skan int i; 6824169689Skan const char *constraint; 6825169689Skan const char **oconstraints; 6826169689Skan bool allows_mem, allows_reg, is_inout; 6827169689Skan int ninputs, noutputs; 682890075Sobrien 6829169689Skan ninputs = list_length (inputs); 6830169689Skan noutputs = list_length (outputs); 6831169689Skan oconstraints = (const char **) alloca (noutputs * sizeof (const char *)); 683290075Sobrien 6833169689Skan string = resolve_asm_operand_names (string, outputs, inputs); 683490075Sobrien 6835169689Skan /* Remove output conversions that change the type but not the mode. */ 6836169689Skan for (i = 0, tail = outputs; tail; ++i, tail = TREE_CHAIN (tail)) 683790075Sobrien { 683890075Sobrien tree output = TREE_VALUE (tail); 683990075Sobrien 6840169689Skan /* ??? Really, this should not be here. Users should be using a 6841169689Skan proper lvalue, dammit. But there's a long history of using casts 6842169689Skan in the output operands. In cases like longlong.h, this becomes a 6843169689Skan primitive form of typechecking -- if the cast can be removed, then 6844169689Skan the output operand had a type of the proper width; otherwise we'll 6845169689Skan get an error. Gross, but ... */ 684690075Sobrien STRIP_NOPS (output); 684790075Sobrien 6848169689Skan if (!lvalue_or_else (output, lv_asm)) 6849169689Skan output = error_mark_node; 685090075Sobrien 6851169689Skan if (output != error_mark_node 6852169689Skan && (TREE_READONLY (output) 6853169689Skan || TYPE_READONLY (TREE_TYPE (output)) 6854169689Skan || ((TREE_CODE (TREE_TYPE (output)) == RECORD_TYPE 6855169689Skan || TREE_CODE (TREE_TYPE (output)) == UNION_TYPE) 6856169689Skan && C_TYPE_FIELDS_READONLY (TREE_TYPE (output))))) 6857169689Skan readonly_error (output, lv_asm); 6858169689Skan 6859169689Skan constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail))); 6860169689Skan oconstraints[i] = constraint; 6861169689Skan 6862169689Skan if (parse_output_constraint (&constraint, i, ninputs, noutputs, 6863169689Skan &allows_mem, &allows_reg, &is_inout)) 6864169689Skan { 6865169689Skan /* If the operand is going to end up in memory, 6866169689Skan mark it addressable. */ 6867169689Skan if (!allows_reg && !c_mark_addressable (output)) 6868169689Skan output = error_mark_node; 6869169689Skan } 6870169689Skan else 6871169689Skan output = error_mark_node; 6872169689Skan 6873169689Skan TREE_VALUE (tail) = output; 687490075Sobrien } 687590075Sobrien 6876169689Skan for (i = 0, tail = inputs; tail; ++i, tail = TREE_CHAIN (tail)) 687790075Sobrien { 6878169689Skan tree input; 6879169689Skan 6880169689Skan constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (tail))); 6881169689Skan input = TREE_VALUE (tail); 6882169689Skan 6883169689Skan if (parse_input_constraint (&constraint, i, ninputs, noutputs, 0, 6884169689Skan oconstraints, &allows_mem, &allows_reg)) 6885169689Skan { 6886169689Skan /* If the operand is going to end up in memory, 6887169689Skan mark it addressable. */ 6888169689Skan if (!allows_reg && allows_mem) 6889169689Skan { 6890169689Skan /* Strip the nops as we allow this case. FIXME, this really 6891169689Skan should be rejected or made deprecated. */ 6892169689Skan STRIP_NOPS (input); 6893169689Skan if (!c_mark_addressable (input)) 6894169689Skan input = error_mark_node; 6895169689Skan } 6896169689Skan } 6897169689Skan else 6898169689Skan input = error_mark_node; 6899169689Skan 6900169689Skan TREE_VALUE (tail) = input; 690190075Sobrien } 690290075Sobrien 6903169689Skan args = build_stmt (ASM_EXPR, string, outputs, inputs, clobbers); 690490075Sobrien 6905169689Skan /* asm statements without outputs, including simple ones, are treated 6906169689Skan as volatile. */ 6907169689Skan ASM_INPUT_P (args) = simple; 6908169689Skan ASM_VOLATILE_P (args) = (noutputs == 0); 6909169689Skan 6910169689Skan return args; 691190075Sobrien} 6912169689Skan 6913169689Skan/* Generate a goto statement to LABEL. */ 691490075Sobrien 6915169689Skantree 6916169689Skanc_finish_goto_label (tree label) 691718334Speter{ 6918169689Skan tree decl = lookup_label (label); 6919169689Skan if (!decl) 6920169689Skan return NULL_TREE; 692118334Speter 6922169689Skan if (C_DECL_UNJUMPABLE_STMT_EXPR (decl)) 6923117395Skan { 6924169689Skan error ("jump into statement expression"); 6925169689Skan return NULL_TREE; 6926117395Skan } 692718334Speter 6928169689Skan if (C_DECL_UNJUMPABLE_VM (decl)) 6929169689Skan { 6930169689Skan error ("jump into scope of identifier with variably modified type"); 6931169689Skan return NULL_TREE; 6932169689Skan } 693318334Speter 6934169689Skan if (!C_DECL_UNDEFINABLE_STMT_EXPR (decl)) 693518334Speter { 6936169689Skan /* No jump from outside this statement expression context, so 6937169689Skan record that there is a jump from within this context. */ 6938169689Skan struct c_label_list *nlist; 6939169689Skan nlist = XOBNEW (&parser_obstack, struct c_label_list); 6940169689Skan nlist->next = label_context_stack_se->labels_used; 6941169689Skan nlist->label = decl; 6942169689Skan label_context_stack_se->labels_used = nlist; 6943169689Skan } 694490075Sobrien 6945169689Skan if (!C_DECL_UNDEFINABLE_VM (decl)) 6946169689Skan { 6947169689Skan /* No jump from outside this context context of identifiers with 6948169689Skan variably modified type, so record that there is a jump from 6949169689Skan within this context. */ 6950169689Skan struct c_label_list *nlist; 6951169689Skan nlist = XOBNEW (&parser_obstack, struct c_label_list); 6952169689Skan nlist->next = label_context_stack_vm->labels_used; 6953169689Skan nlist->label = decl; 6954169689Skan label_context_stack_vm->labels_used = nlist; 695518334Speter } 695618334Speter 6957169689Skan TREE_USED (decl) = 1; 6958169689Skan return add_stmt (build1 (GOTO_EXPR, void_type_node, decl)); 695918334Speter} 696018334Speter 6961169689Skan/* Generate a computed goto statement to EXPR. */ 6962169689Skan 696390075Sobrientree 6964169689Skanc_finish_goto_ptr (tree expr) 696518334Speter{ 6966169689Skan if (pedantic) 6967169689Skan pedwarn ("ISO C forbids %<goto *expr;%>"); 6968169689Skan expr = convert (ptr_type_node, expr); 6969169689Skan return add_stmt (build1 (GOTO_EXPR, void_type_node, expr)); 6970169689Skan} 697118334Speter 6972169689Skan/* Generate a C `return' statement. RETVAL is the expression for what 6973169689Skan to return, or a null pointer for `return;' with no value. */ 6974169689Skan 6975169689Skantree 6976169689Skanc_finish_return (tree retval) 6977169689Skan{ 6978169689Skan tree valtype = TREE_TYPE (TREE_TYPE (current_function_decl)), ret_stmt; 6979169689Skan bool no_warning = false; 6980169689Skan 698118334Speter if (TREE_THIS_VOLATILE (current_function_decl)) 6982169689Skan warning (0, "function declared %<noreturn%> has a %<return%> statement"); 698318334Speter 698418334Speter if (!retval) 698518334Speter { 698618334Speter current_function_returns_null = 1; 698790075Sobrien if ((warn_return_type || flag_isoc99) 698890075Sobrien && valtype != 0 && TREE_CODE (valtype) != VOID_TYPE) 6989169689Skan { 6990169689Skan pedwarn_c99 ("%<return%> with no value, in " 6991169689Skan "function returning non-void"); 6992169689Skan no_warning = true; 6993169689Skan } 699418334Speter } 699518334Speter else if (valtype == 0 || TREE_CODE (valtype) == VOID_TYPE) 699618334Speter { 699718334Speter current_function_returns_null = 1; 699818334Speter if (pedantic || TREE_CODE (TREE_TYPE (retval)) != VOID_TYPE) 6999169689Skan pedwarn ("%<return%> with a value, in function returning void"); 700018334Speter } 700118334Speter else 700218334Speter { 7003169689Skan tree t = convert_for_assignment (valtype, retval, ic_return, 700418334Speter NULL_TREE, NULL_TREE, 0); 700518334Speter tree res = DECL_RESULT (current_function_decl); 700618334Speter tree inner; 700718334Speter 700896263Sobrien current_function_returns_value = 1; 700918334Speter if (t == error_mark_node) 701090075Sobrien return NULL_TREE; 701118334Speter 701218334Speter inner = t = convert (TREE_TYPE (res), t); 701318334Speter 701418334Speter /* Strip any conversions, additions, and subtractions, and see if 701518334Speter we are returning the address of a local variable. Warn if so. */ 701618334Speter while (1) 701718334Speter { 701818334Speter switch (TREE_CODE (inner)) 701918334Speter { 702018334Speter case NOP_EXPR: case NON_LVALUE_EXPR: case CONVERT_EXPR: 702118334Speter case PLUS_EXPR: 702218334Speter inner = TREE_OPERAND (inner, 0); 702318334Speter continue; 702418334Speter 702518334Speter case MINUS_EXPR: 702618334Speter /* If the second operand of the MINUS_EXPR has a pointer 702718334Speter type (or is converted from it), this may be valid, so 702818334Speter don't give a warning. */ 702918334Speter { 703018334Speter tree op1 = TREE_OPERAND (inner, 1); 703118334Speter 7032169689Skan while (!POINTER_TYPE_P (TREE_TYPE (op1)) 703318334Speter && (TREE_CODE (op1) == NOP_EXPR 703418334Speter || TREE_CODE (op1) == NON_LVALUE_EXPR 703518334Speter || TREE_CODE (op1) == CONVERT_EXPR)) 703618334Speter op1 = TREE_OPERAND (op1, 0); 703718334Speter 703818334Speter if (POINTER_TYPE_P (TREE_TYPE (op1))) 703918334Speter break; 704018334Speter 704118334Speter inner = TREE_OPERAND (inner, 0); 704218334Speter continue; 704318334Speter } 7044132718Skan 704518334Speter case ADDR_EXPR: 704618334Speter inner = TREE_OPERAND (inner, 0); 704718334Speter 7048169689Skan while (REFERENCE_CLASS_P (inner) 7049169689Skan && TREE_CODE (inner) != INDIRECT_REF) 705018334Speter inner = TREE_OPERAND (inner, 0); 705118334Speter 7052169689Skan if (DECL_P (inner) 7053169689Skan && !DECL_EXTERNAL (inner) 7054169689Skan && !TREE_STATIC (inner) 705518334Speter && DECL_CONTEXT (inner) == current_function_decl) 7056169689Skan warning (0, "function returns address of local variable"); 705718334Speter break; 705850397Sobrien 705950397Sobrien default: 706050397Sobrien break; 706118334Speter } 706218334Speter 706318334Speter break; 706418334Speter } 706518334Speter 7066169689Skan retval = build2 (MODIFY_EXPR, TREE_TYPE (res), res, t); 706718334Speter } 706890075Sobrien 7069169689Skan ret_stmt = build_stmt (RETURN_EXPR, retval); 7070169689Skan TREE_NO_WARNING (ret_stmt) |= no_warning; 7071169689Skan return add_stmt (ret_stmt); 707218334Speter} 707318334Speter 707490075Sobrienstruct c_switch { 7075169689Skan /* The SWITCH_EXPR being built. */ 7076169689Skan tree switch_expr; 7077169689Skan 7078169689Skan /* The original type of the testing expression, i.e. before the 7079169689Skan default conversion is applied. */ 7080169689Skan tree orig_type; 7081169689Skan 708290075Sobrien /* A splay-tree mapping the low element of a case range to the high 708390075Sobrien element, or NULL_TREE if there is no high element. Used to 708490075Sobrien determine whether or not a new case label duplicates an old case 708590075Sobrien label. We need a tree, rather than simply a hash table, because 708690075Sobrien of the GNU case range extension. */ 708790075Sobrien splay_tree cases; 7088169689Skan 7089169689Skan /* Number of nested statement expressions within this switch 7090169689Skan statement; if nonzero, case and default labels may not 7091169689Skan appear. */ 7092169689Skan unsigned int blocked_stmt_expr; 7093169689Skan 7094169689Skan /* Scope of outermost declarations of identifiers with variably 7095169689Skan modified type within this switch statement; if nonzero, case and 7096169689Skan default labels may not appear. */ 7097169689Skan unsigned int blocked_vm; 7098169689Skan 709990075Sobrien /* The next node on the stack. */ 710090075Sobrien struct c_switch *next; 710190075Sobrien}; 710218334Speter 710390075Sobrien/* A stack of the currently active switch statements. The innermost 710490075Sobrien switch statement is on the top of the stack. There is no need to 710590075Sobrien mark the stack for garbage collection because it is only active 710690075Sobrien during the processing of the body of a function, and we never 710790075Sobrien collect at that point. */ 710890075Sobrien 7109169689Skanstruct c_switch *c_switch_stack; 711090075Sobrien 711190075Sobrien/* Start a C switch statement, testing expression EXP. Return the new 7112169689Skan SWITCH_EXPR. */ 711390075Sobrien 711418334Spetertree 7115132718Skanc_start_case (tree exp) 711618334Speter{ 7117169689Skan tree orig_type = error_mark_node; 711890075Sobrien struct c_switch *cs; 711918334Speter 712090075Sobrien if (exp != error_mark_node) 712118334Speter { 712296263Sobrien orig_type = TREE_TYPE (exp); 712390075Sobrien 7124169689Skan if (!INTEGRAL_TYPE_P (orig_type)) 712590075Sobrien { 7126169689Skan if (orig_type != error_mark_node) 7127169689Skan { 7128169689Skan error ("switch quantity not an integer"); 7129169689Skan orig_type = error_mark_node; 7130169689Skan } 713190075Sobrien exp = integer_zero_node; 713290075Sobrien } 713390075Sobrien else 713490075Sobrien { 7135169689Skan tree type = TYPE_MAIN_VARIANT (orig_type); 713690075Sobrien 7137169689Skan if (!in_system_header 713890075Sobrien && (type == long_integer_type_node 713990075Sobrien || type == long_unsigned_type_node)) 7140169689Skan warning (OPT_Wtraditional, "%<long%> switch expression not " 7141169689Skan "converted to %<int%> in ISO C"); 714290075Sobrien 714390075Sobrien exp = default_conversion (exp); 714490075Sobrien } 714518334Speter } 714618334Speter 7147169689Skan /* Add this new SWITCH_EXPR to the stack. */ 7148169689Skan cs = XNEW (struct c_switch); 7149169689Skan cs->switch_expr = build3 (SWITCH_EXPR, orig_type, exp, NULL_TREE, NULL_TREE); 7150169689Skan cs->orig_type = orig_type; 715190075Sobrien cs->cases = splay_tree_new (case_compare, NULL, NULL); 7152169689Skan cs->blocked_stmt_expr = 0; 7153169689Skan cs->blocked_vm = 0; 7154169689Skan cs->next = c_switch_stack; 7155169689Skan c_switch_stack = cs; 715618334Speter 7157169689Skan return add_stmt (cs->switch_expr); 715890075Sobrien} 715990075Sobrien 716090075Sobrien/* Process a case label. */ 716190075Sobrien 716290075Sobrientree 7163132718Skando_case (tree low_value, tree high_value) 716490075Sobrien{ 716590075Sobrien tree label = NULL_TREE; 716690075Sobrien 7167169689Skan if (c_switch_stack && !c_switch_stack->blocked_stmt_expr 7168169689Skan && !c_switch_stack->blocked_vm) 716990075Sobrien { 7170169689Skan label = c_add_case_label (c_switch_stack->cases, 7171169689Skan SWITCH_COND (c_switch_stack->switch_expr), 7172169689Skan c_switch_stack->orig_type, 717390075Sobrien low_value, high_value); 717490075Sobrien if (label == error_mark_node) 717590075Sobrien label = NULL_TREE; 717618334Speter } 7177169689Skan else if (c_switch_stack && c_switch_stack->blocked_stmt_expr) 7178169689Skan { 7179169689Skan if (low_value) 7180169689Skan error ("case label in statement expression not containing " 7181169689Skan "enclosing switch statement"); 7182169689Skan else 7183169689Skan error ("%<default%> label in statement expression not containing " 7184169689Skan "enclosing switch statement"); 7185169689Skan } 7186169689Skan else if (c_switch_stack && c_switch_stack->blocked_vm) 7187169689Skan { 7188169689Skan if (low_value) 7189169689Skan error ("case label in scope of identifier with variably modified " 7190169689Skan "type not containing enclosing switch statement"); 7191169689Skan else 7192169689Skan error ("%<default%> label in scope of identifier with variably " 7193169689Skan "modified type not containing enclosing switch statement"); 7194169689Skan } 719590075Sobrien else if (low_value) 719690075Sobrien error ("case label not within a switch statement"); 719790075Sobrien else 7198169689Skan error ("%<default%> label not within a switch statement"); 719918334Speter 720090075Sobrien return label; 720190075Sobrien} 720218334Speter 720390075Sobrien/* Finish the switch statement. */ 720490075Sobrien 720590075Sobrienvoid 7206169689Skanc_finish_case (tree body) 720790075Sobrien{ 7208169689Skan struct c_switch *cs = c_switch_stack; 7209169689Skan location_t switch_location; 721090075Sobrien 7211169689Skan SWITCH_BODY (cs->switch_expr) = body; 7212146895Skan 7213169689Skan /* We must not be within a statement expression nested in the switch 7214169689Skan at this point; we might, however, be within the scope of an 7215169689Skan identifier with variably modified type nested in the switch. */ 7216169689Skan gcc_assert (!cs->blocked_stmt_expr); 721790075Sobrien 7218169689Skan /* Emit warnings as needed. */ 7219169689Skan if (EXPR_HAS_LOCATION (cs->switch_expr)) 7220169689Skan switch_location = EXPR_LOCATION (cs->switch_expr); 7221169689Skan else 7222169689Skan switch_location = input_location; 7223169689Skan c_do_switch_warnings (cs->cases, switch_location, 7224169689Skan TREE_TYPE (cs->switch_expr), 7225169689Skan SWITCH_COND (cs->switch_expr)); 7226169689Skan 722790075Sobrien /* Pop the stack. */ 7228169689Skan c_switch_stack = cs->next; 722990075Sobrien splay_tree_delete (cs->cases); 7230169689Skan XDELETE (cs); 723118334Speter} 7232169689Skan 7233169689Skan/* Emit an if statement. IF_LOCUS is the location of the 'if'. COND, 7234169689Skan THEN_BLOCK and ELSE_BLOCK are expressions to be used; ELSE_BLOCK 7235169689Skan may be null. NESTED_IF is true if THEN_BLOCK contains another IF 7236169689Skan statement, and was not surrounded with parenthesis. */ 7237132718Skan 7238169689Skanvoid 7239169689Skanc_finish_if_stmt (location_t if_locus, tree cond, tree then_block, 7240169689Skan tree else_block, bool nested_if) 7241169689Skan{ 7242169689Skan tree stmt; 7243169689Skan 7244169689Skan /* Diagnose an ambiguous else if if-then-else is nested inside if-then. */ 7245169689Skan if (warn_parentheses && nested_if && else_block == NULL) 7246169689Skan { 7247169689Skan tree inner_if = then_block; 7248169689Skan 7249169689Skan /* We know from the grammar productions that there is an IF nested 7250169689Skan within THEN_BLOCK. Due to labels and c99 conditional declarations, 7251169689Skan it might not be exactly THEN_BLOCK, but should be the last 7252169689Skan non-container statement within. */ 7253169689Skan while (1) 7254169689Skan switch (TREE_CODE (inner_if)) 7255169689Skan { 7256169689Skan case COND_EXPR: 7257169689Skan goto found; 7258169689Skan case BIND_EXPR: 7259169689Skan inner_if = BIND_EXPR_BODY (inner_if); 7260169689Skan break; 7261169689Skan case STATEMENT_LIST: 7262169689Skan inner_if = expr_last (then_block); 7263169689Skan break; 7264169689Skan case TRY_FINALLY_EXPR: 7265169689Skan case TRY_CATCH_EXPR: 7266169689Skan inner_if = TREE_OPERAND (inner_if, 0); 7267169689Skan break; 7268169689Skan default: 7269169689Skan gcc_unreachable (); 7270169689Skan } 7271169689Skan found: 7272169689Skan 7273169689Skan if (COND_EXPR_ELSE (inner_if)) 7274169689Skan warning (OPT_Wparentheses, 7275169689Skan "%Hsuggest explicit braces to avoid ambiguous %<else%>", 7276169689Skan &if_locus); 7277169689Skan } 7278169689Skan 7279169689Skan empty_body_warning (then_block, else_block); 7280169689Skan 7281169689Skan stmt = build3 (COND_EXPR, void_type_node, cond, then_block, else_block); 7282169689Skan SET_EXPR_LOCATION (stmt, if_locus); 7283169689Skan add_stmt (stmt); 7284169689Skan} 7285169689Skan 7286169689Skan/* Emit a general-purpose loop construct. START_LOCUS is the location of 7287169689Skan the beginning of the loop. COND is the loop condition. COND_IS_FIRST 7288169689Skan is false for DO loops. INCR is the FOR increment expression. BODY is 7289169689Skan the statement controlled by the loop. BLAB is the break label. CLAB is 7290169689Skan the continue label. Everything is allowed to be NULL. */ 7291169689Skan 7292169689Skanvoid 7293169689Skanc_finish_loop (location_t start_locus, tree cond, tree incr, tree body, 7294169689Skan tree blab, tree clab, bool cond_is_first) 7295169689Skan{ 7296169689Skan tree entry = NULL, exit = NULL, t; 7297169689Skan 7298169689Skan /* If the condition is zero don't generate a loop construct. */ 7299169689Skan if (cond && integer_zerop (cond)) 7300169689Skan { 7301169689Skan if (cond_is_first) 7302169689Skan { 7303169689Skan t = build_and_jump (&blab); 7304169689Skan SET_EXPR_LOCATION (t, start_locus); 7305169689Skan add_stmt (t); 7306169689Skan } 7307169689Skan } 7308169689Skan else 7309169689Skan { 7310169689Skan tree top = build1 (LABEL_EXPR, void_type_node, NULL_TREE); 7311169689Skan 7312169689Skan /* If we have an exit condition, then we build an IF with gotos either 7313169689Skan out of the loop, or to the top of it. If there's no exit condition, 7314169689Skan then we just build a jump back to the top. */ 7315169689Skan exit = build_and_jump (&LABEL_EXPR_LABEL (top)); 7316169689Skan 7317169689Skan if (cond && !integer_nonzerop (cond)) 7318169689Skan { 7319169689Skan /* Canonicalize the loop condition to the end. This means 7320169689Skan generating a branch to the loop condition. Reuse the 7321169689Skan continue label, if possible. */ 7322169689Skan if (cond_is_first) 7323169689Skan { 7324169689Skan if (incr || !clab) 7325169689Skan { 7326169689Skan entry = build1 (LABEL_EXPR, void_type_node, NULL_TREE); 7327169689Skan t = build_and_jump (&LABEL_EXPR_LABEL (entry)); 7328169689Skan } 7329169689Skan else 7330169689Skan t = build1 (GOTO_EXPR, void_type_node, clab); 7331169689Skan SET_EXPR_LOCATION (t, start_locus); 7332169689Skan add_stmt (t); 7333169689Skan } 7334169689Skan 7335169689Skan t = build_and_jump (&blab); 7336169689Skan exit = fold_build3 (COND_EXPR, void_type_node, cond, exit, t); 7337169689Skan if (cond_is_first) 7338169689Skan SET_EXPR_LOCATION (exit, start_locus); 7339169689Skan else 7340169689Skan SET_EXPR_LOCATION (exit, input_location); 7341169689Skan } 7342169689Skan 7343169689Skan add_stmt (top); 7344169689Skan } 7345169689Skan 7346169689Skan if (body) 7347169689Skan add_stmt (body); 7348169689Skan if (clab) 7349169689Skan add_stmt (build1 (LABEL_EXPR, void_type_node, clab)); 7350169689Skan if (incr) 7351169689Skan add_stmt (incr); 7352169689Skan if (entry) 7353169689Skan add_stmt (entry); 7354169689Skan if (exit) 7355169689Skan add_stmt (exit); 7356169689Skan if (blab) 7357169689Skan add_stmt (build1 (LABEL_EXPR, void_type_node, blab)); 7358169689Skan} 7359169689Skan 7360169689Skantree 7361169689Skanc_finish_bc_stmt (tree *label_p, bool is_break) 7362169689Skan{ 7363169689Skan bool skip; 7364169689Skan tree label = *label_p; 7365169689Skan 7366169689Skan /* In switch statements break is sometimes stylistically used after 7367169689Skan a return statement. This can lead to spurious warnings about 7368169689Skan control reaching the end of a non-void function when it is 7369169689Skan inlined. Note that we are calling block_may_fallthru with 7370169689Skan language specific tree nodes; this works because 7371169689Skan block_may_fallthru returns true when given something it does not 7372169689Skan understand. */ 7373169689Skan skip = !block_may_fallthru (cur_stmt_list); 7374169689Skan 7375169689Skan if (!label) 7376169689Skan { 7377169689Skan if (!skip) 7378169689Skan *label_p = label = create_artificial_label (); 7379169689Skan } 7380169689Skan else if (TREE_CODE (label) == LABEL_DECL) 7381169689Skan ; 7382169689Skan else switch (TREE_INT_CST_LOW (label)) 7383169689Skan { 7384169689Skan case 0: 7385169689Skan if (is_break) 7386169689Skan error ("break statement not within loop or switch"); 7387169689Skan else 7388169689Skan error ("continue statement not within a loop"); 7389169689Skan return NULL_TREE; 7390169689Skan 7391169689Skan case 1: 7392169689Skan gcc_assert (is_break); 7393169689Skan error ("break statement used with OpenMP for loop"); 7394169689Skan return NULL_TREE; 7395169689Skan 7396169689Skan default: 7397169689Skan gcc_unreachable (); 7398169689Skan } 7399169689Skan 7400169689Skan if (skip) 7401169689Skan return NULL_TREE; 7402169689Skan 7403169689Skan return add_stmt (build1 (GOTO_EXPR, void_type_node, label)); 7404169689Skan} 7405169689Skan 7406169689Skan/* A helper routine for c_process_expr_stmt and c_finish_stmt_expr. */ 7407169689Skan 7408169689Skanstatic void 7409169689Skanemit_side_effect_warnings (tree expr) 7410169689Skan{ 7411169689Skan if (expr == error_mark_node) 7412169689Skan ; 7413169689Skan else if (!TREE_SIDE_EFFECTS (expr)) 7414169689Skan { 7415169689Skan if (!VOID_TYPE_P (TREE_TYPE (expr)) && !TREE_NO_WARNING (expr)) 7416169689Skan warning (0, "%Hstatement with no effect", 7417169689Skan EXPR_HAS_LOCATION (expr) ? EXPR_LOCUS (expr) : &input_location); 7418169689Skan } 7419169689Skan else if (warn_unused_value) 7420169689Skan warn_if_unused_value (expr, input_location); 7421169689Skan} 7422169689Skan 7423169689Skan/* Process an expression as if it were a complete statement. Emit 7424169689Skan diagnostics, but do not call ADD_STMT. */ 7425169689Skan 7426169689Skantree 7427169689Skanc_process_expr_stmt (tree expr) 7428169689Skan{ 7429169689Skan if (!expr) 7430169689Skan return NULL_TREE; 7431169689Skan 7432169689Skan if (warn_sequence_point) 7433169689Skan verify_sequence_points (expr); 7434169689Skan 7435169689Skan if (TREE_TYPE (expr) != error_mark_node 7436169689Skan && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr)) 7437169689Skan && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE) 7438169689Skan error ("expression statement has incomplete type"); 7439169689Skan 7440169689Skan /* If we're not processing a statement expression, warn about unused values. 7441169689Skan Warnings for statement expressions will be emitted later, once we figure 7442169689Skan out which is the result. */ 7443169689Skan if (!STATEMENT_LIST_STMT_EXPR (cur_stmt_list) 7444169689Skan && (extra_warnings || warn_unused_value)) 7445169689Skan emit_side_effect_warnings (expr); 7446169689Skan 7447169689Skan /* If the expression is not of a type to which we cannot assign a line 7448169689Skan number, wrap the thing in a no-op NOP_EXPR. */ 7449169689Skan if (DECL_P (expr) || CONSTANT_CLASS_P (expr)) 7450169689Skan expr = build1 (NOP_EXPR, TREE_TYPE (expr), expr); 7451169689Skan 7452169689Skan if (EXPR_P (expr)) 7453169689Skan SET_EXPR_LOCATION (expr, input_location); 7454169689Skan 7455169689Skan return expr; 7456169689Skan} 7457169689Skan 7458169689Skan/* Emit an expression as a statement. */ 7459169689Skan 7460169689Skantree 7461169689Skanc_finish_expr_stmt (tree expr) 7462169689Skan{ 7463169689Skan if (expr) 7464169689Skan return add_stmt (c_process_expr_stmt (expr)); 7465169689Skan else 7466169689Skan return NULL; 7467169689Skan} 7468169689Skan 7469169689Skan/* Do the opposite and emit a statement as an expression. To begin, 7470169689Skan create a new binding level and return it. */ 7471169689Skan 7472169689Skantree 7473169689Skanc_begin_stmt_expr (void) 7474169689Skan{ 7475169689Skan tree ret; 7476169689Skan struct c_label_context_se *nstack; 7477169689Skan struct c_label_list *glist; 7478169689Skan 7479169689Skan /* We must force a BLOCK for this level so that, if it is not expanded 7480169689Skan later, there is a way to turn off the entire subtree of blocks that 7481169689Skan are contained in it. */ 7482169689Skan keep_next_level (); 7483169689Skan ret = c_begin_compound_stmt (true); 7484169689Skan if (c_switch_stack) 7485169689Skan { 7486169689Skan c_switch_stack->blocked_stmt_expr++; 7487169689Skan gcc_assert (c_switch_stack->blocked_stmt_expr != 0); 7488169689Skan } 7489169689Skan for (glist = label_context_stack_se->labels_used; 7490169689Skan glist != NULL; 7491169689Skan glist = glist->next) 7492169689Skan { 7493169689Skan C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 1; 7494169689Skan } 7495169689Skan nstack = XOBNEW (&parser_obstack, struct c_label_context_se); 7496169689Skan nstack->labels_def = NULL; 7497169689Skan nstack->labels_used = NULL; 7498169689Skan nstack->next = label_context_stack_se; 7499169689Skan label_context_stack_se = nstack; 7500169689Skan 7501169689Skan /* Mark the current statement list as belonging to a statement list. */ 7502169689Skan STATEMENT_LIST_STMT_EXPR (ret) = 1; 7503169689Skan 7504169689Skan return ret; 7505169689Skan} 7506169689Skan 7507169689Skantree 7508169689Skanc_finish_stmt_expr (tree body) 7509169689Skan{ 7510169689Skan tree last, type, tmp, val; 7511169689Skan tree *last_p; 7512169689Skan struct c_label_list *dlist, *glist, *glist_prev = NULL; 7513169689Skan 7514169689Skan body = c_end_compound_stmt (body, true); 7515169689Skan if (c_switch_stack) 7516169689Skan { 7517169689Skan gcc_assert (c_switch_stack->blocked_stmt_expr != 0); 7518169689Skan c_switch_stack->blocked_stmt_expr--; 7519169689Skan } 7520169689Skan /* It is no longer possible to jump to labels defined within this 7521169689Skan statement expression. */ 7522169689Skan for (dlist = label_context_stack_se->labels_def; 7523169689Skan dlist != NULL; 7524169689Skan dlist = dlist->next) 7525169689Skan { 7526169689Skan C_DECL_UNJUMPABLE_STMT_EXPR (dlist->label) = 1; 7527169689Skan } 7528169689Skan /* It is again possible to define labels with a goto just outside 7529169689Skan this statement expression. */ 7530169689Skan for (glist = label_context_stack_se->next->labels_used; 7531169689Skan glist != NULL; 7532169689Skan glist = glist->next) 7533169689Skan { 7534169689Skan C_DECL_UNDEFINABLE_STMT_EXPR (glist->label) = 0; 7535169689Skan glist_prev = glist; 7536169689Skan } 7537169689Skan if (glist_prev != NULL) 7538169689Skan glist_prev->next = label_context_stack_se->labels_used; 7539169689Skan else 7540169689Skan label_context_stack_se->next->labels_used 7541169689Skan = label_context_stack_se->labels_used; 7542169689Skan label_context_stack_se = label_context_stack_se->next; 7543169689Skan 7544169689Skan /* Locate the last statement in BODY. See c_end_compound_stmt 7545169689Skan about always returning a BIND_EXPR. */ 7546169689Skan last_p = &BIND_EXPR_BODY (body); 7547169689Skan last = BIND_EXPR_BODY (body); 7548169689Skan 7549169689Skan continue_searching: 7550169689Skan if (TREE_CODE (last) == STATEMENT_LIST) 7551169689Skan { 7552169689Skan tree_stmt_iterator i; 7553169689Skan 7554169689Skan /* This can happen with degenerate cases like ({ }). No value. */ 7555169689Skan if (!TREE_SIDE_EFFECTS (last)) 7556169689Skan return body; 7557169689Skan 7558169689Skan /* If we're supposed to generate side effects warnings, process 7559169689Skan all of the statements except the last. */ 7560169689Skan if (extra_warnings || warn_unused_value) 7561169689Skan { 7562169689Skan for (i = tsi_start (last); !tsi_one_before_end_p (i); tsi_next (&i)) 7563169689Skan emit_side_effect_warnings (tsi_stmt (i)); 7564169689Skan } 7565169689Skan else 7566169689Skan i = tsi_last (last); 7567169689Skan last_p = tsi_stmt_ptr (i); 7568169689Skan last = *last_p; 7569169689Skan } 7570169689Skan 7571169689Skan /* If the end of the list is exception related, then the list was split 7572169689Skan by a call to push_cleanup. Continue searching. */ 7573169689Skan if (TREE_CODE (last) == TRY_FINALLY_EXPR 7574169689Skan || TREE_CODE (last) == TRY_CATCH_EXPR) 7575169689Skan { 7576169689Skan last_p = &TREE_OPERAND (last, 0); 7577169689Skan last = *last_p; 7578169689Skan goto continue_searching; 7579169689Skan } 7580169689Skan 7581169689Skan /* In the case that the BIND_EXPR is not necessary, return the 7582169689Skan expression out from inside it. */ 7583169689Skan if (last == error_mark_node 7584169689Skan || (last == BIND_EXPR_BODY (body) 7585169689Skan && BIND_EXPR_VARS (body) == NULL)) 7586169689Skan { 7587169689Skan /* Do not warn if the return value of a statement expression is 7588169689Skan unused. */ 7589169689Skan if (EXPR_P (last)) 7590169689Skan TREE_NO_WARNING (last) = 1; 7591169689Skan return last; 7592169689Skan } 7593169689Skan 7594169689Skan /* Extract the type of said expression. */ 7595169689Skan type = TREE_TYPE (last); 7596169689Skan 7597169689Skan /* If we're not returning a value at all, then the BIND_EXPR that 7598169689Skan we already have is a fine expression to return. */ 7599169689Skan if (!type || VOID_TYPE_P (type)) 7600169689Skan return body; 7601169689Skan 7602169689Skan /* Now that we've located the expression containing the value, it seems 7603169689Skan silly to make voidify_wrapper_expr repeat the process. Create a 7604169689Skan temporary of the appropriate type and stick it in a TARGET_EXPR. */ 7605169689Skan tmp = create_tmp_var_raw (type, NULL); 7606169689Skan 7607169689Skan /* Unwrap a no-op NOP_EXPR as added by c_finish_expr_stmt. This avoids 7608169689Skan tree_expr_nonnegative_p giving up immediately. */ 7609169689Skan val = last; 7610169689Skan if (TREE_CODE (val) == NOP_EXPR 7611169689Skan && TREE_TYPE (val) == TREE_TYPE (TREE_OPERAND (val, 0))) 7612169689Skan val = TREE_OPERAND (val, 0); 7613169689Skan 7614169689Skan *last_p = build2 (MODIFY_EXPR, void_type_node, tmp, val); 7615169689Skan SET_EXPR_LOCUS (*last_p, EXPR_LOCUS (last)); 7616169689Skan 7617169689Skan return build4 (TARGET_EXPR, type, tmp, body, NULL_TREE, NULL_TREE); 7618169689Skan} 7619169689Skan 7620169689Skan/* Begin the scope of an identifier of variably modified type, scope 7621169689Skan number SCOPE. Jumping from outside this scope to inside it is not 7622169689Skan permitted. */ 7623169689Skan 7624169689Skanvoid 7625169689Skanc_begin_vm_scope (unsigned int scope) 7626169689Skan{ 7627169689Skan struct c_label_context_vm *nstack; 7628169689Skan struct c_label_list *glist; 7629169689Skan 7630169689Skan gcc_assert (scope > 0); 7631169689Skan 7632169689Skan /* At file_scope, we don't have to do any processing. */ 7633169689Skan if (label_context_stack_vm == NULL) 7634169689Skan return; 7635169689Skan 7636169689Skan if (c_switch_stack && !c_switch_stack->blocked_vm) 7637169689Skan c_switch_stack->blocked_vm = scope; 7638169689Skan for (glist = label_context_stack_vm->labels_used; 7639169689Skan glist != NULL; 7640169689Skan glist = glist->next) 7641169689Skan { 7642169689Skan C_DECL_UNDEFINABLE_VM (glist->label) = 1; 7643169689Skan } 7644169689Skan nstack = XOBNEW (&parser_obstack, struct c_label_context_vm); 7645169689Skan nstack->labels_def = NULL; 7646169689Skan nstack->labels_used = NULL; 7647169689Skan nstack->scope = scope; 7648169689Skan nstack->next = label_context_stack_vm; 7649169689Skan label_context_stack_vm = nstack; 7650169689Skan} 7651169689Skan 7652169689Skan/* End a scope which may contain identifiers of variably modified 7653169689Skan type, scope number SCOPE. */ 7654169689Skan 7655169689Skanvoid 7656169689Skanc_end_vm_scope (unsigned int scope) 7657169689Skan{ 7658169689Skan if (label_context_stack_vm == NULL) 7659169689Skan return; 7660169689Skan if (c_switch_stack && c_switch_stack->blocked_vm == scope) 7661169689Skan c_switch_stack->blocked_vm = 0; 7662169689Skan /* We may have a number of nested scopes of identifiers with 7663169689Skan variably modified type, all at this depth. Pop each in turn. */ 7664169689Skan while (label_context_stack_vm->scope == scope) 7665169689Skan { 7666169689Skan struct c_label_list *dlist, *glist, *glist_prev = NULL; 7667169689Skan 7668169689Skan /* It is no longer possible to jump to labels defined within this 7669169689Skan scope. */ 7670169689Skan for (dlist = label_context_stack_vm->labels_def; 7671169689Skan dlist != NULL; 7672169689Skan dlist = dlist->next) 7673169689Skan { 7674169689Skan C_DECL_UNJUMPABLE_VM (dlist->label) = 1; 7675169689Skan } 7676169689Skan /* It is again possible to define labels with a goto just outside 7677169689Skan this scope. */ 7678169689Skan for (glist = label_context_stack_vm->next->labels_used; 7679169689Skan glist != NULL; 7680169689Skan glist = glist->next) 7681169689Skan { 7682169689Skan C_DECL_UNDEFINABLE_VM (glist->label) = 0; 7683169689Skan glist_prev = glist; 7684169689Skan } 7685169689Skan if (glist_prev != NULL) 7686169689Skan glist_prev->next = label_context_stack_vm->labels_used; 7687169689Skan else 7688169689Skan label_context_stack_vm->next->labels_used 7689169689Skan = label_context_stack_vm->labels_used; 7690169689Skan label_context_stack_vm = label_context_stack_vm->next; 7691169689Skan } 7692169689Skan} 7693169689Skan 7694169689Skan/* Begin and end compound statements. This is as simple as pushing 7695169689Skan and popping new statement lists from the tree. */ 7696169689Skan 7697169689Skantree 7698169689Skanc_begin_compound_stmt (bool do_scope) 7699169689Skan{ 7700169689Skan tree stmt = push_stmt_list (); 7701169689Skan if (do_scope) 7702169689Skan push_scope (); 7703169689Skan return stmt; 7704169689Skan} 7705169689Skan 7706169689Skantree 7707169689Skanc_end_compound_stmt (tree stmt, bool do_scope) 7708169689Skan{ 7709169689Skan tree block = NULL; 7710169689Skan 7711169689Skan if (do_scope) 7712169689Skan { 7713169689Skan if (c_dialect_objc ()) 7714169689Skan objc_clear_super_receiver (); 7715169689Skan block = pop_scope (); 7716169689Skan } 7717169689Skan 7718169689Skan stmt = pop_stmt_list (stmt); 7719169689Skan stmt = c_build_bind_expr (block, stmt); 7720169689Skan 7721169689Skan /* If this compound statement is nested immediately inside a statement 7722169689Skan expression, then force a BIND_EXPR to be created. Otherwise we'll 7723169689Skan do the wrong thing for ({ { 1; } }) or ({ 1; { } }). In particular, 7724169689Skan STATEMENT_LISTs merge, and thus we can lose track of what statement 7725169689Skan was really last. */ 7726169689Skan if (cur_stmt_list 7727169689Skan && STATEMENT_LIST_STMT_EXPR (cur_stmt_list) 7728169689Skan && TREE_CODE (stmt) != BIND_EXPR) 7729169689Skan { 7730169689Skan stmt = build3 (BIND_EXPR, void_type_node, NULL, stmt, NULL); 7731169689Skan TREE_SIDE_EFFECTS (stmt) = 1; 7732169689Skan } 7733169689Skan 7734169689Skan return stmt; 7735169689Skan} 7736169689Skan 7737169689Skan/* Queue a cleanup. CLEANUP is an expression/statement to be executed 7738169689Skan when the current scope is exited. EH_ONLY is true when this is not 7739169689Skan meant to apply to normal control flow transfer. */ 7740169689Skan 7741169689Skanvoid 7742169689Skanpush_cleanup (tree ARG_UNUSED (decl), tree cleanup, bool eh_only) 7743169689Skan{ 7744169689Skan enum tree_code code; 7745169689Skan tree stmt, list; 7746169689Skan bool stmt_expr; 7747169689Skan 7748169689Skan code = eh_only ? TRY_CATCH_EXPR : TRY_FINALLY_EXPR; 7749169689Skan stmt = build_stmt (code, NULL, cleanup); 7750169689Skan add_stmt (stmt); 7751169689Skan stmt_expr = STATEMENT_LIST_STMT_EXPR (cur_stmt_list); 7752169689Skan list = push_stmt_list (); 7753169689Skan TREE_OPERAND (stmt, 0) = list; 7754169689Skan STATEMENT_LIST_STMT_EXPR (list) = stmt_expr; 7755169689Skan} 7756169689Skan 7757132718Skan/* Build a binary-operation expression without default conversions. 7758132718Skan CODE is the kind of expression to build. 7759132718Skan This function differs from `build' in several ways: 7760132718Skan the data type of the result is computed and recorded in it, 7761132718Skan warnings are generated if arg data types are invalid, 7762132718Skan special handling for addition and subtraction of pointers is known, 7763132718Skan and some optimization is done (operations on narrow ints 7764132718Skan are done in the narrower type when that gives the same result). 7765132718Skan Constant folding is also done before the result is returned. 7766132718Skan 7767132718Skan Note that the operands will never have enumeral types, or function 7768132718Skan or array types, because either they will have the default conversions 7769132718Skan performed or they have both just been converted to some other type in which 7770132718Skan the arithmetic is to be done. */ 7771132718Skan 7772132718Skantree 7773132718Skanbuild_binary_op (enum tree_code code, tree orig_op0, tree orig_op1, 7774132718Skan int convert_p) 7775132718Skan{ 7776132718Skan tree type0, type1; 7777132718Skan enum tree_code code0, code1; 7778132718Skan tree op0, op1; 7779169689Skan const char *invalid_op_diag; 7780132718Skan 7781132718Skan /* Expression code to give to the expression when it is built. 7782132718Skan Normally this is CODE, which is what the caller asked for, 7783132718Skan but in some special cases we change it. */ 7784132718Skan enum tree_code resultcode = code; 7785132718Skan 7786132718Skan /* Data type in which the computation is to be performed. 7787132718Skan In the simplest cases this is the common type of the arguments. */ 7788132718Skan tree result_type = NULL; 7789132718Skan 7790132718Skan /* Nonzero means operands have already been type-converted 7791132718Skan in whatever way is necessary. 7792132718Skan Zero means they need to be converted to RESULT_TYPE. */ 7793132718Skan int converted = 0; 7794132718Skan 7795132718Skan /* Nonzero means create the expression with this type, rather than 7796132718Skan RESULT_TYPE. */ 7797132718Skan tree build_type = 0; 7798132718Skan 7799132718Skan /* Nonzero means after finally constructing the expression 7800132718Skan convert it to this type. */ 7801132718Skan tree final_type = 0; 7802132718Skan 7803132718Skan /* Nonzero if this is an operation like MIN or MAX which can 7804132718Skan safely be computed in short if both args are promoted shorts. 7805132718Skan Also implies COMMON. 7806132718Skan -1 indicates a bitwise operation; this makes a difference 7807132718Skan in the exact conditions for when it is safe to do the operation 7808132718Skan in a narrower mode. */ 7809132718Skan int shorten = 0; 7810132718Skan 7811132718Skan /* Nonzero if this is a comparison operation; 7812132718Skan if both args are promoted shorts, compare the original shorts. 7813132718Skan Also implies COMMON. */ 7814132718Skan int short_compare = 0; 7815132718Skan 7816132718Skan /* Nonzero if this is a right-shift operation, which can be computed on the 7817132718Skan original short and then promoted if the operand is a promoted short. */ 7818132718Skan int short_shift = 0; 7819132718Skan 7820132718Skan /* Nonzero means set RESULT_TYPE to the common type of the args. */ 7821132718Skan int common = 0; 7822132718Skan 7823169689Skan /* True means types are compatible as far as ObjC is concerned. */ 7824169689Skan bool objc_ok; 7825169689Skan 7826132718Skan if (convert_p) 7827132718Skan { 7828132718Skan op0 = default_conversion (orig_op0); 7829132718Skan op1 = default_conversion (orig_op1); 7830132718Skan } 7831132718Skan else 7832132718Skan { 7833132718Skan op0 = orig_op0; 7834132718Skan op1 = orig_op1; 7835132718Skan } 7836132718Skan 7837132718Skan type0 = TREE_TYPE (op0); 7838132718Skan type1 = TREE_TYPE (op1); 7839132718Skan 7840132718Skan /* The expression codes of the data types of the arguments tell us 7841132718Skan whether the arguments are integers, floating, pointers, etc. */ 7842132718Skan code0 = TREE_CODE (type0); 7843132718Skan code1 = TREE_CODE (type1); 7844132718Skan 7845132718Skan /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue. */ 7846132718Skan STRIP_TYPE_NOPS (op0); 7847132718Skan STRIP_TYPE_NOPS (op1); 7848132718Skan 7849132718Skan /* If an error was already reported for one of the arguments, 7850132718Skan avoid reporting another error. */ 7851132718Skan 7852132718Skan if (code0 == ERROR_MARK || code1 == ERROR_MARK) 7853132718Skan return error_mark_node; 7854132718Skan 7855169689Skan if ((invalid_op_diag 7856169689Skan = targetm.invalid_binary_op (code, type0, type1))) 7857169689Skan { 7858169689Skan error (invalid_op_diag); 7859169689Skan return error_mark_node; 7860169689Skan } 7861169689Skan 7862169689Skan objc_ok = objc_compare_types (type0, type1, -3, NULL_TREE); 7863169689Skan 7864132718Skan switch (code) 7865132718Skan { 7866132718Skan case PLUS_EXPR: 7867132718Skan /* Handle the pointer + int case. */ 7868132718Skan if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 7869132718Skan return pointer_int_sum (PLUS_EXPR, op0, op1); 7870132718Skan else if (code1 == POINTER_TYPE && code0 == INTEGER_TYPE) 7871132718Skan return pointer_int_sum (PLUS_EXPR, op1, op0); 7872132718Skan else 7873132718Skan common = 1; 7874132718Skan break; 7875132718Skan 7876132718Skan case MINUS_EXPR: 7877132718Skan /* Subtraction of two similar pointers. 7878132718Skan We must subtract them as integers, then divide by object size. */ 7879132718Skan if (code0 == POINTER_TYPE && code1 == POINTER_TYPE 7880169689Skan && comp_target_types (type0, type1)) 7881132718Skan return pointer_diff (op0, op1); 7882132718Skan /* Handle pointer minus int. Just like pointer plus int. */ 7883132718Skan else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 7884132718Skan return pointer_int_sum (MINUS_EXPR, op0, op1); 7885132718Skan else 7886132718Skan common = 1; 7887132718Skan break; 7888132718Skan 7889132718Skan case MULT_EXPR: 7890132718Skan common = 1; 7891132718Skan break; 7892132718Skan 7893132718Skan case TRUNC_DIV_EXPR: 7894132718Skan case CEIL_DIV_EXPR: 7895132718Skan case FLOOR_DIV_EXPR: 7896132718Skan case ROUND_DIV_EXPR: 7897132718Skan case EXACT_DIV_EXPR: 7898132718Skan /* Floating point division by zero is a legitimate way to obtain 7899132718Skan infinities and NaNs. */ 7900169689Skan if (skip_evaluation == 0 && integer_zerop (op1)) 7901169689Skan warning (OPT_Wdiv_by_zero, "division by zero"); 7902132718Skan 7903132718Skan if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE 7904132718Skan || code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE) 7905132718Skan && (code1 == INTEGER_TYPE || code1 == REAL_TYPE 7906132718Skan || code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE)) 7907132718Skan { 7908169689Skan enum tree_code tcode0 = code0, tcode1 = code1; 7909169689Skan 7910169689Skan if (code0 == COMPLEX_TYPE || code0 == VECTOR_TYPE) 7911169689Skan tcode0 = TREE_CODE (TREE_TYPE (TREE_TYPE (op0))); 7912169689Skan if (code1 == COMPLEX_TYPE || code1 == VECTOR_TYPE) 7913169689Skan tcode1 = TREE_CODE (TREE_TYPE (TREE_TYPE (op1))); 7914169689Skan 7915169689Skan if (!(tcode0 == INTEGER_TYPE && tcode1 == INTEGER_TYPE)) 7916132718Skan resultcode = RDIV_EXPR; 7917132718Skan else 7918132718Skan /* Although it would be tempting to shorten always here, that 7919132718Skan loses on some targets, since the modulo instruction is 7920132718Skan undefined if the quotient can't be represented in the 7921132718Skan computation mode. We shorten only if unsigned or if 7922132718Skan dividing by something we know != -1. */ 7923169689Skan shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0)) 7924132718Skan || (TREE_CODE (op1) == INTEGER_CST 7925169689Skan && !integer_all_onesp (op1))); 7926132718Skan common = 1; 7927132718Skan } 7928132718Skan break; 7929132718Skan 7930132718Skan case BIT_AND_EXPR: 7931132718Skan case BIT_IOR_EXPR: 7932132718Skan case BIT_XOR_EXPR: 7933132718Skan if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 7934132718Skan shorten = -1; 7935132718Skan else if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE) 7936132718Skan common = 1; 7937132718Skan break; 7938132718Skan 7939132718Skan case TRUNC_MOD_EXPR: 7940132718Skan case FLOOR_MOD_EXPR: 7941169689Skan if (skip_evaluation == 0 && integer_zerop (op1)) 7942169689Skan warning (OPT_Wdiv_by_zero, "division by zero"); 7943132718Skan 7944132718Skan if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 7945132718Skan { 7946132718Skan /* Although it would be tempting to shorten always here, that loses 7947132718Skan on some targets, since the modulo instruction is undefined if the 7948132718Skan quotient can't be represented in the computation mode. We shorten 7949132718Skan only if unsigned or if dividing by something we know != -1. */ 7950169689Skan shorten = (TYPE_UNSIGNED (TREE_TYPE (orig_op0)) 7951132718Skan || (TREE_CODE (op1) == INTEGER_CST 7952169689Skan && !integer_all_onesp (op1))); 7953132718Skan common = 1; 7954132718Skan } 7955132718Skan break; 7956132718Skan 7957132718Skan case TRUTH_ANDIF_EXPR: 7958132718Skan case TRUTH_ORIF_EXPR: 7959132718Skan case TRUTH_AND_EXPR: 7960132718Skan case TRUTH_OR_EXPR: 7961132718Skan case TRUTH_XOR_EXPR: 7962132718Skan if ((code0 == INTEGER_TYPE || code0 == POINTER_TYPE 7963132718Skan || code0 == REAL_TYPE || code0 == COMPLEX_TYPE) 7964132718Skan && (code1 == INTEGER_TYPE || code1 == POINTER_TYPE 7965132718Skan || code1 == REAL_TYPE || code1 == COMPLEX_TYPE)) 7966132718Skan { 7967132718Skan /* Result of these operations is always an int, 7968132718Skan but that does not mean the operands should be 7969132718Skan converted to ints! */ 7970132718Skan result_type = integer_type_node; 7971132718Skan op0 = c_common_truthvalue_conversion (op0); 7972132718Skan op1 = c_common_truthvalue_conversion (op1); 7973132718Skan converted = 1; 7974132718Skan } 7975132718Skan break; 7976132718Skan 7977132718Skan /* Shift operations: result has same type as first operand; 7978132718Skan always convert second operand to int. 7979132718Skan Also set SHORT_SHIFT if shifting rightward. */ 7980132718Skan 7981132718Skan case RSHIFT_EXPR: 7982132718Skan if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 7983132718Skan { 7984132718Skan if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0) 7985132718Skan { 7986132718Skan if (tree_int_cst_sgn (op1) < 0) 7987169689Skan warning (0, "right shift count is negative"); 7988132718Skan else 7989132718Skan { 7990169689Skan if (!integer_zerop (op1)) 7991132718Skan short_shift = 1; 7992132718Skan 7993132718Skan if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0) 7994169689Skan warning (0, "right shift count >= width of type"); 7995132718Skan } 7996132718Skan } 7997132718Skan 7998132718Skan /* Use the type of the value to be shifted. */ 7999132718Skan result_type = type0; 8000132718Skan /* Convert the shift-count to an integer, regardless of size 8001132718Skan of value being shifted. */ 8002132718Skan if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node) 8003132718Skan op1 = convert (integer_type_node, op1); 8004132718Skan /* Avoid converting op1 to result_type later. */ 8005132718Skan converted = 1; 8006132718Skan } 8007132718Skan break; 8008132718Skan 8009132718Skan case LSHIFT_EXPR: 8010132718Skan if (code0 == INTEGER_TYPE && code1 == INTEGER_TYPE) 8011132718Skan { 8012132718Skan if (TREE_CODE (op1) == INTEGER_CST && skip_evaluation == 0) 8013132718Skan { 8014132718Skan if (tree_int_cst_sgn (op1) < 0) 8015169689Skan warning (0, "left shift count is negative"); 8016132718Skan 8017132718Skan else if (compare_tree_int (op1, TYPE_PRECISION (type0)) >= 0) 8018169689Skan warning (0, "left shift count >= width of type"); 8019132718Skan } 8020132718Skan 8021132718Skan /* Use the type of the value to be shifted. */ 8022132718Skan result_type = type0; 8023132718Skan /* Convert the shift-count to an integer, regardless of size 8024132718Skan of value being shifted. */ 8025132718Skan if (TYPE_MAIN_VARIANT (TREE_TYPE (op1)) != integer_type_node) 8026132718Skan op1 = convert (integer_type_node, op1); 8027132718Skan /* Avoid converting op1 to result_type later. */ 8028132718Skan converted = 1; 8029132718Skan } 8030132718Skan break; 8031132718Skan 8032132718Skan case EQ_EXPR: 8033132718Skan case NE_EXPR: 8034169689Skan if (code0 == REAL_TYPE || code1 == REAL_TYPE) 8035169689Skan warning (OPT_Wfloat_equal, 8036169689Skan "comparing floating point with == or != is unsafe"); 8037132718Skan /* Result of comparison is always int, 8038132718Skan but don't convert the args to int! */ 8039132718Skan build_type = integer_type_node; 8040132718Skan if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE 8041132718Skan || code0 == COMPLEX_TYPE) 8042132718Skan && (code1 == INTEGER_TYPE || code1 == REAL_TYPE 8043132718Skan || code1 == COMPLEX_TYPE)) 8044132718Skan short_compare = 1; 8045132718Skan else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE) 8046132718Skan { 8047132718Skan tree tt0 = TREE_TYPE (type0); 8048132718Skan tree tt1 = TREE_TYPE (type1); 8049132718Skan /* Anything compares with void *. void * compares with anything. 8050132718Skan Otherwise, the targets must be compatible 8051132718Skan and both must be object or both incomplete. */ 8052169689Skan if (comp_target_types (type0, type1)) 8053169689Skan result_type = common_pointer_type (type0, type1); 8054132718Skan else if (VOID_TYPE_P (tt0)) 8055132718Skan { 8056132718Skan /* op0 != orig_op0 detects the case of something 8057132718Skan whose value is 0 but which isn't a valid null ptr const. */ 8058169689Skan if (pedantic && !null_pointer_constant_p (orig_op0) 8059132718Skan && TREE_CODE (tt1) == FUNCTION_TYPE) 8060169689Skan pedwarn ("ISO C forbids comparison of %<void *%>" 8061169689Skan " with function pointer"); 8062132718Skan } 8063132718Skan else if (VOID_TYPE_P (tt1)) 8064132718Skan { 8065169689Skan if (pedantic && !null_pointer_constant_p (orig_op1) 8066132718Skan && TREE_CODE (tt0) == FUNCTION_TYPE) 8067169689Skan pedwarn ("ISO C forbids comparison of %<void *%>" 8068169689Skan " with function pointer"); 8069132718Skan } 8070132718Skan else 8071169689Skan /* Avoid warning about the volatile ObjC EH puts on decls. */ 8072169689Skan if (!objc_ok) 8073169689Skan pedwarn ("comparison of distinct pointer types lacks a cast"); 8074132718Skan 8075132718Skan if (result_type == NULL_TREE) 8076132718Skan result_type = ptr_type_node; 8077132718Skan } 8078169689Skan else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1)) 8079169689Skan { 8080169689Skan if (TREE_CODE (op0) == ADDR_EXPR 8081169689Skan && DECL_P (TREE_OPERAND (op0, 0)) 8082169689Skan && (TREE_CODE (TREE_OPERAND (op0, 0)) == PARM_DECL 8083169689Skan || TREE_CODE (TREE_OPERAND (op0, 0)) == LABEL_DECL 8084169689Skan || !DECL_WEAK (TREE_OPERAND (op0, 0)))) 8085169689Skan warning (OPT_Waddress, "the address of %qD will never be NULL", 8086169689Skan TREE_OPERAND (op0, 0)); 8087169689Skan result_type = type0; 8088169689Skan } 8089169689Skan else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0)) 8090169689Skan { 8091169689Skan if (TREE_CODE (op1) == ADDR_EXPR 8092169689Skan && DECL_P (TREE_OPERAND (op1, 0)) 8093169689Skan && (TREE_CODE (TREE_OPERAND (op1, 0)) == PARM_DECL 8094169689Skan || TREE_CODE (TREE_OPERAND (op1, 0)) == LABEL_DECL 8095169689Skan || !DECL_WEAK (TREE_OPERAND (op1, 0)))) 8096169689Skan warning (OPT_Waddress, "the address of %qD will never be NULL", 8097169689Skan TREE_OPERAND (op1, 0)); 8098169689Skan result_type = type1; 8099169689Skan } 8100132718Skan else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 8101132718Skan { 8102132718Skan result_type = type0; 8103132718Skan pedwarn ("comparison between pointer and integer"); 8104132718Skan } 8105132718Skan else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE) 8106132718Skan { 8107132718Skan result_type = type1; 8108132718Skan pedwarn ("comparison between pointer and integer"); 8109132718Skan } 8110132718Skan break; 8111132718Skan 8112132718Skan case LE_EXPR: 8113132718Skan case GE_EXPR: 8114132718Skan case LT_EXPR: 8115132718Skan case GT_EXPR: 8116132718Skan build_type = integer_type_node; 8117132718Skan if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE) 8118132718Skan && (code1 == INTEGER_TYPE || code1 == REAL_TYPE)) 8119132718Skan short_compare = 1; 8120132718Skan else if (code0 == POINTER_TYPE && code1 == POINTER_TYPE) 8121132718Skan { 8122169689Skan if (comp_target_types (type0, type1)) 8123132718Skan { 8124169689Skan result_type = common_pointer_type (type0, type1); 8125132718Skan if (!COMPLETE_TYPE_P (TREE_TYPE (type0)) 8126132718Skan != !COMPLETE_TYPE_P (TREE_TYPE (type1))) 8127132718Skan pedwarn ("comparison of complete and incomplete pointers"); 8128132718Skan else if (pedantic 8129132718Skan && TREE_CODE (TREE_TYPE (type0)) == FUNCTION_TYPE) 8130132718Skan pedwarn ("ISO C forbids ordered comparisons of pointers to functions"); 8131132718Skan } 8132132718Skan else 8133132718Skan { 8134132718Skan result_type = ptr_type_node; 8135132718Skan pedwarn ("comparison of distinct pointer types lacks a cast"); 8136132718Skan } 8137132718Skan } 8138169689Skan else if (code0 == POINTER_TYPE && null_pointer_constant_p (orig_op1)) 8139132718Skan { 8140132718Skan result_type = type0; 8141132718Skan if (pedantic || extra_warnings) 8142132718Skan pedwarn ("ordered comparison of pointer with integer zero"); 8143132718Skan } 8144169689Skan else if (code1 == POINTER_TYPE && null_pointer_constant_p (orig_op0)) 8145132718Skan { 8146132718Skan result_type = type1; 8147132718Skan if (pedantic) 8148132718Skan pedwarn ("ordered comparison of pointer with integer zero"); 8149132718Skan } 8150132718Skan else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE) 8151132718Skan { 8152132718Skan result_type = type0; 8153132718Skan pedwarn ("comparison between pointer and integer"); 8154132718Skan } 8155132718Skan else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE) 8156132718Skan { 8157132718Skan result_type = type1; 8158132718Skan pedwarn ("comparison between pointer and integer"); 8159132718Skan } 8160132718Skan break; 8161132718Skan 8162132718Skan default: 8163169689Skan gcc_unreachable (); 8164132718Skan } 8165132718Skan 8166169689Skan if (code0 == ERROR_MARK || code1 == ERROR_MARK) 8167169689Skan return error_mark_node; 8168169689Skan 8169169689Skan if (code0 == VECTOR_TYPE && code1 == VECTOR_TYPE 8170169689Skan && (!tree_int_cst_equal (TYPE_SIZE (type0), TYPE_SIZE (type1)) 8171169689Skan || !same_scalar_type_ignoring_signedness (TREE_TYPE (type0), 8172169689Skan TREE_TYPE (type1)))) 8173169689Skan { 8174169689Skan binary_op_error (code); 8175169689Skan return error_mark_node; 8176169689Skan } 8177169689Skan 8178132718Skan if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE || code0 == COMPLEX_TYPE 8179132718Skan || code0 == VECTOR_TYPE) 8180132718Skan && 8181132718Skan (code1 == INTEGER_TYPE || code1 == REAL_TYPE || code1 == COMPLEX_TYPE 8182132718Skan || code1 == VECTOR_TYPE)) 8183132718Skan { 8184132718Skan int none_complex = (code0 != COMPLEX_TYPE && code1 != COMPLEX_TYPE); 8185132718Skan 8186132718Skan if (shorten || common || short_compare) 8187169689Skan result_type = c_common_type (type0, type1); 8188132718Skan 8189132718Skan /* For certain operations (which identify themselves by shorten != 0) 8190132718Skan if both args were extended from the same smaller type, 8191132718Skan do the arithmetic in that type and then extend. 8192132718Skan 8193132718Skan shorten !=0 and !=1 indicates a bitwise operation. 8194132718Skan For them, this optimization is safe only if 8195132718Skan both args are zero-extended or both are sign-extended. 8196132718Skan Otherwise, we might change the result. 8197132718Skan Eg, (short)-1 | (unsigned short)-1 is (int)-1 8198132718Skan but calculated in (unsigned short) it would be (unsigned short)-1. */ 8199132718Skan 8200132718Skan if (shorten && none_complex) 8201132718Skan { 8202132718Skan int unsigned0, unsigned1; 8203169689Skan tree arg0, arg1; 8204169689Skan int uns; 8205132718Skan tree type; 8206132718Skan 8207169689Skan /* Cast OP0 and OP1 to RESULT_TYPE. Doing so prevents 8208169689Skan excessive narrowing when we call get_narrower below. For 8209169689Skan example, suppose that OP0 is of unsigned int extended 8210169689Skan from signed char and that RESULT_TYPE is long long int. 8211169689Skan If we explicitly cast OP0 to RESULT_TYPE, OP0 would look 8212169689Skan like 8213169689Skan 8214169689Skan (long long int) (unsigned int) signed_char 8215169689Skan 8216169689Skan which get_narrower would narrow down to 8217169689Skan 8218169689Skan (unsigned int) signed char 8219169689Skan 8220169689Skan If we do not cast OP0 first, get_narrower would return 8221169689Skan signed_char, which is inconsistent with the case of the 8222169689Skan explicit cast. */ 8223169689Skan op0 = convert (result_type, op0); 8224169689Skan op1 = convert (result_type, op1); 8225169689Skan 8226169689Skan arg0 = get_narrower (op0, &unsigned0); 8227169689Skan arg1 = get_narrower (op1, &unsigned1); 8228169689Skan 8229169689Skan /* UNS is 1 if the operation to be done is an unsigned one. */ 8230169689Skan uns = TYPE_UNSIGNED (result_type); 8231169689Skan 8232132718Skan final_type = result_type; 8233132718Skan 8234132718Skan /* Handle the case that OP0 (or OP1) does not *contain* a conversion 8235132718Skan but it *requires* conversion to FINAL_TYPE. */ 8236132718Skan 8237132718Skan if ((TYPE_PRECISION (TREE_TYPE (op0)) 8238132718Skan == TYPE_PRECISION (TREE_TYPE (arg0))) 8239132718Skan && TREE_TYPE (op0) != final_type) 8240169689Skan unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0)); 8241132718Skan if ((TYPE_PRECISION (TREE_TYPE (op1)) 8242132718Skan == TYPE_PRECISION (TREE_TYPE (arg1))) 8243132718Skan && TREE_TYPE (op1) != final_type) 8244169689Skan unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1)); 8245132718Skan 8246132718Skan /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE. */ 8247132718Skan 8248132718Skan /* For bitwise operations, signedness of nominal type 8249132718Skan does not matter. Consider only how operands were extended. */ 8250132718Skan if (shorten == -1) 8251132718Skan uns = unsigned0; 8252132718Skan 8253132718Skan /* Note that in all three cases below we refrain from optimizing 8254132718Skan an unsigned operation on sign-extended args. 8255132718Skan That would not be valid. */ 8256132718Skan 8257132718Skan /* Both args variable: if both extended in same way 8258132718Skan from same width, do it in that width. 8259132718Skan Do it unsigned if args were zero-extended. */ 8260132718Skan if ((TYPE_PRECISION (TREE_TYPE (arg0)) 8261132718Skan < TYPE_PRECISION (result_type)) 8262132718Skan && (TYPE_PRECISION (TREE_TYPE (arg1)) 8263132718Skan == TYPE_PRECISION (TREE_TYPE (arg0))) 8264132718Skan && unsigned0 == unsigned1 8265132718Skan && (unsigned0 || !uns)) 8266132718Skan result_type 8267132718Skan = c_common_signed_or_unsigned_type 8268132718Skan (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1))); 8269132718Skan else if (TREE_CODE (arg0) == INTEGER_CST 8270132718Skan && (unsigned1 || !uns) 8271132718Skan && (TYPE_PRECISION (TREE_TYPE (arg1)) 8272132718Skan < TYPE_PRECISION (result_type)) 8273132718Skan && (type 8274132718Skan = c_common_signed_or_unsigned_type (unsigned1, 8275132718Skan TREE_TYPE (arg1)), 8276132718Skan int_fits_type_p (arg0, type))) 8277132718Skan result_type = type; 8278132718Skan else if (TREE_CODE (arg1) == INTEGER_CST 8279132718Skan && (unsigned0 || !uns) 8280132718Skan && (TYPE_PRECISION (TREE_TYPE (arg0)) 8281132718Skan < TYPE_PRECISION (result_type)) 8282132718Skan && (type 8283132718Skan = c_common_signed_or_unsigned_type (unsigned0, 8284132718Skan TREE_TYPE (arg0)), 8285132718Skan int_fits_type_p (arg1, type))) 8286132718Skan result_type = type; 8287132718Skan } 8288132718Skan 8289132718Skan /* Shifts can be shortened if shifting right. */ 8290132718Skan 8291132718Skan if (short_shift) 8292132718Skan { 8293132718Skan int unsigned_arg; 8294132718Skan tree arg0 = get_narrower (op0, &unsigned_arg); 8295132718Skan 8296132718Skan final_type = result_type; 8297132718Skan 8298132718Skan if (arg0 == op0 && final_type == TREE_TYPE (op0)) 8299169689Skan unsigned_arg = TYPE_UNSIGNED (TREE_TYPE (op0)); 8300132718Skan 8301132718Skan if (TYPE_PRECISION (TREE_TYPE (arg0)) < TYPE_PRECISION (result_type) 8302132718Skan /* We can shorten only if the shift count is less than the 8303132718Skan number of bits in the smaller type size. */ 8304132718Skan && compare_tree_int (op1, TYPE_PRECISION (TREE_TYPE (arg0))) < 0 8305132718Skan /* We cannot drop an unsigned shift after sign-extension. */ 8306169689Skan && (!TYPE_UNSIGNED (final_type) || unsigned_arg)) 8307132718Skan { 8308132718Skan /* Do an unsigned shift if the operand was zero-extended. */ 8309132718Skan result_type 8310132718Skan = c_common_signed_or_unsigned_type (unsigned_arg, 8311132718Skan TREE_TYPE (arg0)); 8312132718Skan /* Convert value-to-be-shifted to that type. */ 8313132718Skan if (TREE_TYPE (op0) != result_type) 8314132718Skan op0 = convert (result_type, op0); 8315132718Skan converted = 1; 8316132718Skan } 8317132718Skan } 8318132718Skan 8319132718Skan /* Comparison operations are shortened too but differently. 8320132718Skan They identify themselves by setting short_compare = 1. */ 8321132718Skan 8322132718Skan if (short_compare) 8323132718Skan { 8324132718Skan /* Don't write &op0, etc., because that would prevent op0 8325132718Skan from being kept in a register. 8326132718Skan Instead, make copies of the our local variables and 8327132718Skan pass the copies by reference, then copy them back afterward. */ 8328132718Skan tree xop0 = op0, xop1 = op1, xresult_type = result_type; 8329132718Skan enum tree_code xresultcode = resultcode; 8330132718Skan tree val 8331132718Skan = shorten_compare (&xop0, &xop1, &xresult_type, &xresultcode); 8332132718Skan 8333132718Skan if (val != 0) 8334132718Skan return val; 8335132718Skan 8336132718Skan op0 = xop0, op1 = xop1; 8337132718Skan converted = 1; 8338132718Skan resultcode = xresultcode; 8339132718Skan 8340132718Skan if (warn_sign_compare && skip_evaluation == 0) 8341132718Skan { 8342169689Skan int op0_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op0)); 8343169689Skan int op1_signed = !TYPE_UNSIGNED (TREE_TYPE (orig_op1)); 8344132718Skan int unsignedp0, unsignedp1; 8345132718Skan tree primop0 = get_narrower (op0, &unsignedp0); 8346132718Skan tree primop1 = get_narrower (op1, &unsignedp1); 8347132718Skan 8348132718Skan xop0 = orig_op0; 8349132718Skan xop1 = orig_op1; 8350132718Skan STRIP_TYPE_NOPS (xop0); 8351132718Skan STRIP_TYPE_NOPS (xop1); 8352132718Skan 8353132718Skan /* Give warnings for comparisons between signed and unsigned 8354132718Skan quantities that may fail. 8355132718Skan 8356132718Skan Do the checking based on the original operand trees, so that 8357132718Skan casts will be considered, but default promotions won't be. 8358132718Skan 8359132718Skan Do not warn if the comparison is being done in a signed type, 8360132718Skan since the signed type will only be chosen if it can represent 8361132718Skan all the values of the unsigned type. */ 8362169689Skan if (!TYPE_UNSIGNED (result_type)) 8363132718Skan /* OK */; 8364169689Skan /* Do not warn if both operands are the same signedness. */ 8365169689Skan else if (op0_signed == op1_signed) 8366169689Skan /* OK */; 8367132718Skan else 8368132718Skan { 8369132718Skan tree sop, uop; 8370169689Skan bool ovf; 8371132718Skan 8372132718Skan if (op0_signed) 8373132718Skan sop = xop0, uop = xop1; 8374132718Skan else 8375132718Skan sop = xop1, uop = xop0; 8376132718Skan 8377132718Skan /* Do not warn if the signed quantity is an 8378132718Skan unsuffixed integer literal (or some static 8379132718Skan constant expression involving such literals or a 8380132718Skan conditional expression involving such literals) 8381132718Skan and it is non-negative. */ 8382169689Skan if (tree_expr_nonnegative_warnv_p (sop, &ovf)) 8383132718Skan /* OK */; 8384132718Skan /* Do not warn if the comparison is an equality operation, 8385132718Skan the unsigned quantity is an integral constant, and it 8386132718Skan would fit in the result if the result were signed. */ 8387132718Skan else if (TREE_CODE (uop) == INTEGER_CST 8388132718Skan && (resultcode == EQ_EXPR || resultcode == NE_EXPR) 8389132718Skan && int_fits_type_p 8390132718Skan (uop, c_common_signed_type (result_type))) 8391132718Skan /* OK */; 8392132718Skan /* Do not warn if the unsigned quantity is an enumeration 8393132718Skan constant and its maximum value would fit in the result 8394132718Skan if the result were signed. */ 8395132718Skan else if (TREE_CODE (uop) == INTEGER_CST 8396132718Skan && TREE_CODE (TREE_TYPE (uop)) == ENUMERAL_TYPE 8397132718Skan && int_fits_type_p 8398169689Skan (TYPE_MAX_VALUE (TREE_TYPE (uop)), 8399132718Skan c_common_signed_type (result_type))) 8400132718Skan /* OK */; 8401132718Skan else 8402169689Skan warning (0, "comparison between signed and unsigned"); 8403132718Skan } 8404132718Skan 8405132718Skan /* Warn if two unsigned values are being compared in a size 8406132718Skan larger than their original size, and one (and only one) is the 8407132718Skan result of a `~' operator. This comparison will always fail. 8408132718Skan 8409132718Skan Also warn if one operand is a constant, and the constant 8410132718Skan does not have all bits set that are set in the ~ operand 8411132718Skan when it is extended. */ 8412132718Skan 8413132718Skan if ((TREE_CODE (primop0) == BIT_NOT_EXPR) 8414132718Skan != (TREE_CODE (primop1) == BIT_NOT_EXPR)) 8415132718Skan { 8416132718Skan if (TREE_CODE (primop0) == BIT_NOT_EXPR) 8417132718Skan primop0 = get_narrower (TREE_OPERAND (primop0, 0), 8418132718Skan &unsignedp0); 8419132718Skan else 8420132718Skan primop1 = get_narrower (TREE_OPERAND (primop1, 0), 8421132718Skan &unsignedp1); 8422132718Skan 8423132718Skan if (host_integerp (primop0, 0) || host_integerp (primop1, 0)) 8424132718Skan { 8425132718Skan tree primop; 8426132718Skan HOST_WIDE_INT constant, mask; 8427132718Skan int unsignedp, bits; 8428132718Skan 8429132718Skan if (host_integerp (primop0, 0)) 8430132718Skan { 8431132718Skan primop = primop1; 8432132718Skan unsignedp = unsignedp1; 8433132718Skan constant = tree_low_cst (primop0, 0); 8434132718Skan } 8435132718Skan else 8436132718Skan { 8437132718Skan primop = primop0; 8438132718Skan unsignedp = unsignedp0; 8439132718Skan constant = tree_low_cst (primop1, 0); 8440132718Skan } 8441132718Skan 8442132718Skan bits = TYPE_PRECISION (TREE_TYPE (primop)); 8443132718Skan if (bits < TYPE_PRECISION (result_type) 8444132718Skan && bits < HOST_BITS_PER_WIDE_INT && unsignedp) 8445132718Skan { 8446169689Skan mask = (~(HOST_WIDE_INT) 0) << bits; 8447132718Skan if ((mask & constant) != mask) 8448169689Skan warning (0, "comparison of promoted ~unsigned with constant"); 8449132718Skan } 8450132718Skan } 8451132718Skan else if (unsignedp0 && unsignedp1 8452132718Skan && (TYPE_PRECISION (TREE_TYPE (primop0)) 8453132718Skan < TYPE_PRECISION (result_type)) 8454132718Skan && (TYPE_PRECISION (TREE_TYPE (primop1)) 8455132718Skan < TYPE_PRECISION (result_type))) 8456169689Skan warning (0, "comparison of promoted ~unsigned with unsigned"); 8457132718Skan } 8458132718Skan } 8459132718Skan } 8460132718Skan } 8461132718Skan 8462132718Skan /* At this point, RESULT_TYPE must be nonzero to avoid an error message. 8463132718Skan If CONVERTED is zero, both args will be converted to type RESULT_TYPE. 8464132718Skan Then the expression will be built. 8465132718Skan It will be given type FINAL_TYPE if that is nonzero; 8466132718Skan otherwise, it will be given type RESULT_TYPE. */ 8467132718Skan 8468132718Skan if (!result_type) 8469132718Skan { 8470132718Skan binary_op_error (code); 8471132718Skan return error_mark_node; 8472132718Skan } 8473132718Skan 8474169689Skan if (!converted) 8475132718Skan { 8476132718Skan if (TREE_TYPE (op0) != result_type) 8477169689Skan op0 = convert_and_check (result_type, op0); 8478132718Skan if (TREE_TYPE (op1) != result_type) 8479169689Skan op1 = convert_and_check (result_type, op1); 8480169689Skan 8481169689Skan /* This can happen if one operand has a vector type, and the other 8482169689Skan has a different type. */ 8483169689Skan if (TREE_CODE (op0) == ERROR_MARK || TREE_CODE (op1) == ERROR_MARK) 8484169689Skan return error_mark_node; 8485132718Skan } 8486132718Skan 8487132718Skan if (build_type == NULL_TREE) 8488132718Skan build_type = result_type; 8489132718Skan 8490132718Skan { 8491169689Skan /* Treat expressions in initializers specially as they can't trap. */ 8492169689Skan tree result = require_constant_value ? fold_build2_initializer (resultcode, 8493169689Skan build_type, 8494169689Skan op0, op1) 8495169689Skan : fold_build2 (resultcode, build_type, 8496169689Skan op0, op1); 8497132718Skan 8498132718Skan if (final_type != 0) 8499169689Skan result = convert (final_type, result); 8500169689Skan return result; 8501132718Skan } 8502132718Skan} 8503169689Skan 8504169689Skan 8505169689Skan/* Convert EXPR to be a truth-value, validating its type for this 8506169689Skan purpose. */ 8507169689Skan 8508169689Skantree 8509169689Skanc_objc_common_truthvalue_conversion (tree expr) 8510169689Skan{ 8511169689Skan switch (TREE_CODE (TREE_TYPE (expr))) 8512169689Skan { 8513169689Skan case ARRAY_TYPE: 8514169689Skan error ("used array that cannot be converted to pointer where scalar is required"); 8515169689Skan return error_mark_node; 8516169689Skan 8517169689Skan case RECORD_TYPE: 8518169689Skan error ("used struct type value where scalar is required"); 8519169689Skan return error_mark_node; 8520169689Skan 8521169689Skan case UNION_TYPE: 8522169689Skan error ("used union type value where scalar is required"); 8523169689Skan return error_mark_node; 8524169689Skan 8525169689Skan case FUNCTION_TYPE: 8526169689Skan gcc_unreachable (); 8527169689Skan 8528169689Skan default: 8529169689Skan break; 8530169689Skan } 8531169689Skan 8532169689Skan /* ??? Should we also give an error for void and vectors rather than 8533169689Skan leaving those to give errors later? */ 8534169689Skan return c_common_truthvalue_conversion (expr); 8535169689Skan} 8536169689Skan 8537169689Skan 8538169689Skan/* Convert EXPR to a contained DECL, updating *TC, *TI and *SE as 8539169689Skan required. */ 8540169689Skan 8541169689Skantree 8542169689Skanc_expr_to_decl (tree expr, bool *tc ATTRIBUTE_UNUSED, 8543169689Skan bool *ti ATTRIBUTE_UNUSED, bool *se) 8544169689Skan{ 8545169689Skan if (TREE_CODE (expr) == COMPOUND_LITERAL_EXPR) 8546169689Skan { 8547169689Skan tree decl = COMPOUND_LITERAL_EXPR_DECL (expr); 8548169689Skan /* Executing a compound literal inside a function reinitializes 8549169689Skan it. */ 8550169689Skan if (!TREE_STATIC (decl)) 8551169689Skan *se = true; 8552169689Skan return decl; 8553169689Skan } 8554169689Skan else 8555169689Skan return expr; 8556169689Skan} 8557169689Skan 8558169689Skan/* Like c_begin_compound_stmt, except force the retention of the BLOCK. */ 8559169689Skan 8560169689Skantree 8561169689Skanc_begin_omp_parallel (void) 8562169689Skan{ 8563169689Skan tree block; 8564169689Skan 8565169689Skan keep_next_level (); 8566169689Skan block = c_begin_compound_stmt (true); 8567169689Skan 8568169689Skan return block; 8569169689Skan} 8570169689Skan 8571169689Skantree 8572169689Skanc_finish_omp_parallel (tree clauses, tree block) 8573169689Skan{ 8574169689Skan tree stmt; 8575169689Skan 8576169689Skan block = c_end_compound_stmt (block, true); 8577169689Skan 8578169689Skan stmt = make_node (OMP_PARALLEL); 8579169689Skan TREE_TYPE (stmt) = void_type_node; 8580169689Skan OMP_PARALLEL_CLAUSES (stmt) = clauses; 8581169689Skan OMP_PARALLEL_BODY (stmt) = block; 8582169689Skan 8583169689Skan return add_stmt (stmt); 8584169689Skan} 8585169689Skan 8586169689Skan/* For all elements of CLAUSES, validate them vs OpenMP constraints. 8587169689Skan Remove any elements from the list that are invalid. */ 8588169689Skan 8589169689Skantree 8590169689Skanc_finish_omp_clauses (tree clauses) 8591169689Skan{ 8592169689Skan bitmap_head generic_head, firstprivate_head, lastprivate_head; 8593169689Skan tree c, t, *pc = &clauses; 8594169689Skan const char *name; 8595169689Skan 8596169689Skan bitmap_obstack_initialize (NULL); 8597169689Skan bitmap_initialize (&generic_head, &bitmap_default_obstack); 8598169689Skan bitmap_initialize (&firstprivate_head, &bitmap_default_obstack); 8599169689Skan bitmap_initialize (&lastprivate_head, &bitmap_default_obstack); 8600169689Skan 8601169689Skan for (pc = &clauses, c = clauses; c ; c = *pc) 8602169689Skan { 8603169689Skan bool remove = false; 8604169689Skan bool need_complete = false; 8605169689Skan bool need_implicitly_determined = false; 8606169689Skan 8607169689Skan switch (OMP_CLAUSE_CODE (c)) 8608169689Skan { 8609169689Skan case OMP_CLAUSE_SHARED: 8610169689Skan name = "shared"; 8611169689Skan need_implicitly_determined = true; 8612169689Skan goto check_dup_generic; 8613169689Skan 8614169689Skan case OMP_CLAUSE_PRIVATE: 8615169689Skan name = "private"; 8616169689Skan need_complete = true; 8617169689Skan need_implicitly_determined = true; 8618169689Skan goto check_dup_generic; 8619169689Skan 8620169689Skan case OMP_CLAUSE_REDUCTION: 8621169689Skan name = "reduction"; 8622169689Skan need_implicitly_determined = true; 8623169689Skan t = OMP_CLAUSE_DECL (c); 8624169689Skan if (AGGREGATE_TYPE_P (TREE_TYPE (t)) 8625169689Skan || POINTER_TYPE_P (TREE_TYPE (t))) 8626169689Skan { 8627169689Skan error ("%qE has invalid type for %<reduction%>", t); 8628169689Skan remove = true; 8629169689Skan } 8630169689Skan else if (FLOAT_TYPE_P (TREE_TYPE (t))) 8631169689Skan { 8632169689Skan enum tree_code r_code = OMP_CLAUSE_REDUCTION_CODE (c); 8633169689Skan const char *r_name = NULL; 8634169689Skan 8635169689Skan switch (r_code) 8636169689Skan { 8637169689Skan case PLUS_EXPR: 8638169689Skan case MULT_EXPR: 8639169689Skan case MINUS_EXPR: 8640169689Skan break; 8641169689Skan case BIT_AND_EXPR: 8642169689Skan r_name = "&"; 8643169689Skan break; 8644169689Skan case BIT_XOR_EXPR: 8645169689Skan r_name = "^"; 8646169689Skan break; 8647169689Skan case BIT_IOR_EXPR: 8648169689Skan r_name = "|"; 8649169689Skan break; 8650169689Skan case TRUTH_ANDIF_EXPR: 8651169689Skan r_name = "&&"; 8652169689Skan break; 8653169689Skan case TRUTH_ORIF_EXPR: 8654169689Skan r_name = "||"; 8655169689Skan break; 8656169689Skan default: 8657169689Skan gcc_unreachable (); 8658169689Skan } 8659169689Skan if (r_name) 8660169689Skan { 8661169689Skan error ("%qE has invalid type for %<reduction(%s)%>", 8662169689Skan t, r_name); 8663169689Skan remove = true; 8664169689Skan } 8665169689Skan } 8666169689Skan goto check_dup_generic; 8667169689Skan 8668169689Skan case OMP_CLAUSE_COPYPRIVATE: 8669169689Skan name = "copyprivate"; 8670169689Skan goto check_dup_generic; 8671169689Skan 8672169689Skan case OMP_CLAUSE_COPYIN: 8673169689Skan name = "copyin"; 8674169689Skan t = OMP_CLAUSE_DECL (c); 8675169689Skan if (TREE_CODE (t) != VAR_DECL || !DECL_THREAD_LOCAL_P (t)) 8676169689Skan { 8677169689Skan error ("%qE must be %<threadprivate%> for %<copyin%>", t); 8678169689Skan remove = true; 8679169689Skan } 8680169689Skan goto check_dup_generic; 8681169689Skan 8682169689Skan check_dup_generic: 8683169689Skan t = OMP_CLAUSE_DECL (c); 8684169689Skan if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL) 8685169689Skan { 8686169689Skan error ("%qE is not a variable in clause %qs", t, name); 8687169689Skan remove = true; 8688169689Skan } 8689169689Skan else if (bitmap_bit_p (&generic_head, DECL_UID (t)) 8690169689Skan || bitmap_bit_p (&firstprivate_head, DECL_UID (t)) 8691169689Skan || bitmap_bit_p (&lastprivate_head, DECL_UID (t))) 8692169689Skan { 8693169689Skan error ("%qE appears more than once in data clauses", t); 8694169689Skan remove = true; 8695169689Skan } 8696169689Skan else 8697169689Skan bitmap_set_bit (&generic_head, DECL_UID (t)); 8698169689Skan break; 8699169689Skan 8700169689Skan case OMP_CLAUSE_FIRSTPRIVATE: 8701169689Skan name = "firstprivate"; 8702169689Skan t = OMP_CLAUSE_DECL (c); 8703169689Skan need_complete = true; 8704169689Skan need_implicitly_determined = true; 8705169689Skan if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL) 8706169689Skan { 8707169689Skan error ("%qE is not a variable in clause %<firstprivate%>", t); 8708169689Skan remove = true; 8709169689Skan } 8710169689Skan else if (bitmap_bit_p (&generic_head, DECL_UID (t)) 8711169689Skan || bitmap_bit_p (&firstprivate_head, DECL_UID (t))) 8712169689Skan { 8713169689Skan error ("%qE appears more than once in data clauses", t); 8714169689Skan remove = true; 8715169689Skan } 8716169689Skan else 8717169689Skan bitmap_set_bit (&firstprivate_head, DECL_UID (t)); 8718169689Skan break; 8719169689Skan 8720169689Skan case OMP_CLAUSE_LASTPRIVATE: 8721169689Skan name = "lastprivate"; 8722169689Skan t = OMP_CLAUSE_DECL (c); 8723169689Skan need_complete = true; 8724169689Skan need_implicitly_determined = true; 8725169689Skan if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != PARM_DECL) 8726169689Skan { 8727169689Skan error ("%qE is not a variable in clause %<lastprivate%>", t); 8728169689Skan remove = true; 8729169689Skan } 8730169689Skan else if (bitmap_bit_p (&generic_head, DECL_UID (t)) 8731169689Skan || bitmap_bit_p (&lastprivate_head, DECL_UID (t))) 8732169689Skan { 8733169689Skan error ("%qE appears more than once in data clauses", t); 8734169689Skan remove = true; 8735169689Skan } 8736169689Skan else 8737169689Skan bitmap_set_bit (&lastprivate_head, DECL_UID (t)); 8738169689Skan break; 8739169689Skan 8740169689Skan case OMP_CLAUSE_IF: 8741169689Skan case OMP_CLAUSE_NUM_THREADS: 8742169689Skan case OMP_CLAUSE_SCHEDULE: 8743169689Skan case OMP_CLAUSE_NOWAIT: 8744169689Skan case OMP_CLAUSE_ORDERED: 8745169689Skan case OMP_CLAUSE_DEFAULT: 8746169689Skan pc = &OMP_CLAUSE_CHAIN (c); 8747169689Skan continue; 8748169689Skan 8749169689Skan default: 8750169689Skan gcc_unreachable (); 8751169689Skan } 8752169689Skan 8753169689Skan if (!remove) 8754169689Skan { 8755169689Skan t = OMP_CLAUSE_DECL (c); 8756169689Skan 8757169689Skan if (need_complete) 8758169689Skan { 8759169689Skan t = require_complete_type (t); 8760169689Skan if (t == error_mark_node) 8761169689Skan remove = true; 8762169689Skan } 8763169689Skan 8764169689Skan if (need_implicitly_determined) 8765169689Skan { 8766169689Skan const char *share_name = NULL; 8767169689Skan 8768169689Skan if (TREE_CODE (t) == VAR_DECL && DECL_THREAD_LOCAL_P (t)) 8769169689Skan share_name = "threadprivate"; 8770169689Skan else switch (c_omp_predetermined_sharing (t)) 8771169689Skan { 8772169689Skan case OMP_CLAUSE_DEFAULT_UNSPECIFIED: 8773169689Skan break; 8774169689Skan case OMP_CLAUSE_DEFAULT_SHARED: 8775169689Skan share_name = "shared"; 8776169689Skan break; 8777169689Skan case OMP_CLAUSE_DEFAULT_PRIVATE: 8778169689Skan share_name = "private"; 8779169689Skan break; 8780169689Skan default: 8781169689Skan gcc_unreachable (); 8782169689Skan } 8783169689Skan if (share_name) 8784169689Skan { 8785169689Skan error ("%qE is predetermined %qs for %qs", 8786169689Skan t, share_name, name); 8787169689Skan remove = true; 8788169689Skan } 8789169689Skan } 8790169689Skan } 8791169689Skan 8792169689Skan if (remove) 8793169689Skan *pc = OMP_CLAUSE_CHAIN (c); 8794169689Skan else 8795169689Skan pc = &OMP_CLAUSE_CHAIN (c); 8796169689Skan } 8797169689Skan 8798169689Skan bitmap_obstack_release (NULL); 8799169689Skan return clauses; 8800169689Skan} 8801