/*
- * Copyright (C) 2012, 2013
+ * Copyright (C) 2012, 2013, 2014
* Wolfgang Bumiller
* Dale Weiler
*
self->outr = NULL;
self->params = NULL;
self->count = 0;
- self->flags = 0;
self->varparam = NULL;
+ self->flags = 0;
+ if (OPTS_OPTION_BOOL(OPTION_COVERAGE))
+ self->flags |= AST_FLAG_BLOCK_COVERAGE;
}
static void ast_expression_delete(ast_expression *self)
if (!e) {
if (pos + 6 >= bufsize)
goto full;
- platform_strncpy(buf + pos, "(null)", 6);
+ util_strncpy(buf + pos, "(null)", 6);
return pos + 6;
}
switch (e->vtype) {
case TYPE_VARIANT:
- platform_strncpy(buf + pos, "(variant)", 9);
+ util_strncpy(buf + pos, "(variant)", 9);
return pos + 9;
case TYPE_FIELD:
if (pos + 1 >= bufsize)
goto full;
buf[pos++] = '[';
- pos += platform_snprintf(buf + pos, bufsize - pos - 1, "%i", (int)e->count);
+ pos += util_snprintf(buf + pos, bufsize - pos - 1, "%i", (int)e->count);
if (pos + 1 >= bufsize)
goto full;
buf[pos++] = ']';
typelen = strlen(typestr);
if (pos + typelen >= bufsize)
goto full;
- platform_strncpy(buf + pos, typestr, typelen);
+ util_strncpy(buf + pos, typestr, typelen);
return pos + typelen;
}
ast_binary* ast_binary_new(lex_ctx_t ctx, int op,
ast_expression* left, ast_expression* right)
{
- ast_binary *fold;
ast_instantiate(ast_binary, ctx, ast_binary_delete);
ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_binary_codegen);
+ if (ast_istype(right, ast_unary) && OPTS_OPTIMIZATION(OPTIM_PEEPHOLE)) {
+ ast_unary *unary = ((ast_unary*)right);
+ ast_expression *normal = unary->operand;
+
+ /* make a-(-b) => a + b */
+ if (unary->op == VINSTR_NEG_F || unary->op == VINSTR_NEG_V) {
+ if (op == INSTR_SUB_F) {
+ op = INSTR_ADD_F;
+ right = normal;
+ ++opts_optimizationcount[OPTIM_PEEPHOLE];
+ } else if (op == INSTR_SUB_V) {
+ op = INSTR_ADD_V;
+ right = normal;
+ ++opts_optimizationcount[OPTIM_PEEPHOLE];
+ }
+ }
+ }
+
self->op = op;
self->left = left;
self->right = right;
ast_propagate_effects(self, left);
ast_propagate_effects(self, right);
- if (OPTS_OPTIMIZATION(OPTIM_PEEPHOLE) && (fold = (ast_binary*)fold_superfluous(left, right, op))) {
- ast_binary_delete(self);
- return fold;
- }
-
if (op >= INSTR_EQ_F && op <= INSTR_GT)
self->expression.vtype = TYPE_FLOAT;
else if (op == INSTR_AND || op == INSTR_OR) {
ast_unary *prev = (ast_unary*)((ast_unary*)expr)->operand;
/* Handle for double negation */
- if ((((ast_unary*)expr)->op == VINSTR_NEG_V && op == VINSTR_NEG_V) ||
- (((ast_unary*)expr)->op == VINSTR_NEG_F && op == VINSTR_NEG_F)) {
+ if (((ast_unary*)expr)->op == op)
prev = (ast_unary*)((ast_unary*)expr)->operand;
- }
if (ast_istype(prev, ast_unary)) {
ast_expression_delete((ast_expression*)self);
self->fixedparams = NULL;
self->return_value = NULL;
+ self->static_names = NULL;
+ self->static_count = 0;
+
return self;
cleanup:
*/
ast_unref(self->vtype);
}
+ for (i = 0; i < vec_size(self->static_names); ++i)
+ mem_d(self->static_names[i]);
+ vec_free(self->static_names);
for (i = 0; i < vec_size(self->blocks); ++i)
ast_delete(self->blocks[i]);
vec_free(self->blocks);
self->ir_v->flags |= IR_FLAG_INCLUDE_DEF;
if (self->expression.flags & AST_FLAG_ERASEABLE)
self->ir_v->flags |= IR_FLAG_ERASEABLE;
+ if (self->expression.flags & AST_FLAG_BLOCK_COVERAGE)
+ func->flags |= IR_FLAG_BLOCK_COVERAGE;
/* The function is filled later on ast_function_codegen... */
return true;
}
namelen = strlen(self->name);
name = (char*)mem_a(namelen + 16);
- platform_strncpy(name, self->name, namelen);
+ util_strncpy(name, self->name, namelen);
array->ir_values = (ir_value**)mem_a(sizeof(array->ir_values[0]) * array->expression.count);
array->ir_values[0] = v;
for (ai = 1; ai < array->expression.count; ++ai) {
- platform_snprintf(name + namelen, 16, "[%u]", (unsigned int)ai);
+ util_snprintf(name + namelen, 16, "[%u]", (unsigned int)ai);
array->ir_values[ai] = ir_builder_create_field(ir, name, vtype);
if (!array->ir_values[ai]) {
mem_d(name);
namelen = strlen(self->name);
name = (char*)mem_a(namelen + 16);
- platform_strncpy(name, self->name, namelen);
+ util_strncpy(name, self->name, namelen);
self->ir_values = (ir_value**)mem_a(sizeof(self->ir_values[0]) * self->expression.count);
self->ir_values[0] = v;
for (ai = 1; ai < self->expression.count; ++ai) {
- platform_snprintf(name + namelen, 16, "[%u]", (unsigned int)ai);
+ util_snprintf(name + namelen, 16, "[%u]", (unsigned int)ai);
self->ir_values[ai] = ir_builder_create_global(ir, name, vtype);
if (!self->ir_values[ai]) {
mem_d(name);
namelen = strlen(self->name);
name = (char*)mem_a(namelen + 16);
- platform_strncpy(name, self->name, namelen);
+ util_strncpy(name, self->name, namelen);
self->ir_values[0] = v;
for (ai = 1; ai < self->expression.count; ++ai) {
- platform_snprintf(name + namelen, 16, "[%u]", (unsigned int)ai);
+ util_snprintf(name + namelen, 16, "[%u]", (unsigned int)ai);
self->ir_values[ai] = ir_function_create_local(func, name, vtype, param);
if (!self->ir_values[ai]) {
compile_error(ast_ctx(self), "internal_error: ir_builder_create_global failed on `%s`", name);
ir_value *dummy;
ast_expression *ec;
ast_expression_codegen *cgen;
+
size_t i;
(void)ir;