1/* Language-level data type conversion for GNU C.
2   Copyright (C) 1987-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
14for 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
21/* This file contains the functions for converting C expressions
22   to different data types.  The only entry point is `convert'.
23   Every language front end must have a `convert' function
24   but what kind of conversions it does will depend on the language.  */
25
26#include "config.h"
27#include "system.h"
28#include "coretypes.h"
29#include "tm.h"
30#include "hash-set.h"
31#include "vec.h"
32#include "symtab.h"
33#include "input.h"
34#include "alias.h"
35#include "double-int.h"
36#include "machmode.h"
37#include "inchash.h"
38#include "tree.h"
39#include "flags.h"
40#include "convert.h"
41#include "c-family/c-common.h"
42#include "c-tree.h"
43#include "langhooks.h"
44#include "target.h"
45#include "ubsan.h"
46
47/* Change of width--truncation and extension of integers or reals--
48   is represented with NOP_EXPR.  Proper functioning of many things
49   assumes that no other conversions can be NOP_EXPRs.
50
51   Conversion between integer and pointer is represented with CONVERT_EXPR.
52   Converting integer to real uses FLOAT_EXPR
53   and real to integer uses FIX_TRUNC_EXPR.
54
55   Here is a list of all the functions that assume that widening and
56   narrowing is always done with a NOP_EXPR:
57     In convert.c, convert_to_integer.
58     In c-typeck.c, build_binary_op (boolean ops), and
59	c_common_truthvalue_conversion.
60     In expr.c: expand_expr, for operands of a MULT_EXPR.
61     In fold-const.c: fold.
62     In tree.c: get_narrower and get_unwidened.  */
63
64/* Subroutines of `convert'.  */
65
66
67
68/* Create an expression whose value is that of EXPR,
69   converted to type TYPE.  The TREE_TYPE of the value
70   is always TYPE.  This function implements all reasonable
71   conversions; callers should filter out those that are
72   not permitted by the language being compiled.  */
73
74tree
75convert (tree type, tree expr)
76{
77  tree e = expr;
78  enum tree_code code = TREE_CODE (type);
79  const char *invalid_conv_diag;
80  tree ret;
81  location_t loc = EXPR_LOCATION (expr);
82
83  if (type == error_mark_node
84      || error_operand_p (expr))
85    return error_mark_node;
86
87  if ((invalid_conv_diag
88       = targetm.invalid_conversion (TREE_TYPE (expr), type)))
89    {
90      error (invalid_conv_diag);
91      return error_mark_node;
92    }
93
94  if (type == TREE_TYPE (expr))
95    return expr;
96  ret = targetm.convert_to_type (type, expr);
97  if (ret)
98      return ret;
99
100  STRIP_TYPE_NOPS (e);
101
102  if (TYPE_MAIN_VARIANT (type) == TYPE_MAIN_VARIANT (TREE_TYPE (expr))
103      && (TREE_CODE (TREE_TYPE (expr)) != COMPLEX_TYPE
104	  || TREE_CODE (e) == COMPLEX_EXPR))
105    return fold_convert_loc (loc, type, expr);
106  if (TREE_CODE (TREE_TYPE (expr)) == ERROR_MARK)
107    return error_mark_node;
108  if (TREE_CODE (TREE_TYPE (expr)) == VOID_TYPE)
109    {
110      error ("void value not ignored as it ought to be");
111      return error_mark_node;
112    }
113
114  switch (code)
115    {
116    case VOID_TYPE:
117      return fold_convert_loc (loc, type, e);
118
119    case INTEGER_TYPE:
120    case ENUMERAL_TYPE:
121      if (flag_sanitize & SANITIZE_FLOAT_CAST
122	  && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE
123	  && COMPLETE_TYPE_P (type)
124	  && do_ubsan_in_current_function ())
125	{
126	  tree arg;
127	  if (in_late_binary_op)
128	    {
129	      expr = save_expr (expr);
130	      arg = expr;
131	    }
132	  else
133	    {
134	      expr = c_save_expr (expr);
135	      arg = c_fully_fold (expr, false, NULL);
136	    }
137	  tree check = ubsan_instrument_float_cast (loc, type, expr, arg);
138	  expr = fold_build1 (FIX_TRUNC_EXPR, type, expr);
139	  if (check == NULL)
140	    return expr;
141	  return fold_build2 (COMPOUND_EXPR, TREE_TYPE (expr), check, expr);
142	}
143      ret = convert_to_integer (type, e);
144      goto maybe_fold;
145
146    case BOOLEAN_TYPE:
147      return fold_convert_loc
148	(loc, type, c_objc_common_truthvalue_conversion (input_location, expr));
149
150    case POINTER_TYPE:
151    case REFERENCE_TYPE:
152      ret = convert_to_pointer (type, e);
153      goto maybe_fold;
154
155    case REAL_TYPE:
156      ret = convert_to_real (type, e);
157      goto maybe_fold;
158
159    case FIXED_POINT_TYPE:
160      ret = convert_to_fixed (type, e);
161      goto maybe_fold;
162
163    case COMPLEX_TYPE:
164      /* If converting from COMPLEX_TYPE to a different COMPLEX_TYPE
165	 and e is not COMPLEX_EXPR, convert_to_complex uses save_expr,
166	 but for the C FE c_save_expr needs to be called instead.  */
167      if (TREE_CODE (TREE_TYPE (e)) == COMPLEX_TYPE)
168	{
169	  if (TREE_CODE (e) != COMPLEX_EXPR)
170	    {
171	      tree subtype = TREE_TYPE (type);
172	      tree elt_type = TREE_TYPE (TREE_TYPE (e));
173
174	      if (in_late_binary_op)
175		e = save_expr (e);
176	      else
177		e = c_save_expr (e);
178	      ret
179		= fold_build2_loc (loc, COMPLEX_EXPR, type,
180				   convert (subtype,
181					    fold_build1 (REALPART_EXPR,
182							 elt_type, e)),
183				   convert (subtype,
184					    fold_build1 (IMAGPART_EXPR,
185							 elt_type, e)));
186	      goto maybe_fold;
187	    }
188	}
189      ret = convert_to_complex (type, e);
190      goto maybe_fold;
191
192    case VECTOR_TYPE:
193      ret = convert_to_vector (type, e);
194      goto maybe_fold;
195
196    case RECORD_TYPE:
197    case UNION_TYPE:
198      if (lang_hooks.types_compatible_p (type, TREE_TYPE (expr)))
199	return e;
200      break;
201
202    default:
203      break;
204
205    maybe_fold:
206      if (TREE_CODE (ret) != C_MAYBE_CONST_EXPR)
207	ret = fold (ret);
208      return ret;
209    }
210
211  error ("conversion to non-scalar type requested");
212  return error_mark_node;
213}
214