bool must_be_constant;
} parse_initializer_env_t;
-/**
- * Capture a MS __base extension.
- */
-typedef struct based_spec_t {
- source_position_t source_position;
- variable_t *base_variable;
-} based_spec_t;
-
typedef entity_t* (*parsed_declaration_func) (entity_t *declaration, bool is_definition);
/** The current token. */
static void semantic_comparison(binary_expression_t *expression);
+static void create_gnu_builtins(void);
+static void create_microsoft_intrinsics(void);
+
#define STORAGE_CLASSES \
STORAGE_CLASSES_NO_EXTERN \
case T_extern:
case T___FUNCTION__: \
case T___PRETTY_FUNCTION__: \
case T___alignof__: \
- case T___builtin_alloca: \
case T___builtin_classify_type: \
case T___builtin_constant_p: \
- case T___builtin_expect: \
- case T___builtin_huge_val: \
- case T___builtin_inf: \
- case T___builtin_inff: \
- case T___builtin_infl: \
case T___builtin_isgreater: \
case T___builtin_isgreaterequal: \
case T___builtin_isless: \
case T___builtin_islessequal: \
case T___builtin_islessgreater: \
case T___builtin_isunordered: \
- case T___builtin_nan: \
- case T___builtin_nanf: \
- case T___builtin_nanl: \
case T___builtin_offsetof: \
- case T___builtin_prefetch: \
case T___builtin_va_arg: \
- case T___builtin_va_end: \
case T___builtin_va_start: \
case T___func__: \
case T___noop: \
[EXPR_ALIGNOF] = sizeof(typeprop_expression_t),
[EXPR_CLASSIFY_TYPE] = sizeof(classify_type_expression_t),
[EXPR_FUNCNAME] = sizeof(funcname_expression_t),
- [EXPR_BUILTIN_SYMBOL] = sizeof(builtin_symbol_expression_t),
[EXPR_BUILTIN_CONSTANT_P] = sizeof(builtin_constant_expression_t),
[EXPR_BUILTIN_TYPES_COMPATIBLE_P] = sizeof(builtin_types_compatible_expression_t),
[EXPR_OFFSETOF] = sizeof(offsetof_expression_t),
return res;
}
+static function_parameter_t *allocate_parameter(type_t *const type)
+{
+ function_parameter_t *const param = obstack_alloc(type_obst, sizeof(*param));
+ memset(param, 0, sizeof(*param));
+ param->type = type;
+ return param;
+}
+
/**
* Returns the size of an initializer node.
*
case EXPR_CLASSIFY_TYPE:
case EXPR_ALIGNOF:
case EXPR_FUNCNAME:
- case EXPR_BUILTIN_SYMBOL:
case EXPR_BUILTIN_CONSTANT_P:
case EXPR_BUILTIN_TYPES_COMPATIBLE_P:
case EXPR_OFFSETOF:
return entity;
}
-static void parse_microsoft_based(based_spec_t *based_spec)
+static variable_t *parse_microsoft_based(void)
{
if (token.type != T_IDENTIFIER) {
parse_error_expected("while parsing __based", T_IDENTIFIER, NULL);
- return;
+ return NULL;
}
symbol_t *symbol = token.v.symbol;
entity_t *entity = get_entity(symbol, NAMESPACE_NORMAL);
+ variable_t *variable;
if (entity == NULL || entity->base.kind != ENTITY_VARIABLE) {
errorf(HERE, "'%Y' is not a variable name.", symbol);
- entity = create_error_entity(symbol, ENTITY_VARIABLE);
+ variable = &create_error_entity(symbol, ENTITY_VARIABLE)->variable;
} else {
- variable_t *variable = &entity->variable;
-
- if (based_spec->base_variable != NULL) {
- errorf(HERE, "__based type qualifier specified more than once");
- }
- based_spec->source_position = token.source_position;
- based_spec->base_variable = variable;
+ variable = &entity->variable;
type_t *const type = variable->base.type;
-
if (is_type_valid(type)) {
if (! is_type_pointer(skip_typeref(type))) {
errorf(HERE, "variable in __based modifier must have pointer type instead of '%T'", type);
}
}
next_token();
+ return variable;
}
/**
}
}
+static bool has_parameters(void)
+{
+ /* func(void) is not a parameter */
+ if (token.type == T_IDENTIFIER) {
+ entity_t const *const entity = get_entity(token.v.symbol, NAMESPACE_NORMAL);
+ if (entity->kind != ENTITY_TYPEDEF)
+ return true;
+ if (skip_typeref(entity->typedefe.type) != type_void)
+ return true;
+ } else if (token.type != T_void) {
+ return true;
+ }
+ if (look_ahead(1)->type != ')')
+ return true;
+ next_token();
+ return false;
+}
+
/**
* Parses function type parameters (and optionally creates variable_t entities
* for them in a scope)
goto parameters_finished;
}
- function_parameter_t *parameter;
- function_parameter_t *last_parameter = NULL;
+ if (has_parameters()) {
+ function_parameter_t **anchor = &type->parameters;
+ for (;;) {
+ switch (token.type) {
+ case T_DOTDOTDOT:
+ next_token();
+ type->variadic = true;
+ goto parameters_finished;
- while (true) {
- switch (token.type) {
- case T_DOTDOTDOT:
- next_token();
- type->variadic = true;
- goto parameters_finished;
+ case T_IDENTIFIER:
+ case T___extension__:
+ DECLARATION_START
+ {
+ entity_t *entity = parse_parameter();
+ if (entity->kind == ENTITY_TYPEDEF) {
+ errorf(&entity->base.source_position,
+ "typedef not allowed as function parameter");
+ break;
+ }
+ assert(is_declaration(entity));
- case T_IDENTIFIER:
- case T___extension__:
- DECLARATION_START
- {
- entity_t *entity = parse_parameter();
- if (entity->kind == ENTITY_TYPEDEF) {
- errorf(&entity->base.source_position,
- "typedef not allowed as function parameter");
- break;
- }
- assert(is_declaration(entity));
+ semantic_parameter_incomplete(entity);
- /* func(void) is not a parameter */
- if (last_parameter == NULL
- && token.type == ')'
- && entity->base.symbol == NULL
- && skip_typeref(entity->declaration.type) == type_void) {
- goto parameters_finished;
- }
- semantic_parameter_incomplete(entity);
+ function_parameter_t *const parameter =
+ allocate_parameter(entity->declaration.type);
- parameter = obstack_alloc(type_obst, sizeof(parameter[0]));
- memset(parameter, 0, sizeof(parameter[0]));
- parameter->type = entity->declaration.type;
+ if (scope != NULL) {
+ append_entity(scope, entity);
+ }
- if (scope != NULL) {
- append_entity(scope, entity);
+ *anchor = parameter;
+ anchor = ¶meter->next;
+ break;
}
- if (last_parameter != NULL) {
- last_parameter->next = parameter;
- } else {
- type->parameters = parameter;
+ default:
+ goto parameters_finished;
}
- last_parameter = parameter;
- break;
- }
-
- default:
- goto parameters_finished;
- }
- if (token.type != ',') {
- goto parameters_finished;
+ if (token.type != ',') {
+ goto parameters_finished;
+ }
+ next_token();
}
- next_token();
}
CONSTRUCT_ARRAY
} construct_type_kind_t;
-typedef struct construct_type_t construct_type_t;
-struct construct_type_t {
+typedef union construct_type_t construct_type_t;
+
+typedef struct construct_type_base_t {
construct_type_kind_t kind;
construct_type_t *next;
-};
-
-typedef struct parsed_pointer_t parsed_pointer_t;
-struct parsed_pointer_t {
- construct_type_t construct_type;
- type_qualifiers_t type_qualifiers;
- variable_t *base_variable; /**< MS __based extension. */
-};
-
-typedef struct parsed_reference_t parsed_reference_t;
-struct parsed_reference_t {
- construct_type_t construct_type;
-};
-
-typedef struct construct_function_type_t construct_function_type_t;
-struct construct_function_type_t {
- construct_type_t construct_type;
- type_t *function_type;
-};
-
-typedef struct parsed_array_t parsed_array_t;
-struct parsed_array_t {
- construct_type_t construct_type;
- type_qualifiers_t type_qualifiers;
- bool is_static;
- bool is_variable;
- expression_t *size;
-};
-
-typedef struct construct_base_type_t construct_base_type_t;
-struct construct_base_type_t {
- construct_type_t construct_type;
- type_t *type;
+} construct_type_base_t;
+
+typedef struct parsed_pointer_t {
+ construct_type_base_t base;
+ type_qualifiers_t type_qualifiers;
+ variable_t *base_variable; /**< MS __based extension. */
+} parsed_pointer_t;
+
+typedef struct parsed_reference_t {
+ construct_type_base_t base;
+} parsed_reference_t;
+
+typedef struct construct_function_type_t {
+ construct_type_base_t base;
+ type_t *function_type;
+} construct_function_type_t;
+
+typedef struct parsed_array_t {
+ construct_type_base_t base;
+ type_qualifiers_t type_qualifiers;
+ bool is_static;
+ bool is_variable;
+ expression_t *size;
+} parsed_array_t;
+
+union construct_type_t {
+ construct_type_kind_t kind;
+ construct_type_base_t base;
+ parsed_pointer_t pointer;
+ parsed_reference_t reference;
+ construct_function_type_t function;
+ parsed_array_t array;
};
static construct_type_t *parse_pointer_declarator(variable_t *base_variable)
{
eat('*');
- parsed_pointer_t *pointer = obstack_alloc(&temp_obst, sizeof(pointer[0]));
- memset(pointer, 0, sizeof(pointer[0]));
- pointer->construct_type.kind = CONSTRUCT_POINTER;
- pointer->type_qualifiers = parse_type_qualifiers();
- pointer->base_variable = base_variable;
+ construct_type_t *cons = obstack_alloc(&temp_obst, sizeof(cons->pointer));
+ parsed_pointer_t *pointer = &cons->pointer;
+ memset(pointer, 0, sizeof(*pointer));
+ cons->kind = CONSTRUCT_POINTER;
+ pointer->type_qualifiers = parse_type_qualifiers();
+ pointer->base_variable = base_variable;
- return &pointer->construct_type;
+ return cons;
}
static construct_type_t *parse_reference_declarator(void)
{
eat('&');
- parsed_reference_t *reference = obstack_alloc(&temp_obst, sizeof(reference[0]));
- memset(reference, 0, sizeof(reference[0]));
- reference->construct_type.kind = CONSTRUCT_REFERENCE;
+ construct_type_t *cons = obstack_alloc(&temp_obst, sizeof(cons->reference));
+ parsed_reference_t *reference = &cons->reference;
+ memset(reference, 0, sizeof(*reference));
+ cons->kind = CONSTRUCT_REFERENCE;
- return (construct_type_t*)reference;
+ return cons;
}
static construct_type_t *parse_array_declarator(void)
eat('[');
add_anchor_token(']');
- parsed_array_t *array = obstack_alloc(&temp_obst, sizeof(array[0]));
- memset(array, 0, sizeof(array[0]));
- array->construct_type.kind = CONSTRUCT_ARRAY;
+ construct_type_t *cons = obstack_alloc(&temp_obst, sizeof(cons->array));
+ parsed_array_t *array = &cons->array;
+ memset(array, 0, sizeof(*array));
+ cons->kind = CONSTRUCT_ARRAY;
if (token.type == T_static) {
array->is_static = true;
expect(']', end_error);
end_error:
- return &array->construct_type;
+ return cons;
}
static construct_type_t *parse_function_declarator(scope_t *scope,
parse_parameters(ftype, scope);
- construct_function_type_t *construct_function_type =
- obstack_alloc(&temp_obst, sizeof(construct_function_type[0]));
- memset(construct_function_type, 0, sizeof(construct_function_type[0]));
- construct_function_type->construct_type.kind = CONSTRUCT_FUNCTION;
- construct_function_type->function_type = type;
+ construct_type_t *cons = obstack_alloc(&temp_obst, sizeof(cons->function));
+ construct_function_type_t *function = &cons->function;
+ memset(function, 0, sizeof(*function));
+ cons->kind = CONSTRUCT_FUNCTION;
+ function->function_type = type;
- return &construct_function_type->construct_type;
+ return cons;
}
typedef struct parse_declarator_env_t {
{
/* construct a single linked list of construct_type_t's which describe
* how to construct the final declarator type */
- construct_type_t *first = NULL;
- construct_type_t *last = NULL;
- gnu_attribute_t *attributes = NULL;
+ construct_type_t *first = NULL;
+ construct_type_t **anchor = &first;
+ gnu_attribute_t *attributes = NULL;
decl_modifiers_t modifiers = parse_attributes(&attributes);
- /* MS __based extension */
- based_spec_t base_spec;
- base_spec.base_variable = NULL;
-
for (;;) {
construct_type_t *type;
+ variable_t *based = NULL; /* MS __based extension */
switch (token.type) {
case '&':
if (!(c_mode & _CXX))
errorf(HERE, "references are only available for C++");
- if (base_spec.base_variable != NULL && warning.other) {
- warningf(&base_spec.source_position,
- "__based does not precede a pointer operator, ignored");
- }
type = parse_reference_declarator();
- /* consumed */
- base_spec.base_variable = NULL;
- break;
-
- case '*':
- type = parse_pointer_declarator(base_spec.base_variable);
- /* consumed */
- base_spec.base_variable = NULL;
break;
- case T__based:
+ case T__based: {
+ source_position_t const pos = *HERE;
next_token();
expect('(', end_error);
add_anchor_token(')');
- parse_microsoft_based(&base_spec);
+ based = parse_microsoft_based();
rem_anchor_token(')');
expect(')', end_error);
- continue;
+ if (token.type != '*') {
+ if (token.type == T__based) {
+ errorf(&pos, "__based type modifier specified more than once");
+ } else if (warning.other) {
+ warningf(&pos,
+ "__based does not precede a pointer declarator, ignored");
+ }
+ continue;
+ }
+ /* FALLTHROUGH */
+ }
+
+ case '*':
+ type = parse_pointer_declarator(based);
+ break;
default:
goto ptr_operator_end;
}
- if (last == NULL) {
- first = type;
- last = type;
- } else {
- last->next = type;
- last = type;
- }
+ *anchor = type;
+ anchor = &type->base.next;
/* TODO: find out if this is correct */
modifiers |= parse_attributes(&attributes);
}
ptr_operator_end:
- if (base_spec.base_variable != NULL && warning.other) {
- warningf(&base_spec.source_position,
- "__based does not precede a pointer operator, ignored");
- }
if (env != NULL) {
modifiers |= env->modifiers;
return NULL;
}
- construct_type_t *p = last;
+ construct_type_t **const p = anchor;
- while (true) {
+ for (;;) {
construct_type_t *type;
switch (token.type) {
case '(': {
goto declarator_finished;
}
- /* insert in the middle of the list (behind p) */
- if (p != NULL) {
- type->next = p->next;
- p->next = type;
- } else {
- type->next = first;
- first = type;
- }
- if (last == p) {
- last = type;
- }
+ /* insert in the middle of the list (at p) */
+ type->base.next = *p;
+ *p = type;
+ if (anchor == p)
+ anchor = &type->base.next;
}
declarator_finished:
- /* append inner_types at the end of the list, we don't to set last anymore
+ /* append inner_types at the end of the list, we don't to set anchor anymore
* as it's not needed anymore */
- if (last == NULL) {
- assert(first == NULL);
- first = inner_types;
- } else {
- last->next = inner_types;
- }
+ *anchor = inner_types;
return first;
end_error:
static type_t *construct_declarator_type(construct_type_t *construct_list, type_t *type)
{
construct_type_t *iter = construct_list;
- for (; iter != NULL; iter = iter->next) {
+ for (; iter != NULL; iter = iter->base.next) {
switch (iter->kind) {
case CONSTRUCT_INVALID:
- internal_errorf(HERE, "invalid type construction found");
+ break;
case CONSTRUCT_FUNCTION: {
- construct_function_type_t *construct_function_type
- = (construct_function_type_t*) iter;
-
- type_t *function_type = construct_function_type->function_type;
+ construct_function_type_t *function = &iter->function;
+ type_t *function_type = function->function_type;
function_type->function.return_type = type;
}
}
- type = function_type;
- break;
+ /* The function type was constructed earlier. Freeing it here will
+ * destroy other types. */
+ type = typehash_insert(function_type);
+ continue;
}
case CONSTRUCT_POINTER: {
if (is_type_reference(skip_typeref(type)))
errorf(HERE, "cannot declare a pointer to reference");
- parsed_pointer_t *parsed_pointer = (parsed_pointer_t*) iter;
- type = make_based_pointer_type(type, parsed_pointer->type_qualifiers, parsed_pointer->base_variable);
+ parsed_pointer_t *pointer = &iter->pointer;
+ type = make_based_pointer_type(type, pointer->type_qualifiers, pointer->base_variable);
continue;
}
if (is_type_reference(skip_typeref(type)))
errorf(HERE, "cannot declare an array of references");
- parsed_array_t *parsed_array = (parsed_array_t*) iter;
- type_t *array_type = allocate_type_zero(TYPE_ARRAY);
+ parsed_array_t *array = &iter->array;
+ type_t *array_type = allocate_type_zero(TYPE_ARRAY);
- expression_t *size_expression = parsed_array->size;
+ expression_t *size_expression = array->size;
if (size_expression != NULL) {
size_expression
= create_implicit_cast(size_expression, type_size_t);
}
- array_type->base.qualifiers = parsed_array->type_qualifiers;
+ array_type->base.qualifiers = array->type_qualifiers;
array_type->array.element_type = type;
- array_type->array.is_static = parsed_array->is_static;
- array_type->array.is_variable = parsed_array->is_variable;
+ array_type->array.is_static = array->is_static;
+ array_type->array.is_variable = array->is_variable;
array_type->array.size_expression = size_expression;
if (size_expression != NULL) {
} else if (is_type_function(skipped_type)) {
errorf(HERE, "array of functions is not allowed");
}
- type = array_type;
- break;
- }
+ type = identify_new_type(array_type);
+ continue;
}
-
- /* The function type was constructed earlier. Freeing it here will
- * destroy other types. */
- if (iter->kind == CONSTRUCT_FUNCTION) {
- type = typehash_insert(type);
- } else {
- type = identify_new_type(type);
}
+ internal_errorf(HERE, "invalid type construction found");
}
return type;
if (symbol == NULL)
return entity;
- entity_t *previous_entity = get_entity(symbol, namespc);
+ entity_t *const previous_entity = get_entity(symbol, namespc);
/* pushing the same entity twice will break the stack structure */
assert(previous_entity != entity);
entity->declaration.type, symbol);
}
- if (previous_entity != NULL &&
- previous_entity->base.parent_scope == ¤t_function->parameters &&
- previous_entity->base.parent_scope->depth + 1 == current_scope->depth) {
- assert(previous_entity->kind == ENTITY_PARAMETER);
- errorf(pos,
- "declaration '%#T' redeclares the parameter '%#T' (declared %P)",
- entity->declaration.type, symbol,
- previous_entity->declaration.type, symbol,
- &previous_entity->base.source_position);
- goto finish;
- }
-
- if (previous_entity != NULL &&
- previous_entity->base.parent_scope == current_scope) {
- if (previous_entity->kind != entity->kind) {
- if (!is_error_entity(previous_entity) && !is_error_entity(entity)) {
- error_redefined_as_different_kind(pos, previous_entity,
- entity->kind);
- }
- goto finish;
- }
- if (previous_entity->kind == ENTITY_ENUM_VALUE) {
- errorf(pos, "redeclaration of enum entry '%Y' (declared %P)",
- symbol, &previous_entity->base.source_position);
- goto finish;
- }
- if (previous_entity->kind == ENTITY_TYPEDEF) {
- /* TODO: C++ allows this for exactly the same type */
- errorf(pos, "redefinition of typedef '%Y' (declared %P)",
- symbol, &previous_entity->base.source_position);
+ if (previous_entity != NULL) {
+ if (previous_entity->base.parent_scope == ¤t_function->parameters &&
+ previous_entity->base.parent_scope->depth + 1 == current_scope->depth) {
+ assert(previous_entity->kind == ENTITY_PARAMETER);
+ errorf(pos,
+ "declaration '%#T' redeclares the parameter '%#T' (declared %P)",
+ entity->declaration.type, symbol,
+ previous_entity->declaration.type, symbol,
+ &previous_entity->base.source_position);
goto finish;
}
- /* at this point we should have only VARIABLES or FUNCTIONS */
- assert(is_declaration(previous_entity) && is_declaration(entity));
+ if (previous_entity->base.parent_scope == current_scope) {
+ if (previous_entity->kind != entity->kind) {
+ if (!is_error_entity(previous_entity) && !is_error_entity(entity)) {
+ error_redefined_as_different_kind(pos, previous_entity,
+ entity->kind);
+ }
+ goto finish;
+ }
+ if (previous_entity->kind == ENTITY_ENUM_VALUE) {
+ errorf(pos, "redeclaration of enum entry '%Y' (declared %P)",
+ symbol, &previous_entity->base.source_position);
+ goto finish;
+ }
+ if (previous_entity->kind == ENTITY_TYPEDEF) {
+ /* TODO: C++ allows this for exactly the same type */
+ errorf(pos, "redefinition of typedef '%Y' (declared %P)",
+ symbol, &previous_entity->base.source_position);
+ goto finish;
+ }
- declaration_t *const prev_decl = &previous_entity->declaration;
- declaration_t *const decl = &entity->declaration;
+ /* at this point we should have only VARIABLES or FUNCTIONS */
+ assert(is_declaration(previous_entity) && is_declaration(entity));
+
+ declaration_t *const prev_decl = &previous_entity->declaration;
+ declaration_t *const decl = &entity->declaration;
+
+ /* can happen for K&R style declarations */
+ if (prev_decl->type == NULL &&
+ previous_entity->kind == ENTITY_PARAMETER &&
+ entity->kind == ENTITY_PARAMETER) {
+ prev_decl->type = decl->type;
+ prev_decl->storage_class = decl->storage_class;
+ prev_decl->declared_storage_class = decl->declared_storage_class;
+ prev_decl->modifiers = decl->modifiers;
+ prev_decl->deprecated_string = decl->deprecated_string;
+ return previous_entity;
+ }
- /* can happen for K&R style declarations */
- if (prev_decl->type == NULL &&
- previous_entity->kind == ENTITY_PARAMETER &&
- entity->kind == ENTITY_PARAMETER) {
- prev_decl->type = decl->type;
- prev_decl->storage_class = decl->storage_class;
- prev_decl->declared_storage_class = decl->declared_storage_class;
- prev_decl->modifiers = decl->modifiers;
- prev_decl->deprecated_string = decl->deprecated_string;
- return previous_entity;
- }
+ type_t *const orig_type = decl->type;
+ assert(orig_type != NULL);
+ type_t *const type = skip_typeref(orig_type);
+ type_t *const prev_type = skip_typeref(prev_decl->type);
- type_t *const orig_type = decl->type;
- assert(orig_type != NULL);
- type_t *const type = skip_typeref(orig_type);
- type_t *const prev_type = skip_typeref(prev_decl->type);
+ if (!types_compatible(type, prev_type)) {
+ errorf(pos,
+ "declaration '%#T' is incompatible with '%#T' (declared %P)",
+ orig_type, symbol, prev_decl->type, symbol,
+ &previous_entity->base.source_position);
+ } else {
+ unsigned old_storage_class = prev_decl->storage_class;
+ if (warning.redundant_decls &&
+ is_definition &&
+ !prev_decl->used &&
+ !(prev_decl->modifiers & DM_USED) &&
+ prev_decl->storage_class == STORAGE_CLASS_STATIC) {
+ warningf(&previous_entity->base.source_position,
+ "unnecessary static forward declaration for '%#T'",
+ prev_decl->type, symbol);
+ }
- if (!types_compatible(type, prev_type)) {
- errorf(pos,
- "declaration '%#T' is incompatible with '%#T' (declared %P)",
- orig_type, symbol, prev_decl->type, symbol,
- &previous_entity->base.source_position);
- } else {
- unsigned old_storage_class = prev_decl->storage_class;
- if (warning.redundant_decls &&
- is_definition &&
- !prev_decl->used &&
- !(prev_decl->modifiers & DM_USED) &&
- prev_decl->storage_class == STORAGE_CLASS_STATIC) {
- warningf(&previous_entity->base.source_position,
- "unnecessary static forward declaration for '%#T'",
- prev_decl->type, symbol);
- }
-
- storage_class_t new_storage_class = decl->storage_class;
-
- /* pretend no storage class means extern for function
- * declarations (except if the previous declaration is neither
- * none nor extern) */
- if (entity->kind == ENTITY_FUNCTION) {
- /* the previous declaration could have unspecified parameters or
- * be a typedef, so use the new type */
- if (prev_type->function.unspecified_parameters || is_definition)
- prev_decl->type = type;
+ storage_class_t new_storage_class = decl->storage_class;
+
+ /* pretend no storage class means extern for function
+ * declarations (except if the previous declaration is neither
+ * none nor extern) */
+ if (entity->kind == ENTITY_FUNCTION) {
+ /* the previous declaration could have unspecified parameters or
+ * be a typedef, so use the new type */
+ if (prev_type->function.unspecified_parameters || is_definition)
+ prev_decl->type = type;
+
+ switch (old_storage_class) {
+ case STORAGE_CLASS_NONE:
+ old_storage_class = STORAGE_CLASS_EXTERN;
+ /* FALLTHROUGH */
+
+ case STORAGE_CLASS_EXTERN:
+ if (is_definition) {
+ if (warning.missing_prototypes &&
+ prev_type->function.unspecified_parameters &&
+ !is_sym_main(symbol)) {
+ warningf(pos, "no previous prototype for '%#T'",
+ orig_type, symbol);
+ }
+ } else if (new_storage_class == STORAGE_CLASS_NONE) {
+ new_storage_class = STORAGE_CLASS_EXTERN;
+ }
+ break;
- switch (old_storage_class) {
- case STORAGE_CLASS_NONE:
- old_storage_class = STORAGE_CLASS_EXTERN;
- /* FALLTHROUGH */
-
- case STORAGE_CLASS_EXTERN:
- if (is_definition) {
- if (warning.missing_prototypes &&
- prev_type->function.unspecified_parameters &&
- !is_sym_main(symbol)) {
- warningf(pos, "no previous prototype for '%#T'",
- orig_type, symbol);
- }
- } else if (new_storage_class == STORAGE_CLASS_NONE) {
- new_storage_class = STORAGE_CLASS_EXTERN;
+ default:
+ break;
}
- break;
-
- default:
- break;
+ } else if (is_type_incomplete(prev_type)) {
+ prev_decl->type = type;
}
- } else if (is_type_incomplete(prev_type)) {
- prev_decl->type = type;
- }
- if (old_storage_class == STORAGE_CLASS_EXTERN &&
- new_storage_class == STORAGE_CLASS_EXTERN) {
+ if (old_storage_class == STORAGE_CLASS_EXTERN &&
+ new_storage_class == STORAGE_CLASS_EXTERN) {
warn_redundant_declaration:
- if (!is_definition &&
- warning.redundant_decls &&
- is_type_valid(prev_type) &&
- strcmp(previous_entity->base.source_position.input_name,
- "<builtin>") != 0) {
- warningf(pos,
- "redundant declaration for '%Y' (declared %P)",
- symbol, &previous_entity->base.source_position);
- }
- } else if (current_function == NULL) {
- if (old_storage_class != STORAGE_CLASS_STATIC &&
- new_storage_class == STORAGE_CLASS_STATIC) {
- errorf(pos,
- "static declaration of '%Y' follows non-static declaration (declared %P)",
- symbol, &previous_entity->base.source_position);
- } else if (old_storage_class == STORAGE_CLASS_EXTERN) {
- prev_decl->storage_class = STORAGE_CLASS_NONE;
- prev_decl->declared_storage_class = STORAGE_CLASS_NONE;
- } else {
- /* ISO/IEC 14882:1998(E) §C.1.2:1 */
- if (c_mode & _CXX)
- goto error_redeclaration;
- goto warn_redundant_declaration;
- }
- } else if (is_type_valid(prev_type)) {
- if (old_storage_class == new_storage_class) {
+ if (!is_definition &&
+ warning.redundant_decls &&
+ is_type_valid(prev_type) &&
+ strcmp(previous_entity->base.source_position.input_name,
+ "<builtin>") != 0) {
+ warningf(pos,
+ "redundant declaration for '%Y' (declared %P)",
+ symbol, &previous_entity->base.source_position);
+ }
+ } else if (current_function == NULL) {
+ if (old_storage_class != STORAGE_CLASS_STATIC &&
+ new_storage_class == STORAGE_CLASS_STATIC) {
+ errorf(pos,
+ "static declaration of '%Y' follows non-static declaration (declared %P)",
+ symbol, &previous_entity->base.source_position);
+ } else if (old_storage_class == STORAGE_CLASS_EXTERN) {
+ prev_decl->storage_class = STORAGE_CLASS_NONE;
+ prev_decl->declared_storage_class = STORAGE_CLASS_NONE;
+ } else {
+ /* ISO/IEC 14882:1998(E) §C.1.2:1 */
+ if (c_mode & _CXX)
+ goto error_redeclaration;
+ goto warn_redundant_declaration;
+ }
+ } else if (is_type_valid(prev_type)) {
+ if (old_storage_class == new_storage_class) {
error_redeclaration:
- errorf(pos, "redeclaration of '%Y' (declared %P)",
- symbol, &previous_entity->base.source_position);
- } else {
- errorf(pos,
- "redeclaration of '%Y' with different linkage (declared %P)",
- symbol, &previous_entity->base.source_position);
+ errorf(pos, "redeclaration of '%Y' (declared %P)",
+ symbol, &previous_entity->base.source_position);
+ } else {
+ errorf(pos,
+ "redeclaration of '%Y' with different linkage (declared %P)",
+ symbol, &previous_entity->base.source_position);
+ }
}
}
+
+ prev_decl->modifiers |= decl->modifiers;
+ if (entity->kind == ENTITY_FUNCTION) {
+ previous_entity->function.is_inline |= entity->function.is_inline;
+ }
+ return previous_entity;
}
- prev_decl->modifiers |= decl->modifiers;
- if (entity->kind == ENTITY_FUNCTION) {
- previous_entity->function.is_inline |= entity->function.is_inline;
+ if (warning.shadow) {
+ warningf(pos, "%s '%Y' shadows %s (declared %P)",
+ get_entity_kind_name(entity->kind), symbol,
+ get_entity_kind_name(previous_entity->kind),
+ &previous_entity->base.source_position);
}
- return previous_entity;
}
if (entity->kind == ENTITY_FUNCTION) {
/* §6.7:7 If an identifier for an object is declared with no linkage, the
* type for the object shall be complete [...] */
declaration_t *decl = &ent->declaration;
- if (decl->storage_class != STORAGE_CLASS_NONE)
+ if (decl->storage_class == STORAGE_CLASS_EXTERN ||
+ decl->storage_class == STORAGE_CLASS_STATIC)
return;
type_t *const orig_type = decl->type;
type_t *type = skip_typeref(orig_type);
if (is_type_integer(type)) {
result = promote_integer(type);
- } else if (type == type_float) {
+ } else if (is_type_atomic(type, ATOMIC_TYPE_FLOAT)) {
result = type_double;
}
/* update function type */
type_t *new_type = duplicate_type(type);
- function_parameter_t *parameters = NULL;
- function_parameter_t *last_parameter = NULL;
+ function_parameter_t *parameters = NULL;
+ function_parameter_t **anchor = ¶meters;
parameter = entity->function.parameters.entities;
for (; parameter != NULL; parameter = parameter->base.next) {
*/
parameter_type = get_default_promoted_type(parameter_type);
- function_parameter_t *function_parameter
- = obstack_alloc(type_obst, sizeof(function_parameter[0]));
- memset(function_parameter, 0, sizeof(function_parameter[0]));
+ function_parameter_t *const parameter =
+ allocate_parameter(parameter_type);
- function_parameter->type = parameter_type;
- if (last_parameter != NULL) {
- last_parameter->next = function_parameter;
- } else {
- parameters = function_parameter;
- }
- last_parameter = function_parameter;
+ *anchor = parameter;
+ anchor = ¶meter->next;
}
/* §6.9.1.7: A K&R style parameter list does NOT act as a function
case EXPR_SIZEOF: // TODO handle obscure VLA case
case EXPR_ALIGNOF:
case EXPR_FUNCNAME:
- case EXPR_BUILTIN_SYMBOL:
case EXPR_BUILTIN_CONSTANT_P:
case EXPR_BUILTIN_TYPES_COMPATIBLE_P:
case EXPR_OFFSETOF:
entity->base.symbol, orig_type);
} else if (is_type_incomplete(type)) {
/* §6.7.2.1:16 flexible array member */
- if (is_type_array(type) &&
- token.type == ';' &&
- look_ahead(1)->type == '}') {
- compound->has_flexible_member = true;
- } else {
+ if (!is_type_array(type) ||
+ token.type != ';' ||
+ look_ahead(1)->type != '}') {
errorf(&entity->base.source_position,
"compound member '%Y' has incomplete type '%T'",
entity->base.symbol, orig_type);
static type_t *make_function_2_type(type_t *return_type, type_t *argument_type1,
type_t *argument_type2)
{
- function_parameter_t *parameter2
- = obstack_alloc(type_obst, sizeof(parameter2[0]));
- memset(parameter2, 0, sizeof(parameter2[0]));
- parameter2->type = argument_type2;
-
- function_parameter_t *parameter1
- = obstack_alloc(type_obst, sizeof(parameter1[0]));
- memset(parameter1, 0, sizeof(parameter1[0]));
- parameter1->type = argument_type1;
+ function_parameter_t *const parameter2 = allocate_parameter(argument_type2);
+ function_parameter_t *const parameter1 = allocate_parameter(argument_type1);
parameter1->next = parameter2;
type_t *type = allocate_type_zero(TYPE_FUNCTION);
*/
static type_t *make_function_1_type(type_t *return_type, type_t *argument_type)
{
- function_parameter_t *parameter
- = obstack_alloc(type_obst, sizeof(parameter[0]));
- memset(parameter, 0, sizeof(parameter[0]));
- parameter->type = argument_type;
+ function_parameter_t *const parameter = allocate_parameter(argument_type);
type_t *type = allocate_type_zero(TYPE_FUNCTION);
type->function.return_type = return_type;
}
/**
- * Creates a function type for some function like builtins.
+ * Creates a NO_RETURN return_type (func)(void) function type if not
+ * already exists.
*
- * @param symbol the symbol describing the builtin
- */
-static type_t *get_builtin_symbol_type(symbol_t *symbol)
-{
- switch (symbol->ID) {
- case T___builtin_alloca:
- return make_function_1_type(type_void_ptr, type_size_t);
- case T___builtin_huge_val:
- return make_function_0_type(type_double);
- case T___builtin_inf:
- return make_function_0_type(type_double);
- case T___builtin_inff:
- return make_function_0_type(type_float);
- case T___builtin_infl:
- return make_function_0_type(type_long_double);
- case T___builtin_nan:
- return make_function_1_type(type_double, type_char_ptr);
- case T___builtin_nanf:
- return make_function_1_type(type_float, type_char_ptr);
- case T___builtin_nanl:
- return make_function_1_type(type_long_double, type_char_ptr);
- case T___builtin_va_end:
- return make_function_1_type(type_void, type_valist);
- case T___builtin_expect:
- return make_function_2_type(type_long, type_long, type_long);
- case T___builtin_return_address:
- case T___builtin_frame_address:
- return make_function_1_type(type_void_ptr, type_unsigned_int);
- case T___builtin_prefetch:
- return make_function_1_type_variadic(type_float, type_void_ptr);
- default:
- internal_errorf(HERE, "not implemented builtin identifier found");
- }
+ * @param return_type the return type
+ */
+static type_t *make_function_0_type_noreturn(type_t *return_type)
+{
+ type_t *type = allocate_type_zero(TYPE_FUNCTION);
+ type->function.return_type = return_type;
+ type->function.parameters = NULL;
+ type->function.base.modifiers |= DM_NORETURN;
+ return type;
+
+ return identify_new_type(type);
}
/**
return type->pointer.points_to;
}
- case EXPR_BUILTIN_SYMBOL:
- return get_builtin_symbol_type(expression->builtin_symbol.symbol);
-
case EXPR_ARRAY_ACCESS: {
const expression_t *array_ref = expression->array_access.array_ref;
type_t *type_left = skip_typeref(array_ref->base.type);
return create_invalid_expression();
}
-static expression_t *parse_builtin_symbol(void)
-{
- expression_t *expression = allocate_expression_zero(EXPR_BUILTIN_SYMBOL);
-
- symbol_t *symbol = token.v.symbol;
-
- expression->builtin_symbol.symbol = symbol;
- next_token();
-
- type_t *type = get_builtin_symbol_type(symbol);
- type = automatic_type_conversion(type);
-
- expression->base.type = type;
- return expression;
-}
-
/**
* Parses a __builtin_constant_p() expression.
*/
case T___builtin_offsetof: return parse_offsetof();
case T___builtin_va_start: return parse_va_start();
case T___builtin_va_arg: return parse_va_arg();
- case T___builtin_expect:
- case T___builtin_alloca:
- case T___builtin_inf:
- case T___builtin_inff:
- case T___builtin_infl:
- case T___builtin_nan:
- case T___builtin_nanf:
- case T___builtin_nanl:
- case T___builtin_huge_val:
- case T___builtin_va_end:
- case T___builtin_return_address:
- case T___builtin_frame_address:
- case T___builtin_prefetch: return parse_builtin_symbol();
case T___builtin_isgreater:
case T___builtin_isgreaterequal:
case T___builtin_isless:
* Handle the semantic restrictions of builtin calls
*/
static void handle_builtin_argument_restrictions(call_expression_t *call) {
- switch (call->function->builtin_symbol.symbol->ID) {
- case T___builtin_return_address:
- case T___builtin_frame_address: {
+ switch (call->function->reference.entity->function.btk) {
+ case bk_gnu_builtin_return_address:
+ case bk_gnu_builtin_frame_address: {
/* argument must be constant */
call_argument_t *argument = call->arguments;
if (! is_constant_expression(argument->expression)) {
errorf(&call->base.source_position,
"argument of '%Y' must be a constant expression",
- call->function->builtin_symbol.symbol);
+ call->function->reference.entity->base.symbol);
}
break;
}
- case T___builtin_prefetch: {
- /* second and third argument must be constant if existant */
+ case bk_gnu_builtin_prefetch: {
+ /* second and third argument must be constant if existent */
call_argument_t *rw = call->arguments->next;
call_argument_t *locality = NULL;
if (! is_constant_expression(rw->expression)) {
errorf(&call->base.source_position,
"second argument of '%Y' must be a constant expression",
- call->function->builtin_symbol.symbol);
+ call->function->reference.entity->base.symbol);
}
locality = rw->next;
}
if (! is_constant_expression(locality->expression)) {
errorf(&call->base.source_position,
"third argument of '%Y' must be a constant expression",
- call->function->builtin_symbol.symbol);
+ call->function->reference.entity->base.symbol);
}
locality = rw->next;
}
add_anchor_token(',');
if (token.type != ')') {
- call_argument_t *last_argument = NULL;
-
- while (true) {
- call_argument_t *argument = allocate_ast_zero(sizeof(argument[0]));
-
+ call_argument_t **anchor = &call->arguments;
+ for (;;) {
+ call_argument_t *argument = allocate_ast_zero(sizeof(*argument));
argument->expression = parse_assignment_expression();
- if (last_argument == NULL) {
- call->arguments = argument;
- } else {
- last_argument->next = argument;
- }
- last_argument = argument;
+
+ *anchor = argument;
+ anchor = &argument->next;
if (token.type != ',')
break;
"function call has aggregate value");
}
- if (call->function->kind == EXPR_BUILTIN_SYMBOL) {
- handle_builtin_argument_restrictions(&result->call);
+ if (call->function->kind == EXPR_REFERENCE) {
+ reference_expression_t *reference = &call->function->reference;
+ if (reference->entity->kind == ENTITY_FUNCTION &&
+ reference->entity->function.btk != bk_none)
+ handle_builtin_argument_restrictions(call);
}
end_error:
case EXPR_CALL: {
const call_expression_t *const call = &expr->call;
- if (call->function->kind != EXPR_BUILTIN_SYMBOL)
+ if (call->function->kind != EXPR_REFERENCE)
return true;
- switch (call->function->builtin_symbol.symbol->ID) {
- case T___builtin_prefetch:
- case T___builtin_va_end: return true;
- default: return false;
+ switch (call->function->reference.entity->function.btk) {
+ /* FIXME: which builtins have no effect? */
+ default: return true;
}
}
case EXPR_ALIGNOF: return false;
case EXPR_FUNCNAME: return false;
- case EXPR_BUILTIN_SYMBOL: break; /* handled in EXPR_CALL */
case EXPR_BUILTIN_CONSTANT_P: return false;
case EXPR_BUILTIN_TYPES_COMPATIBLE_P: return false;
case EXPR_OFFSETOF: return false;
assert(current_scope == NULL);
scope_push(&unit->scope);
+
+ create_gnu_builtins();
+ if (c_mode & _MS)
+ create_microsoft_intrinsics();
}
translation_unit_t *finish_parsing(void)
incomplete_arrays = NULL;
}
+/**
+ * create a builtin function.
+ */
+static entity_t *create_builtin_function(builtin_kind_t kind, const char *name, type_t *function_type)
+{
+ symbol_t *symbol = symbol_table_insert(name);
+ entity_t *entity = allocate_entity_zero(ENTITY_FUNCTION);
+ entity->declaration.storage_class = STORAGE_CLASS_EXTERN;
+ entity->declaration.declared_storage_class = STORAGE_CLASS_EXTERN;
+ entity->declaration.type = function_type;
+ entity->declaration.implicit = true;
+ entity->base.symbol = symbol;
+ entity->base.source_position = builtin_source_position;
+
+ entity->function.btk = kind;
+
+ record_entity(entity, /*is_definition=*/false);
+ return entity;
+}
+
+
+/**
+ * Create predefined gnu builtins.
+ */
+static void create_gnu_builtins(void)
+{
+#define GNU_BUILTIN(a, b) create_builtin_function(bk_gnu_builtin_##a, "__builtin_" #a, b)
+
+ GNU_BUILTIN(alloca, make_function_1_type(type_void_ptr, type_size_t));
+ GNU_BUILTIN(huge_val, make_function_0_type(type_double));
+ GNU_BUILTIN(inf, make_function_0_type(type_double));
+ GNU_BUILTIN(inff, make_function_0_type(type_float));
+ GNU_BUILTIN(infl, make_function_0_type(type_long_double));
+ GNU_BUILTIN(nan, make_function_1_type(type_double, type_char_ptr));
+ GNU_BUILTIN(nanf, make_function_1_type(type_float, type_char_ptr));
+ GNU_BUILTIN(nanl, make_function_1_type(type_long_double, type_char_ptr));
+ GNU_BUILTIN(va_end, make_function_1_type(type_void, type_valist));
+ GNU_BUILTIN(expect, make_function_2_type(type_long, type_long, type_long));
+ GNU_BUILTIN(return_address, make_function_1_type(type_void_ptr, type_unsigned_int));
+ GNU_BUILTIN(frame_address, make_function_1_type(type_void_ptr, type_unsigned_int));
+ GNU_BUILTIN(ffs, make_function_1_type(type_int, type_unsigned_int));
+ GNU_BUILTIN(clz, make_function_1_type(type_int, type_unsigned_int));
+ GNU_BUILTIN(ctz, make_function_1_type(type_int, type_unsigned_int));
+ GNU_BUILTIN(popcount, make_function_1_type(type_int, type_unsigned_int));
+ GNU_BUILTIN(parity, make_function_1_type(type_int, type_unsigned_int));
+ GNU_BUILTIN(prefetch, make_function_1_type_variadic(type_float, type_void_ptr));
+ GNU_BUILTIN(trap, make_function_0_type_noreturn(type_void));
+
+#undef GNU_BUILTIN
+}
+
+/**
+ * Create predefined MS intrinsics.
+ */
+static void create_microsoft_intrinsics(void)
+{
+#define MS_BUILTIN(a, b) create_builtin_function(bk_ms##a, #a, b)
+
+ /* intrinsics for all architectures */
+ MS_BUILTIN(_rotl, make_function_2_type(type_unsigned_int, type_unsigned_int, type_int));
+ MS_BUILTIN(_rotr, make_function_2_type(type_unsigned_int, type_unsigned_int, type_int));
+ MS_BUILTIN(_rotl64, make_function_2_type(type_unsigned_int64, type_unsigned_int64, type_int));
+ MS_BUILTIN(_rotr64, make_function_2_type(type_unsigned_int64, type_unsigned_int64, type_int));
+ MS_BUILTIN(_byteswap_ushort, make_function_1_type(type_unsigned_short, type_unsigned_short));
+ MS_BUILTIN(_byteswap_ulong, make_function_1_type(type_unsigned_long, type_unsigned_long));
+ MS_BUILTIN(_byteswap_uint64, make_function_1_type(type_unsigned_int64, type_unsigned_int64));
+
+ MS_BUILTIN(__debugbreak, make_function_0_type(type_void));
+ MS_BUILTIN(_ReturnAddress, make_function_0_type(type_void_ptr));
+ MS_BUILTIN(__popcount, make_function_1_type(type_unsigned_int, type_unsigned_int));
+
+ /* x86/x64 only */
+ MS_BUILTIN(_enable, make_function_0_type(type_void));
+ MS_BUILTIN(_disable, make_function_0_type(type_void));
+ MS_BUILTIN(__inbyte, make_function_1_type(type_unsigned_char, type_unsigned_short));
+ MS_BUILTIN(__inword, make_function_1_type(type_unsigned_short, type_unsigned_short));
+ MS_BUILTIN(__indword, make_function_1_type(type_unsigned_long, type_unsigned_short));
+ MS_BUILTIN(__outbyte, make_function_2_type(type_void, type_unsigned_short, type_unsigned_char));
+ MS_BUILTIN(__outword, make_function_2_type(type_void, type_unsigned_short, type_unsigned_short));
+ MS_BUILTIN(__outdword, make_function_2_type(type_void, type_unsigned_short, type_unsigned_long));
+ MS_BUILTIN(__ud2, make_function_0_type_noreturn(type_void));
+ MS_BUILTIN(_BitScanForward, make_function_2_type(type_unsigned_char, type_unsigned_long_ptr, type_unsigned_long));
+ MS_BUILTIN(_BitScanReverse, make_function_2_type(type_unsigned_char, type_unsigned_long_ptr, type_unsigned_long));
+ MS_BUILTIN(_InterlockedExchange, make_function_2_type(type_long, type_long_ptr, type_long));
+ MS_BUILTIN(_InterlockedExchange64, make_function_2_type(type_int64, type_int64_ptr, type_int64));
+
+ if (machine_size <= 32) {
+ MS_BUILTIN(__readeflags, make_function_0_type(type_unsigned_int));
+ MS_BUILTIN(__writeeflags, make_function_1_type(type_void, type_unsigned_int));
+ } else {
+ MS_BUILTIN(__readeflags, make_function_0_type(type_unsigned_int64));
+ MS_BUILTIN(__writeeflags, make_function_1_type(type_void, type_unsigned_int64));
+ }
+
+#undef MS_BUILTIN
+}
+
/**
* Initialize the parser.
*/
projects / cparser / blobdiff