static FILE *out;
static int indent;
+static int print_implicit_casts = 1;
static void print_statement(const statement_t *statement);
static void print_binary_expression(const binary_expression_t *binexpr)
{
- if(binexpr->expression.type == EXPR_BINARY_BUILTIN_EXPECT) {
+ if(binexpr->expression.kind == EXPR_BINARY_BUILTIN_EXPECT) {
fputs("__builtin_expect(", out);
print_expression(binexpr->left);
fputs(", ", out);
fprintf(out, "(");
print_expression(binexpr->left);
fprintf(out, " ");
- switch(binexpr->expression.type) {
+ switch(binexpr->expression.kind) {
case EXPR_BINARY_COMMA: fputs(",", out); break;
case EXPR_BINARY_ASSIGN: fputs("=", out); break;
case EXPR_BINARY_ADD: fputs("+", out); break;
static void print_unary_expression(const unary_expression_t *unexpr)
{
- switch(unexpr->expression.type) {
+ switch(unexpr->expression.kind) {
case EXPR_UNARY_NEGATE: fputs("-", out); break;
case EXPR_UNARY_PLUS: fputs("+", out); break;
case EXPR_UNARY_NOT: fputs("!", out); break;
case EXPR_UNARY_DEREFERENCE: fputs("*", out); break;
case EXPR_UNARY_TAKE_ADDRESS: fputs("&", out); break;
+ case EXPR_UNARY_BITFIELD_EXTRACT:
+ print_expression(unexpr->value);
+ return;
+
case EXPR_UNARY_POSTFIX_INCREMENT:
fputs("(", out);
print_expression(unexpr->value);
fputs(")", out);
fputs("--", out);
return;
+ case EXPR_UNARY_CAST_IMPLICIT:
+ if(!print_implicit_casts) {
+ print_expression(unexpr->value);
+ return;
+ }
+ /* fallthrough */
case EXPR_UNARY_CAST:
fputs("(", out);
print_type(unexpr->expression.datatype);
fputs(")", out);
break;
- case EXPR_UNARY_CAST_IMPLICIT:
- print_expression(unexpr->value);
- return;
+ case EXPR_UNARY_ASSUME:
+ fputs("__assume", out);
+ break;
default:
panic("invalid unary expression found");
}
}
}
+static void print_alignof_expression(const alignof_expression_t *expression)
+{
+ fputs("__alignof__(", out);
+ print_type(expression->type);
+ fputc(')', out);
+}
+
static void print_builtin_symbol(const builtin_symbol_expression_t *expression)
{
fputs(expression->symbol->string, out);
}
+static void print_builtin_constant(const builtin_constant_expression_t *expression)
+{
+ fputs("__builtin_constant_p(", out);
+ print_expression(expression->value);
+ fputc(')', out);
+}
+
+static void print_builtin_prefetch(const builtin_prefetch_expression_t *expression)
+{
+ fputs("__builtin_prefetch(", out);
+ print_expression(expression->adr);
+ if (expression->rw) {
+ fputc(',', out);
+ print_expression(expression->rw);
+ }
+ if (expression->locality) {
+ fputc(',', out);
+ print_expression(expression->locality);
+ }
+ fputc(')', out);
+}
+
static void print_conditional(const conditional_expression_t *expression)
{
fputs("(", out);
{
print_expression(expression->compound);
if(expression->compound->base.datatype == NULL ||
- expression->compound->base.datatype->type == TYPE_POINTER) {
+ expression->compound->base.datatype->kind == TYPE_POINTER) {
fputs("->", out);
} else {
fputc('.', out);
fputc(')', out);
}
+static void print_designator(const designator_t *designator)
+{
+ fputs(designator->symbol->string, out);
+ for (designator = designator->next; designator != NULL; designator = designator->next) {
+ if (designator->array_access) {
+ fputc('[', out);
+ print_expression(designator->array_access);
+ fputc(']', out);
+ } else {
+ fputc('.', out);
+ fputs(designator->symbol->string, out);
+ }
+ }
+}
+
+static void print_offsetof_expression(const offsetof_expression_t *expression)
+{
+ fputs("__builtin_offsetof", out);
+ fputc('(', out);
+ print_type(expression->type);
+ fputc(',', out);
+ print_designator(expression->designator);
+ fputc(')', out);
+}
+
+static void print_statement_expression(const statement_expression_t *expression)
+{
+ fputc('(', out);
+ print_statement(expression->statement);
+ fputc(')', out);
+}
+
void print_expression(const expression_t *expression)
{
- switch(expression->type) {
+ switch(expression->kind) {
case EXPR_UNKNOWN:
case EXPR_INVALID:
fprintf(out, "*invalid expression*");
case EXPR_SIZEOF:
print_sizeof_expression(&expression->sizeofe);
break;
+ case EXPR_ALIGNOF:
+ print_alignof_expression(&expression->alignofe);
+ break;
case EXPR_BUILTIN_SYMBOL:
print_builtin_symbol(&expression->builtin_symbol);
break;
+ case EXPR_BUILTIN_CONSTANT_P:
+ print_builtin_constant(&expression->builtin_constant);
+ break;
+ case EXPR_BUILTIN_PREFETCH:
+ print_builtin_prefetch(&expression->builtin_prefetch);
+ break;
case EXPR_CONDITIONAL:
print_conditional(&expression->conditional);
break;
case EXPR_VA_START:
print_va_start(&expression->va_starte);
+ break;
case EXPR_VA_ARG:
print_va_arg(&expression->va_arge);
break;
case EXPR_CLASSIFY_TYPE:
print_classify_type_expression(&expression->classify_type);
break;
-
case EXPR_OFFSETOF:
+ print_offsetof_expression(&expression->offsetofe);
+ break;
case EXPR_STATEMENT:
+ print_statement_expression(&expression->statement);
+ break;
+
+ default:
/* TODO */
- fprintf(out, "some expression of type %d", (int) expression->type);
+ fprintf(out, "some expression of type %d", (int) expression->kind);
break;
}
}
void print_statement(const statement_t *statement)
{
- switch(statement->type) {
+ switch(statement->kind) {
case STATEMENT_COMPOUND:
print_compound_statement(&statement->compound);
break;
void print_initializer(const initializer_t *initializer)
{
- if(initializer->type == INITIALIZER_VALUE) {
+ if(initializer->kind == INITIALIZER_VALUE) {
const initializer_value_t *value = &initializer->value;
print_expression(value->value);
return;
}
- assert(initializer->type == INITIALIZER_LIST);
+ assert(initializer->kind == INITIALIZER_LIST);
fputs("{ ", out);
const initializer_list_t *list = &initializer->list;
{
print_storage_class(declaration->storage_class);
if(declaration->is_inline) {
- if (declaration->decl_modifiers & DM_FORCEINLINE)
+ if (declaration->modifiers & DM_FORCEINLINE)
fputs("__forceinline ", out);
else
fputs("inline ", out);
print_type_ext(declaration->type, declaration->symbol,
&declaration->context);
- if(declaration->type->type == TYPE_FUNCTION) {
+ if(declaration->type->kind == TYPE_FUNCTION) {
if(declaration->init.statement != NULL) {
fputs("\n", out);
print_statement(declaration->init.statement);
bool is_constant_expression(const expression_t *expression)
{
- switch(expression->type) {
+ switch(expression->kind) {
case EXPR_CONST:
case EXPR_STRING_LITERAL:
case EXPR_FUNCTION:
case EXPR_PRETTY_FUNCTION:
case EXPR_OFFSETOF:
+ case EXPR_ALIGNOF:
+ case EXPR_BUILTIN_CONSTANT_P:
return true;
case EXPR_BUILTIN_SYMBOL:
+ case EXPR_BUILTIN_PREFETCH:
case EXPR_CALL:
case EXPR_SELECT:
case EXPR_VA_START:
case EXPR_UNARY_POSTFIX_DECREMENT:
case EXPR_UNARY_PREFIX_INCREMENT:
case EXPR_UNARY_PREFIX_DECREMENT:
+ case EXPR_UNARY_BITFIELD_EXTRACT:
+ case EXPR_UNARY_ASSUME: /* has VOID type */
case EXPR_BINARY_ASSIGN:
case EXPR_BINARY_MUL_ASSIGN:
case EXPR_BINARY_DIV_ASSIGN: