6935971286

Committed 20 Nov 2023 09:23PM UTC coverage: 91.231% (-0.01%) from 91.244%

Build # 6935971286

Build Type

push

github

Committed by

nickg

Commit Message

Fix wrong result bounds when TO_UNSIGNED is constant folded

Fixes #799

Run Details

31 of 34 new or added lines in 1 file covered. (91.18%)

8 existing lines in 2 files now uncovered.

50705 of 55579 relevant lines covered (91.23%)

607472.84 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

87.44

/src/eval.c

//
//  Copyright (C) 2013-2023  Nick Gasson
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <http://www.gnu.org/licenses/>.
//

#include "util.h"
#include "common.h"
#include "diag.h"
#include "eval.h"
#include "hash.h"
#include "ident.h"
#include "jit/jit.h"
#include "jit/jit-ffi.h"
#include "lib.h"
#include "lower.h"
#include "option.h"
#include "phase.h"
#include "tree.h"
#include "type.h"
#include "vcode.h"

#include <assert.h>
#include <stdint.h>
#include <stdlib.h>
#include <stdarg.h>
#include <inttypes.h>
#include <string.h>

static const char *eval_expr_name(tree_t expr)
{
   const tree_kind_t kind = tree_kind(expr);
   if (kind == T_FCALL)
      return istr(tree_ident(expr));
   else
      return tree_kind_str(kind);
}

static tree_t eval_value_to_tree(jit_scalar_t value, type_t type,
                                 const loc_t *loc)
{
   tree_t tree = NULL;

   if (type_is_enum(type)) {
      type_t base = type_base_recur(type);
      if ((unsigned)value.integer >= type_enum_literals(base))
         fatal_at(loc, "enum position %"PRIi64" out of range for type %s",
                  value.integer, type_pp(base));

      tree_t lit = type_enum_literal(base, value.integer);

      tree = tree_new(T_REF);
      tree_set_ref(tree, lit);
      tree_set_ident(tree, tree_ident(lit));
   }
   else if (type_is_integer(type)) {
      tree = tree_new(T_LITERAL);
      tree_set_subkind(tree, L_INT);
      tree_set_ival(tree, value.integer);
   }
   else if (type_is_real(type)) {
      tree = tree_new(T_LITERAL);
      tree_set_subkind(tree, L_REAL);
      tree_set_dval(tree, value.real);
   }
   else if (type_is_physical(type)) {
      tree = tree_new(T_LITERAL);
      tree_set_subkind(tree, L_PHYSICAL);
      tree_set_ival(tree, value.integer);
   }
   else
      fatal_trace("cannot convert 0x%"PRIx64" to %s", value.integer,
                  type_pp(type));

   tree_set_type(tree, type);
   tree_set_loc(tree, loc);
   return tree;
}

static void *thunk_result_cb(jit_scalar_t *args, void *user)
{
   tree_t expr = user;
   type_t type = tree_type(expr);
   const loc_t *loc = tree_loc(expr);

   if (type_is_array(type)) {
      assert(dimension_of(type) == 1);

      type_t elem = type_elem(type);
      assert(type_is_scalar(elem));

      type_t base = type_base_recur(elem);

      bool all_chars = true;
      tree_t *lits LOCAL = NULL;
      if (type_is_enum(elem)) {
         const int nlits = type_enum_literals(base);
         lits = xcalloc_array(nlits, sizeof(tree_t));
      }
      else
         all_chars = false;

      range_kind_t dir;
      int64_t length, ileft, iright;
      if (!type_const_bounds(type)) {
         length = ffi_array_length(args[2].integer);
         dir = ffi_array_dir(args[2].integer);
         ileft = args[1].integer;
         iright = ffi_array_right(args[1].integer, args[2].integer);
      }
      else {
         tree_t r = range_of(type, 0);
         if (!folded_length(r, &length))
            fatal_at(loc, "cannot determine static length of array");

         dir = tree_subkind(r);
         ileft = assume_int(tree_left(r));
         iright = assume_int(tree_right(r));
      }

      const int bytes = (type_bit_width(elem) + 7) / 8;
      tree_t *elts LOCAL = xmalloc_array(length, sizeof(tree_t));
      for (int i = 0; i < length; i++) {
#define UNPACK_VALUE(type) do {                                    \
            value.integer = ((type *)args[0].pointer)[i];          \
         } while (0);

         jit_scalar_t value = { .integer = 0 };
         FOR_ALL_SIZES(bytes, UNPACK_VALUE);

         if (lits != NULL) {
            assert(value.integer >= 0);

            if (lits[value.integer] == NULL) {
               tree_t li = type_enum_literal(base, value.integer);
               lits[value.integer] = make_ref(li);
               all_chars &= ident_char(tree_ident(li), 0) == '\'';
            }

            elts[i] = lits[value.integer];
         }
         else
            elts[i] = eval_value_to_tree(value, elem, loc);
      }

      type_t sub = type_new(T_SUBTYPE);
      type_set_base(sub, type);

      type_t index_type = index_type_of(type, 0);

      tree_t left = NULL, right = NULL;
      if (type_is_enum(index_type)) {
         left = get_enum_lit(expr, index_type, ileft);
         right = get_enum_lit(expr, index_type, iright);
      }
      else {
         left = get_int_lit(expr, index_type, ileft);
         right = get_int_lit(expr, index_type, iright);
      }

      tree_t r = tree_new(T_RANGE);
      tree_set_subkind(r, dir);
      tree_set_left(r, left);
      tree_set_right(r, right);
      tree_set_loc(r, loc);
      tree_set_type(r, index_type);

      tree_t c = tree_new(T_CONSTRAINT);
      tree_set_subkind(c, C_INDEX);
      tree_add_range(c, r);
      tree_set_loc(c, loc);

      type_add_constraint(sub, c);

      if (all_chars) {
         tree_t tree = tree_new(T_STRING);

         for (int i = 0; i < length; i++)
            tree_add_char(tree, elts[i]);

         tree_set_loc(tree, loc);
         tree_set_type(tree, sub);
         return tree;
      }
      else {
         tree_t tree = tree_new(T_AGGREGATE);
         tree_set_type(tree, sub);
         tree_set_loc(tree, loc);

         for (int i = 0; i < length; i++) {
            tree_t a = tree_new(T_ASSOC);
            tree_set_loc(a, loc);
            tree_set_subkind(a, A_POS);
            tree_set_pos(a, i);
            tree_set_value(a, elts[i]);

            tree_add_assoc(tree, a);
         }

         return tree;
      }
   }
   else
      return eval_value_to_tree(args[0], tree_type(expr), tree_loc(expr));
}

static tree_t eval_do_fold(jit_t *jit, tree_t expr, lower_unit_t *parent,
                           void *context)
{
   vcode_unit_t thunk = lower_thunk(parent, expr);
   if (thunk == NULL)
      return expr;

   const bool verbose = opt_get_verbose(OPT_EVAL_VERBOSE, NULL);

   tree_t result = jit_call_thunk(jit, thunk, context, thunk_result_cb, expr);

   vcode_unit_unref(thunk);
   thunk = NULL;

   if (result != NULL) {
      if (verbose) {
         LOCAL_TEXT_BUF tb = tb_new();
         capture_syntax(tb);
         dump(result);
         capture_syntax(NULL);
         tb_strip(tb);

         debugf("evaluating %s returned %s", eval_expr_name(expr), tb_get(tb));
      }

      return result;
   }
   else if (verbose) {
      diag_t *d = diag_new(DIAG_DEBUG, tree_loc(expr));
      diag_printf(d, "failed to evaluate %s", eval_expr_name(expr));
      diag_emit(d);
   }

   return expr;
}

tree_t eval_try_fold(jit_t *jit, tree_t expr, lower_unit_t *parent,
                     void *context)
{
   const bool verbose = opt_get_verbose(OPT_EVAL_VERBOSE, NULL);
   jit_set_silent(jit, !verbose);

   tree_t result = eval_do_fold(jit, expr, parent, context);

   jit_set_silent(jit, false);

   return result;
}

tree_t eval_must_fold(jit_t *jit, tree_t expr, lower_unit_t *parent,
                      void *context)
{
   return eval_do_fold(jit, expr, parent, context);
}

static bool eval_not_possible(tree_t t, const char *why)
{
   if (opt_get_verbose(OPT_EVAL_VERBOSE, NULL))
      warn_at(tree_loc(t), "%s prevents constant folding", why);

   return false;
}

bool eval_possible(tree_t t, unit_registry_t *ur)
{
   switch (tree_kind(t)) {
   case T_FCALL:
      {
         const tree_flags_t flags = tree_flags(t);
         if (!(flags & (TREE_F_LOCALLY_STATIC | TREE_F_GLOBALLY_STATIC)))
            return eval_not_possible(t, "non-static expression");

         tree_t decl = tree_ref(t);
         const subprogram_kind_t kind = tree_subkind(decl);
         if (is_foreign(kind))
            return eval_not_possible(t, "call to foreign function");
         else if (tree_flags(decl) & TREE_F_IMPURE)
            return eval_not_possible(t, "call to impure function");
         else if (kind != S_USER && !is_open_coded_builtin(kind)
                  && unit_registry_get(ur, tree_ident2(decl)) == NULL)
            return eval_not_possible(t, "not yet lowered predef");
         else if (kind == S_USER && !is_package(tree_container(decl)))
            return eval_not_possible(t, "subprogram not in package");

         const int nparams = tree_params(t);
         for (int i = 0; i < nparams; i++) {
            tree_t p = tree_value(tree_param(t, i));
            if (!eval_possible(p, ur))
               return false;
            else if (tree_kind(p) == T_FCALL && type_is_scalar(tree_type(p)))
               return false;  // Would have been folded already if possible
         }

         return true;
      }

   case T_LITERAL:
   case T_STRING:
      return true;

   case T_TYPE_CONV:
      return eval_possible(tree_value(t), ur);

   case T_QUALIFIED:
      return eval_possible(tree_value(t), ur);

   case T_REF:
      {
         tree_t decl = tree_ref(t);
         switch (tree_kind(decl)) {
         case T_UNIT_DECL:
         case T_ENUM_LIT:
            return true;

         case T_CONST_DECL:
            if (tree_has_value(decl))
               return eval_possible(tree_value(decl), ur);
            else
               return false;

         default:
            return eval_not_possible(t, "reference");
         }
      }

   case T_RECORD_REF:
      return eval_possible(tree_value(t), ur);

   case T_ARRAY_REF:
      {
         const int nparams = tree_params(t);
         for (int i = 0; i < nparams; i++) {
            if (!eval_possible(tree_value(tree_param(t, i)), ur))
               return false;
         }

         return eval_possible(tree_value(t), ur);
      }

   case T_AGGREGATE:
      {
         const int nassocs = tree_assocs(t);
         for (int i = 0; i < nassocs; i++) {
            if (!eval_possible(tree_value(tree_assoc(t, i)), ur))
               return false;
         }

         return true;
      }

   case T_ATTR_REF:
      {
         if (tree_subkind(t) == ATTR_USER)
            return eval_not_possible(t, "user defined attribute");

         if (!eval_possible(tree_name(t), ur))
            return false;

         const int nparams = tree_params(t);
         for (int i = 0; i < nparams; i++) {
            if (!eval_possible(tree_value(tree_param(t, i)), ur))
               return false;
         }

         return true;
      }

   default:
      return eval_not_possible(t, tree_kind_str(tree_kind(t)));
   }
}

static void *case_result_cb(jit_scalar_t *args, void *user)
{
   jit_scalar_t *result = user;
   result->integer = args[0].integer;
   return result;
}

tree_t eval_case(jit_t *jit, tree_t stmt, lower_unit_t *parent, void *context)
{
   assert(tree_kind(stmt) == T_CASE_GENERATE);

   vcode_unit_t thunk = lower_case_generate_thunk(parent, stmt);

   jit_scalar_t result = { .integer = -1 };
   if (jit_call_thunk(jit, thunk, context, case_result_cb, &result) == NULL)
      error_at(tree_loc(tree_value(stmt)), "generate expression is not static");

   vcode_unit_unref(thunk);

   if (result.integer == -1)
      return NULL;
   else
      return tree_stmt(stmt, result.integer);
}

void *eval_instance(jit_t *jit, ident_t name, void *context)
{
   jit_handle_t h = jit_lazy_compile(jit, name);
   if (h == JIT_HANDLE_INVALID)
      fatal_trace("failed to compile instance %s", istr(name));

   jit_scalar_t result;
   if (!jit_try_call(jit, h, &result, context, context))
      return NULL;

   return result.pointer;
}

1	//
2	// Copyright (C) 2013-2023 Nick Gasson
3	//
4	// This program is free software: you can redistribute it and/or modify
5	// it under the terms of the GNU General Public License as published by
6	// the Free Software Foundation, either version 3 of the License, or
7	// (at your option) any later version.
8	//
9	// This program is distributed in the hope that it will be useful,
10	// but WITHOUT ANY WARRANTY; without even the implied warranty of
11	// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12	// GNU General Public License for more details.
13	//
14	// You should have received a copy of the GNU General Public License
15	// along with this program. If not, see <http://www.gnu.org/licenses/>.
16	//
17
18	#include "util.h"
19	#include "common.h"
20	#include "diag.h"
21	#include "eval.h"
22	#include "hash.h"
23	#include "ident.h"
24	#include "jit/jit.h"
25	#include "jit/jit-ffi.h"
26	#include "lib.h"
27	#include "lower.h"
28	#include "option.h"
29	#include "phase.h"
30	#include "tree.h"
31	#include "type.h"
32	#include "vcode.h"
33
34	#include <assert.h>
35	#include <stdint.h>
36	#include <stdlib.h>
37	#include <stdarg.h>
38	#include <inttypes.h>
39	#include <string.h>
40
41	static const char *eval_expr_name(tree_t expr)	×
42	{
43	const tree_kind_t kind = tree_kind(expr);	×
44	if (kind == T_FCALL)	×
45	return istr(tree_ident(expr));	×
46	else
47	return tree_kind_str(kind);	×
48	}
49
50	static tree_t eval_value_to_tree(jit_scalar_t value, type_t type,	8,989✔
51	const loc_t *loc)
52	{
53	tree_t tree = NULL;	8,989✔
54
55	if (type_is_enum(type)) {	8,989✔
56	type_t base = type_base_recur(type);	2,095✔
57	if ((unsigned)value.integer >= type_enum_literals(base))	2,095✔
58	fatal_at(loc, "enum position %"PRIi64" out of range for type %s",	×
59	value.integer, type_pp(base));
60
61	tree_t lit = type_enum_literal(base, value.integer);	2,095✔
62
63	tree = tree_new(T_REF);	2,095✔
64	tree_set_ref(tree, lit);	2,095✔
65	tree_set_ident(tree, tree_ident(lit));	2,095✔
66	}
67	else if (type_is_integer(type)) {	6,894✔
68	tree = tree_new(T_LITERAL);	1,002✔
69	tree_set_subkind(tree, L_INT);	1,002✔
70	tree_set_ival(tree, value.integer);	1,002✔
71	}
72	else if (type_is_real(type)) {	5,892✔
73	tree = tree_new(T_LITERAL);	5,808✔
74	tree_set_subkind(tree, L_REAL);	5,808✔
75	tree_set_dval(tree, value.real);	5,808✔
76	}
77	else if (type_is_physical(type)) {	84✔
78	tree = tree_new(T_LITERAL);	84✔
79	tree_set_subkind(tree, L_PHYSICAL);	84✔
80	tree_set_ival(tree, value.integer);	84✔
81	}
82	else
83	fatal_trace("cannot convert 0x%"PRIx64" to %s", value.integer,	×
84	type_pp(type));
85
86	tree_set_type(tree, type);	8,989✔
87	tree_set_loc(tree, loc);	8,989✔
88	return tree;	8,989✔
89	}
90
91	static void thunk_result_cb(jit_scalar_t args, void *user)	9,154✔
92	{
93	tree_t expr = user;	9,154✔
94	type_t type = tree_type(expr);	9,154✔
95	const loc_t *loc = tree_loc(expr);	9,154✔
96
97	if (type_is_array(type)) {	9,154✔
98	assert(dimension_of(type) == 1);	177✔
99
100	type_t elem = type_elem(type);	177✔
101	assert(type_is_scalar(elem));	177✔
102
103	type_t base = type_base_recur(elem);	177✔
104
105	bool all_chars = true;	177✔
106	tree_t *lits LOCAL = NULL;	354✔
107	if (type_is_enum(elem)) {	177✔
108	const int nlits = type_enum_literals(base);	172✔
109	lits = xcalloc_array(nlits, sizeof(tree_t));	172✔
110	}
111	else
112	all_chars = false;
113
114	range_kind_t dir;	177✔
115	int64_t length, ileft, iright;	177✔
116	if (!type_const_bounds(type)) {	177✔
117	length = ffi_array_length(args[2].integer);	176✔
118	dir = ffi_array_dir(args[2].integer);	176✔
119	ileft = args[1].integer;	176✔
120	iright = ffi_array_right(args[1].integer, args[2].integer);	275✔
121	}
122	else {
123	tree_t r = range_of(type, 0);	1✔
124	if (!folded_length(r, &length))	1✔
NEW 125	fatal_at(loc, "cannot determine static length of array");	×
126
127	dir = tree_subkind(r);	1✔
128	ileft = assume_int(tree_left(r));	1✔
129	iright = assume_int(tree_right(r));	1✔
130	}
131
132	const int bytes = (type_bit_width(elem) + 7) / 8;	177✔
133	tree_t *elts LOCAL = xmalloc_array(length, sizeof(tree_t));	354✔
134	for (int i = 0; i < length; i++) {	1,651✔
135	#define UNPACK_VALUE(type) do { \
136	value.integer = ((type *)args[0].pointer)[i]; \
137	} while (0);
138
139	jit_scalar_t value = { .integer = 0 };	1,474✔
140	FOR_ALL_SIZES(bytes, UNPACK_VALUE);	1,474✔
141
142	if (lits != NULL) {	1,474✔
143	assert(value.integer >= 0);	1,462✔
144
145	if (lits[value.integer] == NULL) {	1,462✔
146	tree_t li = type_enum_literal(base, value.integer);	302✔
147	lits[value.integer] = make_ref(li);	302✔
148	all_chars &= ident_char(tree_ident(li), 0) == '\'';	302✔
149	}
150
151	elts[i] = lits[value.integer];	1,462✔
152	}
153	else
154	elts[i] = eval_value_to_tree(value, elem, loc);	12✔
155	}
156
157	type_t sub = type_new(T_SUBTYPE);	177✔
158	type_set_base(sub, type);	177✔
159
160	type_t index_type = index_type_of(type, 0);	177✔
161
162	tree_t left = NULL, right = NULL;	177✔
163	if (type_is_enum(index_type)) {	177✔
NEW 164	left = get_enum_lit(expr, index_type, ileft);	×
NEW 165	right = get_enum_lit(expr, index_type, iright);	×
166	}
167	else {
168	left = get_int_lit(expr, index_type, ileft);	177✔
169	right = get_int_lit(expr, index_type, iright);	177✔
170	}
171
172	tree_t r = tree_new(T_RANGE);	177✔
173	tree_set_subkind(r, dir);	177✔
174	tree_set_left(r, left);	177✔
175	tree_set_right(r, right);	177✔
176	tree_set_loc(r, loc);	177✔
177	tree_set_type(r, index_type);	177✔
178
179	tree_t c = tree_new(T_CONSTRAINT);	177✔
180	tree_set_subkind(c, C_INDEX);	177✔
181	tree_add_range(c, r);	177✔
182	tree_set_loc(c, loc);	177✔
183
184	type_add_constraint(sub, c);	177✔
185
186	if (all_chars) {	177✔
187	tree_t tree = tree_new(T_STRING);	171✔
188
189	for (int i = 0; i < length; i++)	1,631✔
190	tree_add_char(tree, elts[i]);	1,460✔
191
192	tree_set_loc(tree, loc);	171✔
193	tree_set_type(tree, sub);	171✔
194	return tree;	171✔
195	}
196	else {
197	tree_t tree = tree_new(T_AGGREGATE);	6✔
198	tree_set_type(tree, sub);	6✔
199	tree_set_loc(tree, loc);	6✔
200
201	for (int i = 0; i < length; i++) {	20✔
202	tree_t a = tree_new(T_ASSOC);	14✔
203	tree_set_loc(a, loc);	14✔
204	tree_set_subkind(a, A_POS);	14✔
205	tree_set_pos(a, i);	14✔
206	tree_set_value(a, elts[i]);	14✔
207
208	tree_add_assoc(tree, a);	14✔
209	}
210
211	return tree;
212	}
213	}
214	else
215	return eval_value_to_tree(args[0], tree_type(expr), tree_loc(expr));	8,977✔
216	}
217
218	static tree_t eval_do_fold(jit_t jit, tree_t expr, lower_unit_t parent,	10,662✔
219	void *context)
220	{
221	vcode_unit_t thunk = lower_thunk(parent, expr);	10,662✔
222	if (thunk == NULL)	10,662✔
223	return expr;
224
225	const bool verbose = opt_get_verbose(OPT_EVAL_VERBOSE, NULL);	9,573✔
226
227	tree_t result = jit_call_thunk(jit, thunk, context, thunk_result_cb, expr);	9,573✔
228
229	vcode_unit_unref(thunk);	9,570✔
230	thunk = NULL;	9,570✔
231
232	if (result != NULL) {	9,570✔
233	if (verbose) {	9,154✔
234	LOCAL_TEXT_BUF tb = tb_new();	×
235	capture_syntax(tb);	×
236	dump(result);	×
237	capture_syntax(NULL);	×
238	tb_strip(tb);	×
239
240	debugf("evaluating %s returned %s", eval_expr_name(expr), tb_get(tb));	×
241	}
242
243	return result;	9,154✔
244	}
245	else if (verbose) {	416✔
246	diag_t *d = diag_new(DIAG_DEBUG, tree_loc(expr));	×
247	diag_printf(d, "failed to evaluate %s", eval_expr_name(expr));	×
248	diag_emit(d);	×
249	}
250
251	return expr;
252	}
253
254	tree_t eval_try_fold(jit_t jit, tree_t expr, lower_unit_t parent,	10,612✔
255	void *context)
256	{
257	const bool verbose = opt_get_verbose(OPT_EVAL_VERBOSE, NULL);	10,612✔
258	jit_set_silent(jit, !verbose);	10,612✔
259
260	tree_t result = eval_do_fold(jit, expr, parent, context);	10,612✔
261
262	jit_set_silent(jit, false);	10,609✔
263
264	return result;	10,609✔
265	}
266
267	tree_t eval_must_fold(jit_t jit, tree_t expr, lower_unit_t parent,	50✔
268	void *context)
269	{
270	return eval_do_fold(jit, expr, parent, context);	50✔
271	}
272
273	static bool eval_not_possible(tree_t t, const char *why)	8,958✔
274	{
275	if (opt_get_verbose(OPT_EVAL_VERBOSE, NULL))	8,958✔
276	warn_at(tree_loc(t), "%s prevents constant folding", why);	×
277
278	return false;	8,958✔
279	}
280
281	bool eval_possible(tree_t t, unit_registry_t *ur)	82,031✔
282	{
283	switch (tree_kind(t)) {	92,479✔
284	case T_FCALL:	44,628✔
285	{
286	const tree_flags_t flags = tree_flags(t);	44,628✔
287	if (!(flags & (TREE_F_LOCALLY_STATIC \| TREE_F_GLOBALLY_STATIC)))	44,628✔
288	return eval_not_possible(t, "non-static expression");	987✔
289
290	tree_t decl = tree_ref(t);	43,641✔
291	const subprogram_kind_t kind = tree_subkind(decl);	43,641✔
292	if (is_foreign(kind))	43,641✔
293	return eval_not_possible(t, "call to foreign function");	57✔
294	else if (tree_flags(decl) & TREE_F_IMPURE)	43,584✔
295	return eval_not_possible(t, "call to impure function");	×
296	else if (kind != S_USER && !is_open_coded_builtin(kind)	43,584✔
297	&& unit_registry_get(ur, tree_ident2(decl)) == NULL)	4,033✔
298	return eval_not_possible(t, "not yet lowered predef");	153✔
299	else if (kind == S_USER && !is_package(tree_container(decl)))	43,431✔
300	return eval_not_possible(t, "subprogram not in package");	651✔
301
302	const int nparams = tree_params(t);	42,780✔
303	for (int i = 0; i < nparams; i++) {	59,237✔
304	tree_t p = tree_value(tree_param(t, i));	48,370✔
305	if (!eval_possible(p, ur))	48,370✔
306	return false;
307	else if (tree_kind(p) == T_FCALL && type_is_scalar(tree_type(p)))	17,132✔
308	return false; // Would have been folded already if possible
309	}
310
311	return true;
312	}
313
314	case T_LITERAL:
315	case T_STRING:
316	return true;
317
318	case T_TYPE_CONV:	3,908✔
319	return eval_possible(tree_value(t), ur);	3,908✔
320
321	case T_QUALIFIED:	2,298✔
322	return eval_possible(tree_value(t), ur);	2,298✔
323
324	case T_REF:	17,701✔
325	{
326	tree_t decl = tree_ref(t);	17,701✔
327	switch (tree_kind(decl)) {	17,701✔
328	case T_UNIT_DECL:
329	case T_ENUM_LIT:
330	return true;
331
332	case T_CONST_DECL:	2,499✔
333	if (tree_has_value(decl))	2,499✔
334	return eval_possible(tree_value(decl), ur);	2,480✔
335	else
336	return false;
337
338	default:	6,959✔
339	return eval_not_possible(t, "reference");	6,959✔
340	}
341	}
342
343	case T_RECORD_REF:	400✔
344	return eval_possible(tree_value(t), ur);	400✔
345
346	case T_ARRAY_REF:	1,422✔
347	{
348	const int nparams = tree_params(t);	1,422✔
349	for (int i = 0; i < nparams; i++) {	2,807✔
350	if (!eval_possible(tree_value(tree_param(t, i)), ur))	1,445✔
351	return false;
352	}
353
354	return eval_possible(tree_value(t), ur);	1,362✔
355	}
356
357	case T_AGGREGATE:	1,611✔
358	{
359	const int nassocs = tree_assocs(t);	1,611✔
360	for (int i = 0; i < nassocs; i++) {	10,365✔
361	if (!eval_possible(tree_value(tree_assoc(t, i)), ur))	8,778✔
362	return false;
363	}
364
365	return true;
366	}
367
368	case T_ATTR_REF:	3,240✔
369	{
370	if (tree_subkind(t) == ATTR_USER)	3,240✔
371	return eval_not_possible(t, "user defined attribute");	×
372
373	if (!eval_possible(tree_name(t), ur))	3,240✔
374	return false;
375
376	const int nparams = tree_params(t);	×
377	for (int i = 0; i < nparams; i++) {	×
378	if (!eval_possible(tree_value(tree_param(t, i)), ur))	×
379	return false;
380	}
381
382	return true;
383	}
384
385	default:	151✔
386	return eval_not_possible(t, tree_kind_str(tree_kind(t)));	151✔
387	}
388	}
389
390	static void case_result_cb(jit_scalar_t args, void *user)	9✔
391	{
392	jit_scalar_t *result = user;	9✔
393	result->integer = args[0].integer;	9✔
394	return result;	9✔
395	}
396
397	tree_t eval_case(jit_t jit, tree_t stmt, lower_unit_t parent, void *context)	9✔
398	{
399	assert(tree_kind(stmt) == T_CASE_GENERATE);	9✔
400
401	vcode_unit_t thunk = lower_case_generate_thunk(parent, stmt);	9✔
402
403	jit_scalar_t result = { .integer = -1 };	9✔
404	if (jit_call_thunk(jit, thunk, context, case_result_cb, &result) == NULL)	9✔
405	error_at(tree_loc(tree_value(stmt)), "generate expression is not static");	×
406
407	vcode_unit_unref(thunk);	9✔
408
409	if (result.integer == -1)	9✔
410	return NULL;
411	else
412	return tree_stmt(stmt, result.integer);	9✔
413	}
414
415	void eval_instance(jit_t jit, ident_t name, void *context)	6,955✔
416	{
417	jit_handle_t h = jit_lazy_compile(jit, name);	6,955✔
418	if (h == JIT_HANDLE_INVALID)	6,955✔
419	fatal_trace("failed to compile instance %s", istr(name));	×
420
421	jit_scalar_t result;	6,955✔
422	if (!jit_try_call(jit, h, &result, context, context))	6,955✔
423	return NULL;
424
425	return result.pointer;	6,944✔
426	}

nickg / nvc / 6935971286

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous