From 564a3cdfed70f6e7d7c75fa693ea2630b82cb8aa Mon Sep 17 00:00:00 2001 From: Michael Beck Date: Tue, 18 Mar 2008 01:59:07 +0000 Subject: [PATCH] - completed __FUNCSIG__ and __FUNCDNAME__ - fixed some gcc warnings [r18971] --- TODO | 3 +++ ast.c | 2 ++ ast2firm.c | 21 +++++++++++++++++++++ parser.c | 6 +++++- type.c | 8 ++++---- 5 files changed, 35 insertions(+), 5 deletions(-) diff --git a/TODO b/TODO index 9944e79..9a85373 100644 --- a/TODO +++ b/TODO @@ -1,3 +1,6 @@ +Driver: +- add an -std= option (for c99, gnu99, ms at least) + Refactoring: - eliminate target_architecture.h and replace with stuff in lang_features.h - redo storage classes: so we can separate real from declared storage class diff --git a/ast.c b/ast.c index c1d1cf6..50eaec3 100644 --- a/ast.c +++ b/ast.c @@ -1508,6 +1508,8 @@ bool is_constant_expression(const expression_t *expression) case EXPR_SIZEOF: case EXPR_CLASSIFY_TYPE: case EXPR_FUNCTION: + case EXPR_FUNCSIG: + case EXPR_FUNCDNAME: case EXPR_PRETTY_FUNCTION: case EXPR_OFFSETOF: case EXPR_ALIGNOF: diff --git a/ast2firm.c b/ast2firm.c index aac4a31..09aa949 100644 --- a/ast2firm.c +++ b/ast2firm.c @@ -59,6 +59,7 @@ static ir_node **imature_blocks; static const declaration_t *current_function_decl; static ir_node *current_function_name; +static ir_node *current_funcsig; static struct obstack asm_obst; @@ -2644,6 +2645,20 @@ static ir_node *function_name_to_firm( return current_function_name; } +static ir_node *funcsig_to_firm( + const string_literal_expression_t *const expr) +{ + if (current_funcsig == NULL) { + const source_position_t *const src_pos = &expr->base.source_position; + ir_entity *ent = get_irg_entity(current_ir_graph); + const char *const name = get_entity_ld_name(ent); + const string_t string = { name, strlen(name) + 1 }; + current_funcsig = string_to_firm(src_pos, "__FUNCSIG__", &string); + } + + return current_funcsig; +} + static ir_node *statement_expression_to_firm(const statement_expression_t *expr) { statement_t *statement = expr->statement; @@ -2769,7 +2784,10 @@ static ir_node *_expression_to_firm(const expression_t *expression) return classify_type_to_firm(&expression->classify_type); case EXPR_FUNCTION: case EXPR_PRETTY_FUNCTION: + case EXPR_FUNCDNAME: return function_name_to_firm(&expression->string); + case EXPR_FUNCSIG: + return funcsig_to_firm(&expression->string); case EXPR_STATEMENT: return statement_expression_to_firm(&expression->statement); case EXPR_VA_START: @@ -4401,6 +4419,8 @@ static int count_decls_in_expression(const expression_t *expression) { case EXPR_WIDE_STRING_LITERAL: case EXPR_FUNCTION: case EXPR_PRETTY_FUNCTION: + case EXPR_FUNCSIG: + case EXPR_FUNCDNAME: case EXPR_BUILTIN_SYMBOL: case EXPR_VA_START: case EXPR_VA_ARG: @@ -4617,6 +4637,7 @@ static void create_function(declaration_t *declaration) current_function_decl = declaration; current_function_name = NULL; + current_funcsig = NULL; assert(imature_blocks == NULL); imature_blocks = NEW_ARR_F(ir_node*, 0); diff --git a/parser.c b/parser.c index 037084f..26a647c 100644 --- a/parser.c +++ b/parser.c @@ -953,7 +953,9 @@ static void parse_gnu_attribute(void) while(true) { if(token.type != T_IDENTIFIER) break; - symbol_t *symbol = token.v.symbol; + symbol_t *sym = token.v.symbol; + if(sym == sym_deprecated) { + } next_token(); if(token.type == '(') eat_until_matching_token('('); @@ -5824,6 +5826,8 @@ static bool expression_has_effect(const expression_t *const expr) case EXPR_FUNCTION: return false; case EXPR_PRETTY_FUNCTION: return false; + case EXPR_FUNCSIG: return false; + case EXPR_FUNCDNAME: return false; case EXPR_BUILTIN_SYMBOL: break; /* handled in EXPR_CALL */ case EXPR_BUILTIN_CONSTANT_P: return false; case EXPR_BUILTIN_PREFETCH: return true; diff --git a/type.c b/type.c index 8910878..88c52b4 100644 --- a/type.c +++ b/type.c @@ -1029,14 +1029,14 @@ atomic_type_kind_t find_signed_int_atomic_type_kind_for_size(unsigned size) { assert(size < 32); atomic_type_kind_t kind = kinds[size]; if(kind == ATOMIC_TYPE_INVALID) { - static const possible_kinds[] = { + static const atomic_type_kind_t possible_kinds[] = { ATOMIC_TYPE_SCHAR, ATOMIC_TYPE_SHORT, ATOMIC_TYPE_INT, ATOMIC_TYPE_LONG, ATOMIC_TYPE_LONGLONG }; - for(int i = 0; i < sizeof(possible_kinds)/sizeof(possible_kinds[0]); ++i) { + for(unsigned i = 0; i < sizeof(possible_kinds)/sizeof(possible_kinds[0]); ++i) { if(get_atomic_type_size(possible_kinds[i]) == size) { kind = possible_kinds[i]; break; @@ -1056,14 +1056,14 @@ atomic_type_kind_t find_unsigned_int_atomic_type_kind_for_size(unsigned size) { assert(size < 32); atomic_type_kind_t kind = kinds[size]; if(kind == ATOMIC_TYPE_INVALID) { - static const possible_kinds[] = { + static const atomic_type_kind_t possible_kinds[] = { ATOMIC_TYPE_UCHAR, ATOMIC_TYPE_USHORT, ATOMIC_TYPE_UINT, ATOMIC_TYPE_ULONG, ATOMIC_TYPE_ULONGLONG }; - for(int i = 0; i < sizeof(possible_kinds)/sizeof(possible_kinds[0]); ++i) { + for(unsigned i = 0; i < sizeof(possible_kinds)/sizeof(possible_kinds[0]); ++i) { if(get_atomic_type_size(possible_kinds[i]) == size) { kind = possible_kinds[i]; break; -- 2.20.1