X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ast.c;h=1dd6085fd34efaefed4128ce39967c2c67e9c6b6;hb=f0acd842a34d249ac78dfbb2c2168695c466693e;hp=4bc91a196a1e4a55c2bc0f2ea94a8b2c6ef75c7b;hpb=f3f57226195059ecb38d482c469a4c665fc9c2d1;p=cparser

diff --git a/ast.c b/ast.c
index 4bc91a1..1dd6085 100644
--- a/ast.c
+++ b/ast.c
@@ -22,6 +22,8 @@
 #include "ast_t.h"
 #include "symbol_t.h"
 #include "type_t.h"
+#include "parser.h"
+#include "lang_features.h"
 
 #include <assert.h>
 #include <stdio.h>
@@ -113,8 +115,7 @@ static unsigned get_expression_precedence(expression_kind_t kind)
 		[EXPR_CLASSIFY_TYPE]             = PREC_UNARY,
 		[EXPR_ALIGNOF]                   = PREC_UNARY,
 
-		[EXPR_FUNCTION]                  = PREC_PRIM,
-		[EXPR_PRETTY_FUNCTION]           = PREC_PRIM,
+		[EXPR_FUNCNAME]                  = PREC_PRIM,
 		[EXPR_BUILTIN_SYMBOL]            = PREC_PRIM,
 		[EXPR_BUILTIN_CONSTANT_P]        = PREC_PRIM,
 		[EXPR_BUILTIN_PREFETCH]          = PREC_PRIM,
@@ -136,7 +137,6 @@ static unsigned get_expression_precedence(expression_kind_t kind)
 		[EXPR_UNARY_CAST]                = PREC_UNARY,
 		[EXPR_UNARY_CAST_IMPLICIT]       = PREC_UNARY,
 		[EXPR_UNARY_ASSUME]              = PREC_PRIM,
-		[EXPR_UNARY_BITFIELD_EXTRACT]    = PREC_ACCESS,
 
 		[EXPR_BINARY_ADD]                = PREC_PLUS,
 		[EXPR_BINARY_SUB]                = PREC_PLUS,
@@ -210,11 +210,12 @@ static void print_const(const const_expression_t *cnst)
  *
  * @param string  the string constant
  * @param border  the border char
+ * @param skip    number of chars to skip at the end
  */
-static void print_quoted_string(const string_t *const string, char border)
+static void print_quoted_string(const string_t *const string, char border, int skip)
 {
 	fputc(border, out);
-	const char *end = string->begin + string->size - 1;
+	const char *end = string->begin + string->size - skip;
 	for (const char *c = string->begin; c != end; ++c) {
 		if (*c == border) {
 			fputc('\\', out);
@@ -229,6 +230,11 @@ static void print_quoted_string(const string_t *const string, char border)
 		case '\t':  fputs("\\t", out); break;
 		case '\v':  fputs("\\v", out); break;
 		case '\?':  fputs("\\?", out); break;
+		case 27:
+			if (c_mode & _GNUC) {
+				fputs("\\e", out); break;
+			}
+			/*fallthrough*/
 		default:
 			if(!isprint(*c)) {
 				fprintf(out, "\\%03o", *c);
@@ -244,15 +250,17 @@ static void print_quoted_string(const string_t *const string, char border)
 /**
  * Prints a wide string literal expression.
  *
- * @param wstr  the wide string literal expression
+ * @param wstr    the wide string literal expression
+ * @param border  the border char
+ * @param skip    number of chars to skip at the end
  */
 static void print_quoted_wide_string(const wide_string_t *const wstr,
-                                     char border)
+                                     char border, int skip)
 {
 	fputc('L', out);
 	fputc(border, out);
-	for (const wchar_rep_t *c = wstr->begin, *end = wstr->begin + wstr->size-1;
-	     c != end; ++c) {
+	const wchar_rep_t *end = wstr->begin + wstr->size - skip;
+	for (const wchar_rep_t *c = wstr->begin; c != end; ++c) {
 		switch (*c) {
 			case L'\"':  fputs("\\\"", out); break;
 			case L'\\':  fputs("\\\\", out); break;
@@ -264,6 +272,11 @@ static void print_quoted_wide_string(const wide_string_t *const wstr,
 			case L'\t':  fputs("\\t",  out); break;
 			case L'\v':  fputs("\\v",  out); break;
 			case L'\?':  fputs("\\?",  out); break;
+			case 27:
+				if (c_mode & _GNUC) {
+					fputs("\\e", out); break;
+				}
+				/*fallthrough*/
 			default: {
 				const unsigned tc = *c;
 				if (tc < 0x80U) {
@@ -298,12 +311,12 @@ static void print_quoted_wide_string(const wide_string_t *const wstr,
  */
 static void print_character_constant(const const_expression_t *cnst)
 {
-	print_quoted_string(&cnst->v.character, '\'');
+	print_quoted_string(&cnst->v.character, '\'', 0);
 }
 
 static void print_wide_character_constant(const const_expression_t *cnst)
 {
-	print_quoted_wide_string(&cnst->v.wide_character, '\'');
+	print_quoted_wide_string(&cnst->v.wide_character, '\'', 0);
 }
 
 /**
@@ -314,13 +327,31 @@ static void print_wide_character_constant(const const_expression_t *cnst)
 static void print_string_literal(
 		const string_literal_expression_t *string_literal)
 {
-	print_quoted_string(&string_literal->value, '"');
+	print_quoted_string(&string_literal->value, '"', 1);
+}
+
+/**
+ * Prints a predefined symbol.
+ */
+static void print_funcname(
+		const funcname_expression_t *funcname)
+{
+	const char *s = "";
+	switch(funcname->kind) {
+	case FUNCNAME_FUNCTION:        s = (c_mode & _C99) ? "__func__" : "__FUNCTION__"; break;
+	case FUNCNAME_PRETTY_FUNCTION: s = "__PRETTY_FUNCTION__"; break;
+	case FUNCNAME_FUNCSIG:         s = "__FUNCSIG__"; break;
+	case FUNCNAME_FUNCDNAME:       s = "__FUNCDNAME__"; break;
+	}
+	fputc('"', out);
+	fputs(s, out);
+	fputc('"', out);
 }
 
 static void print_wide_string_literal(
 	const wide_string_literal_expression_t *const wstr)
 {
-	print_quoted_wide_string(&wstr->value, '"');
+	print_quoted_wide_string(&wstr->value, '"', 1);
 }
 
 static void print_compound_literal(
@@ -436,10 +467,6 @@ static void print_unary_expression(const unary_expression_t *unexpr)
 	case EXPR_UNARY_DEREFERENCE:      fputs("*", out);  break;
 	case EXPR_UNARY_TAKE_ADDRESS:     fputs("&", out);  break;
 
-	case EXPR_UNARY_BITFIELD_EXTRACT:
-		print_expression_prec(unexpr->value, prec);
-		return;
-
 	case EXPR_UNARY_POSTFIX_INCREMENT:
 		print_expression_prec(unexpr->value, prec);
 		fputs("++", out);
@@ -449,11 +476,6 @@ static void print_unary_expression(const unary_expression_t *unexpr)
 		fputs("--", out);
 		return;
 	case EXPR_UNARY_CAST_IMPLICIT:
-		if(!print_implicit_casts) {
-			print_expression_prec(unexpr->value, prec);
-			return;
-		}
-		/* fallthrough */
 	case EXPR_UNARY_CAST:
 		fputc('(', out);
 		print_type(unexpr->base.type);
@@ -491,12 +513,12 @@ static void print_array_expression(const array_access_expression_t *expression)
 	if(!expression->flipped) {
 		print_expression_prec(expression->array_ref, prec);
 		fputc('[', out);
-		print_expression_prec(expression->index, prec);
+		print_expression_prec(expression->index, PREC_BOTTOM);
 		fputc(']', out);
 	} else {
 		print_expression_prec(expression->index, prec);
 		fputc('[', out);
-		print_expression_prec(expression->array_ref, prec);
+		print_expression_prec(expression->array_ref, PREC_BOTTOM);
 		fputc(']', out);
 	}
 }
@@ -579,8 +601,12 @@ static void print_conditional(const conditional_expression_t *expression)
 	fputs("(", out);
 	print_expression_prec(expression->condition, prec);
 	fputs(" ? ", out);
-	print_expression_prec(expression->true_expression, prec);
-	fputs(" : ", out);
+	if (expression->true_expression != NULL) {
+		print_expression_prec(expression->true_expression, prec);
+		fputs(" : ", out);
+	} else {
+		fputs(": ", out);
+	}
 	print_expression_prec(expression->false_expression, prec);
 	fputs(")", out);
 }
@@ -622,7 +648,7 @@ static void print_select(const select_expression_t *expression)
 {
 	unsigned prec = get_expression_precedence(expression->base.kind);
 	print_expression_prec(expression->compound, prec);
-	if(is_type_pointer(expression->compound->base.type)) {
+	if(is_type_pointer(skip_typeref(expression->compound->base.type))) {
 		fputs("->", out);
 	} else {
 		fputc('.', out);
@@ -653,7 +679,7 @@ static void print_designator(const designator_t *designator)
 	for ( ; designator != NULL; designator = designator->next) {
 		if (designator->symbol == NULL) {
 			fputc('[', out);
-			print_expression_prec(designator->array_index, PREC_ACCESS);
+			print_expression_prec(designator->array_index, PREC_BOTTOM);
 			fputc(']', out);
 		} else {
 			fputc('.', out);
@@ -697,6 +723,9 @@ static void print_statement_expression(const statement_expression_t *expression)
  */
 static void print_expression_prec(const expression_t *expression, unsigned top_prec)
 {
+	if (expression->kind == EXPR_UNARY_CAST_IMPLICIT && !print_implicit_casts) {
+		expression = expression->unary.value;
+	}
 	unsigned prec = get_expression_precedence(expression->base.kind);
 	if (print_parenthesis && top_prec != PREC_BOTTOM)
 		top_prec = PREC_TOP;
@@ -705,7 +734,7 @@ static void print_expression_prec(const expression_t *expression, unsigned top_p
 	switch(expression->kind) {
 	case EXPR_UNKNOWN:
 	case EXPR_INVALID:
-		fprintf(out, "*invalid expression*");
+		fprintf(out, "$invalid expression$");
 		break;
 	case EXPR_CHARACTER_CONSTANT:
 		print_character_constant(&expression->conste);
@@ -716,8 +745,9 @@ static void print_expression_prec(const expression_t *expression, unsigned top_p
 	case EXPR_CONST:
 		print_const(&expression->conste);
 		break;
-	case EXPR_FUNCTION:
-	case EXPR_PRETTY_FUNCTION:
+	case EXPR_FUNCNAME:
+		print_funcname(&expression->funcname);
+		break;
 	case EXPR_STRING_LITERAL:
 		print_string_literal(&expression->string);
 		break;
@@ -856,9 +886,7 @@ static void print_label_statement(const label_statement_t *statement)
 {
 	fprintf(stderr, "(%p)", (void*) statement->label);
 	fprintf(out, "%s:\n", statement->label->symbol->string);
-	if(statement->statement != NULL) {
-		print_statement(statement->statement);
-	}
+	print_statement(statement->statement);
 }
 
 /**
@@ -868,12 +896,10 @@ static void print_label_statement(const label_statement_t *statement)
  */
 static void print_if_statement(const if_statement_t *statement)
 {
-	fputs("if(", out);
+	fputs("if (", out);
 	print_expression(statement->condition);
 	fputs(") ", out);
-	if(statement->true_statement != NULL) {
-		print_statement(statement->true_statement);
-	}
+	print_statement(statement->true_statement);
 
 	if(statement->false_statement != NULL) {
 		print_indent();
@@ -889,7 +915,7 @@ static void print_if_statement(const if_statement_t *statement)
  */
 static void print_switch_statement(const switch_statement_t *statement)
 {
-	fputs("switch(", out);
+	fputs("switch (", out);
 	print_expression(statement->expression);
 	fputs(") ", out);
 	print_statement(statement->body);
@@ -935,6 +961,9 @@ static void print_declaration_statement(
 	declaration_t *declaration = statement->declarations_begin;
 	for( ; declaration != statement->declarations_end->next;
 	       declaration = declaration->next) {
+	    if(declaration->storage_class == STORAGE_CLASS_ENUM_ENTRY)
+	    	continue;
+
 		if(!first) {
 			print_indent();
 		} else {
@@ -952,7 +981,7 @@ static void print_declaration_statement(
  */
 static void print_while_statement(const while_statement_t *statement)
 {
-	fputs("while(", out);
+	fputs("while (", out);
 	print_expression(statement->condition);
 	fputs(") ", out);
 	print_statement(statement->body);
@@ -968,7 +997,7 @@ static void print_do_while_statement(const do_while_statement_t *statement)
 	fputs("do ", out);
 	print_statement(statement->body);
 	print_indent();
-	fputs("while(", out);
+	fputs("while (", out);
 	print_expression(statement->condition);
 	fputs(");\n", out);
 }
@@ -980,7 +1009,7 @@ static void print_do_while_statement(const do_while_statement_t *statement)
  */
 static void print_for_statement(const for_statement_t *statement)
 {
-	fputs("for(", out);
+	fputs("for (", out);
 	if(statement->scope.declarations != NULL) {
 		assert(statement->initialisation == NULL);
 		print_declaration(statement->scope.declarations);
@@ -1006,23 +1035,23 @@ static void print_for_statement(const for_statement_t *statement)
 }
 
 /**
- * Print assembler constraints.
+ * Print assembler arguments.
  *
- * @param constraints   the constraints
+ * @param arguments   the arguments
  */
-static void print_asm_constraints(asm_constraint_t *constraints)
+static void print_asm_arguments(asm_argument_t *arguments)
 {
-	asm_constraint_t *constraint = constraints;
-	for( ; constraint != NULL; constraint = constraint->next) {
-		if(constraint != constraints)
+	asm_argument_t *argument = arguments;
+	for( ; argument != NULL; argument = argument->next) {
+		if(argument != arguments)
 			fputs(", ", out);
 
-		if(constraint->symbol) {
-			fprintf(out, "[%s] ", constraint->symbol->string);
+		if(argument->symbol) {
+			fprintf(out, "[%s] ", argument->symbol->string);
 		}
-		print_quoted_string(&constraint->constraints, '"');
+		print_quoted_string(&argument->constraints, '"', 1);
 		fputs(" (", out);
-		print_expression(constraint->expression);
+		print_expression(argument->expression);
 		fputs(")", out);
 	}
 }
@@ -1039,7 +1068,7 @@ static void print_asm_clobbers(asm_clobber_t *clobbers)
 		if(clobber != clobbers)
 			fputs(", ", out);
 
-		print_quoted_string(&clobber->clobber, '"');
+		print_quoted_string(&clobber->clobber, '"', 1);
 	}
 }
 
@@ -1055,18 +1084,18 @@ static void print_asm_statement(const asm_statement_t *statement)
 		fputs("volatile ", out);
 	}
 	fputs("(", out);
-	print_quoted_string(&statement->asm_text, '"');
+	print_quoted_string(&statement->asm_text, '"', 1);
 	if(statement->inputs == NULL && statement->outputs == NULL
 			&& statement->clobbers == NULL)
 		goto end_of_print_asm_statement;
 
 	fputs(" : ", out);
-	print_asm_constraints(statement->inputs);
+	print_asm_arguments(statement->inputs);
 	if(statement->outputs == NULL && statement->clobbers == NULL)
 		goto end_of_print_asm_statement;
 
 	fputs(" : ", out);
-	print_asm_constraints(statement->outputs);
+	print_asm_arguments(statement->outputs);
 	if(statement->clobbers == NULL)
 		goto end_of_print_asm_statement;
 
@@ -1077,6 +1106,37 @@ end_of_print_asm_statement:
 	fputs(");\n", out);
 }
 
+/**
+ * Print a microsoft __try statement.
+ *
+ * @param statement   the statement
+ */
+static void print_ms_try_statement(const ms_try_statement_t *statement)
+{
+	fputs("__try ", out);
+	print_statement(statement->try_statement);
+	print_indent();
+	if(statement->except_expression != NULL) {
+		fputs("__except(", out);
+		print_expression(statement->except_expression);
+		fputs(") ", out);
+	} else {
+		fputs("__finally ", out);
+	}
+	print_statement(statement->final_statement);
+}
+
+/**
+ * Print a microsoft __leave statement.
+ *
+ * @param statement   the statement
+ */
+static void print_leave_statement(const leave_statement_t *statement)
+{
+	(void) statement;
+	fputs("__leave;\n", out);
+}
+
 /**
  * Print a statement.
  *
@@ -1085,6 +1145,9 @@ end_of_print_asm_statement:
 void print_statement(const statement_t *statement)
 {
 	switch(statement->kind) {
+	case STATEMENT_EMPTY:
+		fputs(";\n", out);
+		break;
 	case STATEMENT_COMPOUND:
 		print_compound_statement(&statement->compound);
 		break;
@@ -1130,8 +1193,14 @@ void print_statement(const statement_t *statement)
 	case STATEMENT_ASM:
 		print_asm_statement(&statement->asms);
 		break;
+	case STATEMENT_MS_TRY:
+		print_ms_try_statement(&statement->ms_try);
+		break;
+	case STATEMENT_LEAVE:
+		print_leave_statement(&statement->leave);
+		break;
 	case STATEMENT_INVALID:
-		fprintf(out, "*invalid statement*");
+		fprintf(out, "$invalid statement$");
 		break;
 	}
 }
@@ -1166,7 +1235,7 @@ static void print_storage_class(storage_class_tag_t storage_class)
 void print_initializer(const initializer_t *initializer)
 {
 	if(initializer == NULL) {
-		fputs("{ NIL-INITIALIZER }", out);
+		fputs("{}", out);
 		return;
 	}
 
@@ -1184,18 +1253,19 @@ void print_initializer(const initializer_t *initializer)
 		for(size_t i = 0 ; i < list->len; ++i) {
 			const initializer_t *sub_init = list->initializers[i];
 			print_initializer(list->initializers[i]);
-			if(i < list->len-1 && sub_init->kind != INITIALIZER_DESIGNATOR) {
-				fputs(", ", out);
+			if(i < list->len-1) {
+				if(sub_init == NULL || sub_init->kind != INITIALIZER_DESIGNATOR)
+					fputs(", ", out);
 			}
 		}
 		fputs(" }", out);
 		return;
 	}
 	case INITIALIZER_STRING:
-		print_quoted_string(&initializer->string.string, '"');
+		print_quoted_string(&initializer->string.string, '"', 1);
 		return;
 	case INITIALIZER_WIDE_STRING:
-		print_quoted_wide_string(&initializer->wide_string.string, '"');
+		print_quoted_wide_string(&initializer->wide_string.string, '"', 1);
 		return;
 	case INITIALIZER_DESIGNATOR:
 		print_designator(initializer->designator.designator);
@@ -1206,6 +1276,79 @@ void print_initializer(const initializer_t *initializer)
 	panic("invalid initializer kind found");
 }
 
+/**
+ * Print microsoft extended declaration modifiers.
+ */
+static void print_ms_modifiers(const declaration_t *declaration) {
+	if((c_mode & _MS) == 0)
+		return;
+
+	decl_modifiers_t modifiers = declaration->modifiers;
+
+	/* DM_FORCEINLINE handled outside. */
+	if ((modifiers & ~DM_FORCEINLINE) != 0    ||
+	    declaration->alignment        != 0    ||
+	    declaration->get_property_sym != NULL ||
+	    declaration->put_property_sym != NULL) {
+		char *next = "(";
+
+		fputs("__declspec", out);
+		if(modifiers & DM_DLLIMPORT) {
+			fputs(next, out); next = ", "; fputs("dllimport", out);
+		}
+		if(modifiers & DM_DLLEXPORT) {
+			fputs(next, out); next = ", "; fputs("dllexport", out);
+		}
+		if(modifiers & DM_THREAD) {
+			fputs(next, out); next = ", "; fputs("thread", out);
+		}
+		if(modifiers & DM_NAKED) {
+			fputs(next, out); next = ", "; fputs("naked", out);
+		}
+		if(modifiers & DM_THREAD) {
+			fputs(next, out); next = ", "; fputs("thread", out);
+		}
+		if(modifiers & DM_SELECTANY) {
+			fputs(next, out); next = ", "; fputs("selectany", out);
+		}
+		if(modifiers & DM_NOTHROW) {
+			fputs(next, out); next = ", "; fputs("nothrow", out);
+		}
+		if(modifiers & DM_NORETURN) {
+			fputs(next, out); next = ", "; fputs("noreturn", out);
+		}
+		if(modifiers & DM_NOINLINE) {
+			fputs(next, out); next = ", "; fputs("noinline", out);
+		}
+		if (modifiers & DM_DEPRECATED) {
+			fputs(next, out); next = ", "; fputs("deprecated", out);
+			if(declaration->deprecated_string != NULL)
+				fprintf(out, "(\"%s\")", declaration->deprecated_string);
+		}
+		if(declaration->alignment != 0) {
+			fputs(next, out); next = ", "; fprintf(out, "align(%u)", declaration->alignment);
+		}
+		if(modifiers & DM_RESTRICT) {
+			fputs(next, out); next = ", "; fputs("restrict", out);
+		}
+		if(modifiers & DM_NOALIAS) {
+			fputs(next, out); next = ", "; fputs("noalias", out);
+		}
+	    if(declaration->get_property_sym != NULL || declaration->put_property_sym != NULL) {
+	    	char *comma = "";
+			fputs(next, out); next = ", "; fprintf(out, "property(");
+	    	if(declaration->get_property_sym != NULL) {
+	    		fprintf(out, "get=%s", declaration->get_property_sym->string);
+	    		comma = ", ";
+			}
+	    	if(declaration->put_property_sym != NULL)
+	    		fprintf(out, "%sput=%s", comma, declaration->put_property_sym->string);
+			fputc(')', out);
+		}
+		fputs(") ", out);
+	}
+}
+
 /**
  * Print a declaration in the NORMAL namespace.
  *
@@ -1214,12 +1357,16 @@ void print_initializer(const initializer_t *initializer)
 static void print_normal_declaration(const declaration_t *declaration)
 {
 	print_storage_class((storage_class_tag_t) declaration->declared_storage_class);
-	if(declaration->is_inline) {
-		if (declaration->modifiers & DM_FORCEINLINE)
+	if (declaration->is_inline) {
+		if (declaration->modifiers & DM_FORCEINLINE) {
 			fputs("__forceinline ", out);
-		else
+		} else if (declaration->modifiers & DM_MICROSOFT_INLINE) {
+			fputs("__inline ", out);
+		} else {
 			fputs("inline ", out);
+		}
 	}
+	print_ms_modifiers(declaration);
 	print_type_ext(declaration->type, declaration->symbol,
 	               &declaration->scope);
 
@@ -1318,7 +1465,7 @@ bool is_constant_initializer(const initializer_t *initializer)
 	case INITIALIZER_VALUE:
 		return is_constant_expression(initializer->value.value);
 
-	case INITIALIZER_LIST: {
+	case INITIALIZER_LIST:
 		for(size_t i = 0; i < initializer->list.len; ++i) {
 			initializer_t *sub_initializer = initializer->list.initializers[i];
 			if(!is_constant_initializer(sub_initializer))
@@ -1326,22 +1473,22 @@ bool is_constant_initializer(const initializer_t *initializer)
 		}
 		return true;
 	}
-	}
 	panic("invalid initializer kind found");
 }
 
-static bool is_object_with_constant_address(const expression_t *expression)
+static bool is_object_with_linker_constant_address(const expression_t *expression)
 {
 	switch(expression->kind) {
 	case EXPR_UNARY_DEREFERENCE:
 		return is_address_constant(expression->unary.value);
 
 	case EXPR_SELECT: {
-		if(is_type_pointer(expression->select.compound->base.type)) {
+		type_t *base_type = skip_typeref(expression->select.compound->base.type);
+		if(is_type_pointer(base_type)) {
 			/* it's a -> */
 			return is_address_constant(expression->select.compound);
 		} else {
-			return is_object_with_constant_address(expression->select.compound);
+			return is_object_with_linker_constant_address(expression->select.compound);
 		}
 	}
 
@@ -1370,12 +1517,30 @@ bool is_address_constant(const expression_t *expression)
 {
 	switch(expression->kind) {
 	case EXPR_UNARY_TAKE_ADDRESS:
-		return is_object_with_constant_address(expression->unary.value);
+		return is_object_with_linker_constant_address(expression->unary.value);
+
+	case EXPR_UNARY_DEREFERENCE: {
+		type_t *real_type
+			= revert_automatic_type_conversion(expression->unary.value);
+		/* dereferencing a function is a NOP */
+		if(is_type_function(real_type)) {
+			return is_address_constant(expression->unary.value);
+		}
 
-	case EXPR_UNARY_CAST:
-		return is_type_pointer(skip_typeref(expression->base.type))
-			&& (is_constant_expression(expression->unary.value)
+		/* fallthrough */
+	}
+
+	case EXPR_UNARY_CAST: {
+		type_t *dest = skip_typeref(expression->base.type);
+		if (!is_type_pointer(dest) &&
+				! (dest->kind == TYPE_ATOMIC
+					&& (get_atomic_type_flags(dest->atomic.akind) & ATOMIC_TYPE_FLAG_INTEGER)
+					&& (get_atomic_type_size(dest->atomic.akind) >= get_atomic_type_size(get_intptr_kind()))))
+			return false;
+
+		return (is_constant_expression(expression->unary.value)
 			|| is_address_constant(expression->unary.value));
+	}
 
 	case EXPR_BINARY_ADD:
 	case EXPR_BINARY_SUB: {
@@ -1397,7 +1562,7 @@ bool is_address_constant(const expression_t *expression)
 		if(is_type_function(type))
 			return true;
 		if(is_type_array(type)) {
-			return is_object_with_constant_address(expression);
+			return is_object_with_linker_constant_address(expression);
 		}
 		return false;
 	}
@@ -1407,6 +1572,64 @@ bool is_address_constant(const expression_t *expression)
 	}
 }
 
+static bool is_builtin_const_call(const expression_t *expression)
+{
+	expression_t *function = expression->call.function;
+	if (function->kind != EXPR_BUILTIN_SYMBOL) {
+		return false;
+	}
+
+	symbol_t *symbol = function->builtin_symbol.symbol;
+
+	switch (symbol->ID) {
+	case T___builtin_huge_val:
+	case T___builtin_nan:
+	case T___builtin_nanf:
+	case T___builtin_nand:
+		return true;
+	}
+
+	return false;
+}
+
+static bool is_constant_pointer(const expression_t *expression)
+{
+	if (is_constant_expression(expression))
+		return true;
+
+	switch (expression->kind) {
+	case EXPR_SELECT:
+		return is_constant_pointer(expression->select.compound);
+	case EXPR_UNARY_CAST:
+		return is_constant_pointer(expression->unary.value);
+	default:
+		return false;
+	}
+}
+
+static bool is_object_with_constant_address(const expression_t *expression)
+{
+	switch(expression->kind) {
+	case EXPR_SELECT: {
+		expression_t *compound      = expression->select.compound;
+		type_t       *compound_type = compound->base.type;
+		compound_type = skip_typeref(compound_type);
+		if(is_type_pointer(compound_type)) {
+			return is_constant_pointer(compound);
+		} else {
+			return is_object_with_constant_address(compound);
+		}
+	}
+	case EXPR_ARRAY_ACCESS:
+		return is_constant_pointer(expression->array_access.array_ref)
+			&& is_constant_expression(expression->array_access.index);
+	case EXPR_UNARY_DEREFERENCE:
+		return is_constant_pointer(expression->unary.value);
+	default:
+		return false;
+	}
+}
+
 bool is_constant_expression(const expression_t *expression)
 {
 	switch(expression->kind) {
@@ -1416,18 +1639,26 @@ bool is_constant_expression(const expression_t *expression)
 	case EXPR_WIDE_CHARACTER_CONSTANT:
 	case EXPR_STRING_LITERAL:
 	case EXPR_WIDE_STRING_LITERAL:
-	case EXPR_SIZEOF:
 	case EXPR_CLASSIFY_TYPE:
-	case EXPR_FUNCTION:
-	case EXPR_PRETTY_FUNCTION:
+	case EXPR_FUNCNAME:
 	case EXPR_OFFSETOF:
 	case EXPR_ALIGNOF:
 	case EXPR_BUILTIN_CONSTANT_P:
 		return true;
 
+	case EXPR_SIZEOF: {
+		type_t *type = expression->typeprop.type;
+		if (type == NULL)
+			type = expression->typeprop.tp_expression->base.type;
+
+		type = skip_typeref(type);
+		if (is_type_array(type) && type->array.is_vla)
+			return false;
+		return true;
+	}
+
 	case EXPR_BUILTIN_SYMBOL:
 	case EXPR_BUILTIN_PREFETCH:
-	case EXPR_CALL:
 	case EXPR_SELECT:
 	case EXPR_VA_START:
 	case EXPR_VA_ARG:
@@ -1436,10 +1667,8 @@ bool is_constant_expression(const expression_t *expression)
 	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_UNARY_DEREFERENCE:
-	case EXPR_UNARY_TAKE_ADDRESS:
 	case EXPR_BINARY_ASSIGN:
 	case EXPR_BINARY_MUL_ASSIGN:
 	case EXPR_BINARY_DIV_ASSIGN:
@@ -1454,6 +1683,12 @@ bool is_constant_expression(const expression_t *expression)
 	case EXPR_BINARY_COMMA:
 		return false;
 
+	case EXPR_UNARY_TAKE_ADDRESS:
+		return is_object_with_constant_address(expression->unary.value);
+
+	case EXPR_CALL:
+		return is_builtin_const_call(expression);
+
 	case EXPR_UNARY_NEGATE:
 	case EXPR_UNARY_PLUS:
 	case EXPR_UNARY_BITWISE_NEGATE:
@@ -1520,8 +1755,10 @@ bool is_constant_expression(const expression_t *expression)
 		return false;
 	}
 
-	case EXPR_UNKNOWN:
 	case EXPR_INVALID:
+		return true;
+
+	case EXPR_UNKNOWN:
 		break;
 	}
 	panic("invalid expression found (is constant expression)");