1/* Header file for gimple decl, type and expressions. 2 Copyright (C) 2013-2015 Free Software Foundation, Inc. 3 4This file is part of GCC. 5 6GCC is free software; you can redistribute it and/or modify it under 7the terms of the GNU General Public License as published by the Free 8Software Foundation; either version 3, or (at your option) any later 9version. 10 11GCC is distributed in the hope that it will be useful, but WITHOUT ANY 12WARRANTY; without even the implied warranty of MERCHANTABILITY or 13FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 for more details. 15 16You should have received a copy of the GNU General Public License 17along with GCC; see the file COPYING3. If not see 18<http://www.gnu.org/licenses/>. */ 19 20#ifndef GCC_GIMPLE_EXPR_H 21#define GCC_GIMPLE_EXPR_H 22 23extern bool useless_type_conversion_p (tree, tree); 24 25 26extern void gimple_set_body (tree, gimple_seq); 27extern gimple_seq gimple_body (tree); 28extern bool gimple_has_body_p (tree); 29extern const char *gimple_decl_printable_name (tree, int); 30extern tree copy_var_decl (tree, tree, tree); 31extern bool gimple_can_coalesce_p (tree, tree); 32extern tree create_tmp_var_name (const char *); 33extern tree create_tmp_var_raw (tree, const char * = NULL); 34extern tree create_tmp_var (tree, const char * = NULL); 35extern tree create_tmp_reg (tree, const char * = NULL); 36extern tree create_tmp_reg_fn (struct function *, tree, const char *); 37 38 39extern void extract_ops_from_tree (tree, enum tree_code *, tree *, tree *, 40 tree *); 41extern void gimple_cond_get_ops_from_tree (tree, enum tree_code *, tree *, 42 tree *); 43extern bool is_gimple_lvalue (tree); 44extern bool is_gimple_condexpr (tree); 45extern bool is_gimple_address (const_tree); 46extern bool is_gimple_invariant_address (const_tree); 47extern bool is_gimple_ip_invariant_address (const_tree); 48extern bool is_gimple_min_invariant (const_tree); 49extern bool is_gimple_ip_invariant (const_tree); 50extern bool is_gimple_reg (tree); 51extern bool is_gimple_val (tree); 52extern bool is_gimple_asm_val (tree); 53extern bool is_gimple_min_lval (tree); 54extern bool is_gimple_call_addr (tree); 55extern bool is_gimple_mem_ref_addr (tree); 56extern void mark_addressable (tree); 57extern bool is_gimple_reg_rhs (tree); 58 59/* Return true if a conversion from either type of TYPE1 and TYPE2 60 to the other is not required. Otherwise return false. */ 61 62static inline bool 63types_compatible_p (tree type1, tree type2) 64{ 65 return (type1 == type2 66 || (useless_type_conversion_p (type1, type2) 67 && useless_type_conversion_p (type2, type1))); 68} 69 70/* Return true if TYPE is a suitable type for a scalar register variable. */ 71 72static inline bool 73is_gimple_reg_type (tree type) 74{ 75 return !AGGREGATE_TYPE_P (type); 76} 77 78/* Return true if T is a variable. */ 79 80static inline bool 81is_gimple_variable (tree t) 82{ 83 return (TREE_CODE (t) == VAR_DECL 84 || TREE_CODE (t) == PARM_DECL 85 || TREE_CODE (t) == RESULT_DECL 86 || TREE_CODE (t) == SSA_NAME); 87} 88 89/* Return true if T is a GIMPLE identifier (something with an address). */ 90 91static inline bool 92is_gimple_id (tree t) 93{ 94 return (is_gimple_variable (t) 95 || TREE_CODE (t) == FUNCTION_DECL 96 || TREE_CODE (t) == LABEL_DECL 97 || TREE_CODE (t) == CONST_DECL 98 /* Allow string constants, since they are addressable. */ 99 || TREE_CODE (t) == STRING_CST); 100} 101 102/* Return true if OP, an SSA name or a DECL is a virtual operand. */ 103 104static inline bool 105virtual_operand_p (tree op) 106{ 107 if (TREE_CODE (op) == SSA_NAME) 108 { 109 op = SSA_NAME_VAR (op); 110 if (!op) 111 return false; 112 } 113 114 if (TREE_CODE (op) == VAR_DECL) 115 return VAR_DECL_IS_VIRTUAL_OPERAND (op); 116 117 return false; 118} 119 120/* Return true if T is something whose address can be taken. */ 121 122static inline bool 123is_gimple_addressable (tree t) 124{ 125 return (is_gimple_id (t) || handled_component_p (t) 126 || TREE_CODE (t) == MEM_REF); 127} 128 129/* Return true if T is a valid gimple constant. */ 130 131static inline bool 132is_gimple_constant (const_tree t) 133{ 134 switch (TREE_CODE (t)) 135 { 136 case INTEGER_CST: 137 case REAL_CST: 138 case FIXED_CST: 139 case STRING_CST: 140 case COMPLEX_CST: 141 case VECTOR_CST: 142 return true; 143 144 default: 145 return false; 146 } 147} 148 149/* A wrapper around extract_ops_from_tree with 3 ops, for callers which 150 expect to see only a maximum of two operands. */ 151 152static inline void 153extract_ops_from_tree (tree expr, enum tree_code *code, tree *op0, 154 tree *op1) 155{ 156 tree op2; 157 extract_ops_from_tree (expr, code, op0, op1, &op2); 158 gcc_assert (op2 == NULL_TREE); 159} 160 161/* Given a valid GIMPLE_CALL function address return the FUNCTION_DECL 162 associated with the callee if known. Otherwise return NULL_TREE. */ 163 164static inline tree 165gimple_call_addr_fndecl (const_tree fn) 166{ 167 if (fn && TREE_CODE (fn) == ADDR_EXPR) 168 { 169 tree fndecl = TREE_OPERAND (fn, 0); 170 if (TREE_CODE (fndecl) == MEM_REF 171 && TREE_CODE (TREE_OPERAND (fndecl, 0)) == ADDR_EXPR 172 && integer_zerop (TREE_OPERAND (fndecl, 1))) 173 fndecl = TREE_OPERAND (TREE_OPERAND (fndecl, 0), 0); 174 if (TREE_CODE (fndecl) == FUNCTION_DECL) 175 return fndecl; 176 } 177 return NULL_TREE; 178} 179 180#endif /* GCC_GIMPLE_EXPR_H */ 181