ast_node_init((ast_node*)self, ctx, TYPE_##T); \
( (ast_node*)self )->node.destroy = (ast_node_delete*)destroyfn
+
/* error handling */
static void asterror(lex_ctx ctx, const char *msg, ...)
{
/* It must not be possible to get here. */
static GMQCC_NORETURN void _ast_node_destroy(ast_node *self)
{
+ (void)self;
con_err("ast node missing destroy()\n");
abort();
}
self->node.destroy = &_ast_node_destroy;
self->node.keep = false;
self->node.nodetype = nodetype;
+ self->node.side_effects = false;
}
+/* weight and side effects */
+static void _ast_propagate_effects(ast_node *self, ast_node *other)
+{
+ if (ast_side_effects(other))
+ ast_side_effects(self) = true;
+}
+#define ast_propagate_effects(s,o) _ast_propagate_effects(((ast_node*)(s)), ((ast_node*)(o)))
+
/* General expression initialization */
static void ast_expression_init(ast_expression *self,
ast_expression_codegen *codegen)
self->name = name ? util_strdup(name) : NULL;
self->expression.vtype = t;
self->expression.next = NULL;
- self->isconst = false;
+ self->constant = false;
+ self->hasvalue = false;
self->uses = 0;
memset(&self->constval, 0, sizeof(self->constval));
{
if (self->name)
mem_d((void*)self->name);
- if (self->isconst) {
+ if (self->hasvalue) {
switch (self->expression.vtype)
{
case TYPE_STRING:
self->left = left;
self->right = right;
+ ast_propagate_effects(self, left);
+ ast_propagate_effects(self, right);
+
if (op >= INSTR_EQ_F && op <= INSTR_GT)
self->expression.vtype = TYPE_FLOAT;
else if (op == INSTR_AND || op == INSTR_OR ||
ast_instantiate(ast_binstore, ctx, ast_binstore_delete);
ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_binstore_codegen);
+ ast_side_effects(self) = true;
+
self->opstore = storop;
self->opbin = op;
self->dest = left;
self->op = op;
self->operand = expr;
+ ast_propagate_effects(self, expr);
+
if (op >= INSTR_NOT_F && op <= INSTR_NOT_FNC) {
self->expression.vtype = TYPE_FLOAT;
} else
self->operand = expr;
+ if (expr)
+ ast_propagate_effects(self, expr);
+
return self;
}
self->entity = entity;
self->field = field;
+ ast_propagate_effects(self, entity);
+ ast_propagate_effects(self, field);
if (!ast_type_adopt(self, outtype)) {
ast_entfield_delete(self);
mem_d(self);
}
-ast_member* ast_member_new(lex_ctx ctx, ast_expression *owner, unsigned int field)
+ast_member* ast_member_new(lex_ctx ctx, ast_expression *owner, unsigned int field, const char *name)
{
ast_instantiate(ast_member, ctx, ast_member_delete);
if (field >= 3) {
}
self->owner = owner;
+ ast_propagate_effects(self, owner);
+
self->field = field;
+ if (name)
+ self->name = util_strdup(name);
+ else
+ self->name = NULL;
return self;
}
self->array = array;
self->index = index;
+ ast_propagate_effects(self, array);
+ ast_propagate_effects(self, index);
if (!ast_type_adopt(self, outtype)) {
ast_array_index_delete(self);
self->cond = cond;
self->on_true = ontrue;
self->on_false = onfalse;
+ ast_propagate_effects(self, cond);
+ if (ontrue)
+ ast_propagate_effects(self, ontrue);
+ if (onfalse)
+ ast_propagate_effects(self, onfalse);
return self;
}
self->cond = cond;
self->on_true = ontrue;
self->on_false = onfalse;
+ ast_propagate_effects(self, cond);
+ ast_propagate_effects(self, ontrue);
+ ast_propagate_effects(self, onfalse);
if (!ast_type_adopt(self, ontrue)) {
ast_ternary_delete(self);
self->increment = increment;
self->body = body;
+ if (initexpr)
+ ast_propagate_effects(self, initexpr);
+ if (precond)
+ ast_propagate_effects(self, precond);
+ if (postcond)
+ ast_propagate_effects(self, postcond);
+ if (increment)
+ ast_propagate_effects(self, increment);
+ if (body)
+ ast_propagate_effects(self, body);
+
return self;
}
self->operand = op;
self->cases = NULL;
+ ast_propagate_effects(self, op);
+
return self;
}
mem_d(self);
}
+ast_label* ast_label_new(lex_ctx ctx, const char *name)
+{
+ ast_instantiate(ast_label, ctx, ast_label_delete);
+ ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_label_codegen);
+
+ self->name = util_strdup(name);
+ self->irblock = NULL;
+ self->gotos = NULL;
+
+ return self;
+}
+
+void ast_label_delete(ast_label *self)
+{
+ mem_d((void*)self->name);
+ vec_free(self->gotos);
+ ast_expression_delete((ast_expression*)self);
+ mem_d(self);
+}
+
+void ast_label_register_goto(ast_label *self, ast_goto *g)
+{
+ vec_push(self->gotos, g);
+}
+
+ast_goto* ast_goto_new(lex_ctx ctx, const char *name)
+{
+ ast_instantiate(ast_goto, ctx, ast_goto_delete);
+ ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_goto_codegen);
+
+ self->name = util_strdup(name);
+ self->target = NULL;
+ self->irblock_from = NULL;
+
+ return self;
+}
+
+void ast_goto_delete(ast_goto *self)
+{
+ mem_d((void*)self->name);
+ ast_expression_delete((ast_expression*)self);
+ mem_d(self);
+}
+
+void ast_goto_set_label(ast_goto *self, ast_label *label)
+{
+ self->target = label;
+}
+
ast_call* ast_call_new(lex_ctx ctx,
ast_expression *funcexpr)
{
ast_instantiate(ast_call, ctx, ast_call_delete);
ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_call_codegen);
+ ast_side_effects(self) = true;
+
self->params = NULL;
self->func = funcexpr;
ast_instantiate(ast_store, ctx, ast_store_delete);
ast_expression_init((ast_expression*)self, (ast_expression_codegen*)&ast_store_codegen);
+ ast_side_effects(self) = true;
+
self->op = op;
self->dest = dest;
self->source = source;
return self;
}
+void ast_block_add_expr(ast_block *self, ast_expression *e)
+{
+ ast_propagate_effects(self, e);
+ vec_push(self->exprs, e);
+}
+
void ast_block_collect(ast_block *self, ast_expression *expr)
{
vec_push(self->collect, expr);
ast_instantiate(ast_function, ctx, ast_function_delete);
if (!vtype ||
- vtype->isconst ||
+ vtype->hasvalue ||
vtype->expression.vtype != TYPE_FUNCTION)
{
+ asterror(ast_ctx(self), "internal error: ast_function_new condition %i %i type=%i",
+ (int)!vtype,
+ (int)vtype->hasvalue,
+ vtype->expression.vtype);
mem_d(self);
return NULL;
}
self->breakblock = NULL;
self->continueblock = NULL;
- vtype->isconst = true;
+ vtype->hasvalue = true;
vtype->constval.vfunc = self;
return self;
mem_d((void*)self->name);
if (self->vtype) {
/* ast_value_delete(self->vtype); */
- self->vtype->isconst = false;
+ self->vtype->hasvalue = false;
self->vtype->constval.vfunc = NULL;
/* We use unref - if it was stored in a global table it is supposed
* to be deleted from *there*
bool ast_value_codegen(ast_value *self, ast_function *func, bool lvalue, ir_value **out)
{
+ (void)func;
+ (void)lvalue;
/* NOTE: This is the codegen for a variable used in an expression.
* It is not the codegen to generate the value. For this purpose,
* ast_local_codegen and ast_global_codegen are to be used before this
{
ir_value *v = NULL;
- if (self->isconst && self->expression.vtype == TYPE_FUNCTION)
+ if (self->hasvalue && self->expression.vtype == TYPE_FUNCTION)
{
ir_function *func = ir_builder_create_function(ir, self->name, self->expression.next->expression.vtype);
if (!func)
if (isfield && self->expression.vtype == TYPE_FIELD) {
ast_expression *fieldtype = self->expression.next;
- if (self->isconst) {
+ if (self->hasvalue) {
asterror(ast_ctx(self), "TODO: constant field pointers with value");
goto error;
}
v = ir_builder_create_field(ir, self->name, vtype);
if (!v) {
- asterror(ast_ctx(self), "ir_builder_create_global failed");
+ asterror(ast_ctx(self), "ir_builder_create_global failed on `%s`", self->name);
return false;
}
if (vtype == TYPE_FIELD)
array->ir_values[ai] = ir_builder_create_field(ir, name, vtype);
if (!array->ir_values[ai]) {
mem_d(name);
- asterror(ast_ctx(self), "ir_builder_create_global failed");
+ asterror(ast_ctx(self), "ir_builder_create_global failed on `%s`", name);
return false;
}
if (vtype == TYPE_FIELD)
v = ir_builder_create_global(ir, self->name, vtype);
if (!v) {
- asterror(ast_ctx(self), "ir_builder_create_global failed");
+ asterror(ast_ctx(self), "ir_builder_create_global failed `%s`", self->name);
return false;
}
if (vtype == TYPE_FIELD)
self->ir_values[ai] = ir_builder_create_global(ir, name, vtype);
if (!self->ir_values[ai]) {
mem_d(name);
- asterror(ast_ctx(self), "ir_builder_create_global failed");
+ asterror(ast_ctx(self), "ir_builder_create_global failed `%s`", name);
return false;
}
if (vtype == TYPE_FIELD)
*/
v = ir_builder_create_global(ir, self->name, self->expression.vtype);
if (!v) {
- asterror(ast_ctx(self), "ir_builder_create_global failed");
+ asterror(ast_ctx(self), "ir_builder_create_global failed on `%s`", self->name);
return false;
}
if (self->expression.vtype == TYPE_FIELD)
v->context = ast_ctx(self);
}
- if (self->isconst) {
+ if (self->hasvalue) {
switch (self->expression.vtype)
{
case TYPE_FLOAT:
bool ast_local_codegen(ast_value *self, ir_function *func, bool param)
{
ir_value *v = NULL;
- if (self->isconst && self->expression.vtype == TYPE_FUNCTION)
+ if (self->hasvalue && self->expression.vtype == TYPE_FUNCTION)
{
/* Do we allow local functions? I think not...
* this is NOT a function pointer atm.
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]) {
- asterror(ast_ctx(self), "ir_builder_create_global failed");
+ asterror(ast_ctx(self), "ir_builder_create_global failed on `%s`", name);
return false;
}
if (vtype == TYPE_FIELD)
/* A constant local... hmmm...
* I suppose the IR will have to deal with this
*/
- if (self->isconst) {
+ if (self->hasvalue) {
switch (self->expression.vtype)
{
case TYPE_FLOAT:
ast_expression_common *ec;
size_t i;
+ (void)ir;
+
irf = self->ir_func;
if (!irf) {
asterror(ast_ctx(self), "ast_function's related ast_value was not generated yet");
for (i = 0; i < vec_size(self->exprs); ++i)
{
ast_expression_codegen *gen = self->exprs[i]->expression.codegen;
- if (func->curblock->final) {
+ if (func->curblock->final && !ast_istype(self->exprs[i], ast_label)) {
asterror(ast_ctx(self->exprs[i]), "unreachable statement");
return false;
}
ai = (ast_array_index*)self->dest;
idx = (ast_value*)ai->index;
- if (ast_istype(ai->index, ast_value) && idx->isconst)
+ if (ast_istype(ai->index, ast_value) && idx->hasvalue)
ai = NULL;
}
bool ast_binstore_codegen(ast_binstore *self, ast_function *func, bool lvalue, ir_value **out)
{
ast_expression_codegen *cgen;
- ir_value *leftl, *leftr, *right, *bin;
+ ir_value *leftl = NULL, *leftr, *right, *bin;
+
+ ast_value *arr;
+ ast_value *idx = 0;
+ ast_array_index *ai = NULL;
+ ir_value *iridx = NULL;
if (lvalue && self->expression.outl) {
*out = self->expression.outl;
return true;
}
+ if (ast_istype(self->dest, ast_array_index))
+ {
+
+ ai = (ast_array_index*)self->dest;
+ idx = (ast_value*)ai->index;
+
+ if (ast_istype(ai->index, ast_value) && idx->hasvalue)
+ ai = NULL;
+ }
+
/* for a binstore we need both an lvalue and an rvalue for the left side */
/* rvalue of destination! */
+ if (ai) {
+ cgen = idx->expression.codegen;
+ if (!(*cgen)((ast_expression*)(idx), func, false, &iridx))
+ return false;
+ }
cgen = self->dest->expression.codegen;
if (!(*cgen)((ast_expression*)(self->dest), func, false, &leftr))
return false;
self->opbin, leftr, right);
self->expression.outr = bin;
- /* now store them */
- cgen = self->dest->expression.codegen;
- /* lvalue of destination */
- if (!(*cgen)((ast_expression*)(self->dest), func, true, &leftl))
- return false;
- self->expression.outl = leftl;
- if (!ir_block_create_store_op(func->curblock, self->opstore, leftl, bin))
- return false;
- self->expression.outr = bin;
+ if (ai) {
+ /* we need to call the setter */
+ ir_value *funval;
+ ir_instr *call;
+
+ if (lvalue) {
+ asterror(ast_ctx(self), "array-subscript assignment cannot produce lvalues");
+ return false;
+ }
+
+ arr = (ast_value*)ai->array;
+ if (!ast_istype(ai->array, ast_value) || !arr->setter) {
+ asterror(ast_ctx(self), "value has no setter (%s)", arr->name);
+ return false;
+ }
+
+ cgen = arr->setter->expression.codegen;
+ if (!(*cgen)((ast_expression*)(arr->setter), func, true, &funval))
+ return false;
+
+ call = ir_block_create_call(func->curblock, ast_function_label(func, "store"), funval);
+ if (!call)
+ return false;
+ ir_call_param(call, iridx);
+ ir_call_param(call, bin);
+ self->expression.outr = bin;
+ } else {
+ /* now store them */
+ cgen = self->dest->expression.codegen;
+ /* lvalue of destination */
+ if (!(*cgen)((ast_expression*)(self->dest), func, true, &leftl))
+ return false;
+ self->expression.outl = leftl;
+
+ if (!ir_block_create_store_op(func->curblock, self->opstore, leftl, bin))
+ return false;
+ self->expression.outr = bin;
+ }
/* Theoretically, an assinment returns its left side as an
* lvalue, if we don't need an lvalue though, we return
ast_expression_codegen *cgen;
ir_value *operand;
+ *out = NULL;
+
/* In the context of a return operation, we don't actually return
* anything...
*/
arr = (ast_value*)self->array;
idx = (ast_value*)self->index;
- if (!ast_istype(self->index, ast_value) || !idx->isconst) {
+ if (!ast_istype(self->index, ast_value) || !idx->hasvalue) {
/* Time to use accessor functions */
ast_expression_codegen *cgen;
ir_value *iridx, *funval;
}
cgen = self->index->expression.codegen;
- if (!(*cgen)((ast_expression*)(self->index), func, true, &iridx))
+ if (!(*cgen)((ast_expression*)(self->index), func, false, &iridx))
return false;
cgen = arr->getter->expression.codegen;
{
ir_block *target;
+ *out = NULL;
+
if (lvalue) {
asterror(ast_ctx(self), "break/continue expression is not an l-value");
return false;
return true;
}
+bool ast_label_codegen(ast_label *self, ast_function *func, bool lvalue, ir_value **out)
+{
+ size_t i;
+ ir_value *dummy;
+
+ *out = NULL;
+ if (lvalue) {
+ asterror(ast_ctx(self), "internal error: ast_label cannot be an lvalue");
+ return false;
+ }
+
+ /* simply create a new block and jump to it */
+ self->irblock = ir_function_create_block(func->ir_func, self->name);
+ if (!self->irblock) {
+ asterror(ast_ctx(self), "failed to allocate label block `%s`", self->name);
+ return false;
+ }
+ if (!func->curblock->final) {
+ if (!ir_block_create_jump(func->curblock, self->irblock))
+ return false;
+ }
+
+ /* enter the new block */
+ func->curblock = self->irblock;
+
+ /* Generate all the leftover gotos */
+ for (i = 0; i < vec_size(self->gotos); ++i) {
+ if (!ast_goto_codegen(self->gotos[i], func, false, &dummy))
+ return false;
+ }
+
+ return true;
+}
+
+bool ast_goto_codegen(ast_goto *self, ast_function *func, bool lvalue, ir_value **out)
+{
+ *out = NULL;
+ if (lvalue) {
+ asterror(ast_ctx(self), "internal error: ast_goto cannot be an lvalue");
+ return false;
+ }
+
+ if (self->target->irblock) {
+ if (self->irblock_from) {
+ /* we already tried once, this is the callback */
+ self->irblock_from->final = false;
+ if (!ir_block_create_jump(self->irblock_from, self->target->irblock)) {
+ asterror(ast_ctx(self), "failed to generate goto to `%s`", self->name);
+ return false;
+ }
+ }
+ else
+ {
+ if (!ir_block_create_jump(func->curblock, self->target->irblock)) {
+ asterror(ast_ctx(self), "failed to generate goto to `%s`", self->name);
+ return false;
+ }
+ }
+ }
+ else
+ {
+ /* the target has not yet been created...
+ * close this block in a sneaky way:
+ */
+ func->curblock->final = true;
+ self->irblock_from = func->curblock;
+ ast_label_register_goto(self->target, self);
+ }
+
+ return true;
+}
+
bool ast_call_codegen(ast_call *self, ast_function *func, bool lvalue, ir_value **out)
{
ast_expression_codegen *cgen;
projects / xonotic / gmqcc.git / blobdiff