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