From Evan Shaw.
From-SVN: r172882
features such as %<%> for appropriate quoting.
+ Localization may be an issue.
-* Use of gcc_unreachable.
-
This compiler works, but the code is a work in progress. Notably, the
support for garbage collection is ineffective and needs a complete
rethinking. The frontend pays little attention to its memory usage
// We can't have two variables with the same name in the same
// location.
- gcc_unreachable();
+ go_unreachable();
}
// Class Dataflow.
void
Expression::do_export(Export*) const
{
- gcc_unreachable();
+ go_unreachable();
}
// Warn that the value of the expression is not used.
return build_complex(type, real, imag);
}
else
- gcc_unreachable();
+ go_unreachable();
}
// Return a tree for VAL in TYPE.
return build_complex(type, build_real(TREE_TYPE(type), r2), imag);
}
else
- gcc_unreachable();
+ go_unreachable();
}
// Return a tree for REAL/IMAG in TYPE.
build_real(TREE_TYPE(type), r4));
}
else
- gcc_unreachable();
+ go_unreachable();
}
// Return a tree which evaluates to true if VAL, of arbitrary integer
tree
do_get_tree(Translate_context*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
private:
// The type which we are representing as an expression.
else if (this->variable_->is_result_variable())
return this->variable_->result_var_value()->type();
else
- gcc_unreachable();
+ go_unreachable();
}
// Determine the type of a reference to a variable.
else if (this->variable_->is_result_variable())
this->variable_->result_var_value()->set_address_taken();
else
- gcc_unreachable();
+ go_unreachable();
}
// Get the tree for a reference to a variable.
else if (this->variable_->is_result_variable())
is_in_heap = this->variable_->result_var_value()->is_in_heap();
else
- gcc_unreachable();
+ go_unreachable();
if (is_in_heap)
{
ret = build_fold_indirect_ref_loc(this->location(), ret);
else if (this->function_->is_function_declaration())
return this->function_->func_declaration_value()->type();
else
- gcc_unreachable();
+ go_unreachable();
}
// Get the tree for a function expression without evaluating the
else if (this->function_->is_function_declaration())
fntype = this->function_->func_declaration_value()->type();
else
- gcc_unreachable();
+ go_unreachable();
// Builtin functions are handled specially by Call_expression. We
// can't take their address.
else if (no->is_function_declaration())
fndecl = no->func_declaration_value()->get_or_make_decl(gogo, no, id);
else
- gcc_unreachable();
+ go_unreachable();
if (fndecl == error_mark_node)
return error_mark_node;
error_at(location, "unexpected reference to package");
return Expression::make_error(location);
default:
- gcc_unreachable();
+ go_unreachable();
}
}
max_exp = 1024;
break;
default:
- gcc_unreachable();
+ go_unreachable();
}
if (exp > max_exp)
{
max_exp = 1024;
break;
default:
- gcc_unreachable();
+ go_unreachable();
}
// A NaN or Infinity always fits in the range of the type.
else if (TREE_CODE(type_tree) == COMPLEX_TYPE)
ret = fold(convert_to_complex(type_tree, const_tree));
else
- gcc_unreachable();
+ go_unreachable();
return ret;
}
protected:
Expression*
do_lower(Gogo*, Named_object*, int)
- { gcc_unreachable(); }
+ { go_unreachable(); }
// There should only ever be one of these.
Expression*
do_copy()
- { gcc_unreachable(); }
+ { go_unreachable(); }
};
// Make an iota expression. This is only called for one case: the
|| expr_type->is_unsafe_pointer_type())
ret = fold(convert_to_integer(type_tree, expr_tree));
else
- gcc_unreachable();
+ go_unreachable();
}
else if (type->float_type() != NULL)
{
|| expr_type->float_type() != NULL)
ret = fold(convert_to_real(type_tree, expr_tree));
else
- gcc_unreachable();
+ go_unreachable();
}
else if (type->complex_type() != NULL)
{
if (expr_type->complex_type() != NULL)
ret = fold(convert_to_complex(type_tree, expr_tree));
else
- gcc_unreachable();
+ go_unreachable();
}
else if (type->is_string_type()
&& expr_type->integer_type() != NULL)
return convert_to_integer(type_tree, expr_tree);
}
else
- gcc_unreachable();
+ go_unreachable();
if (use_view_convert)
return fold_build1_loc(loc, VIEW_CONVERT_EXPR, type_tree, expr_tree);
case OPERATOR_MULT:
return false;
default:
- gcc_unreachable();
+ go_unreachable();
}
}
case OPERATOR_MULT:
return false;
default:
- gcc_unreachable();
+ go_unreachable();
}
}
case OPERATOR_MULT:
return false;
default:
- gcc_unreachable();
+ go_unreachable();
}
}
}
default:
- gcc_unreachable();
+ go_unreachable();
}
}
break;
default:
- gcc_unreachable();
+ go_unreachable();
}
}
break;
default:
- gcc_unreachable();
+ go_unreachable();
}
}
}
default:
- gcc_unreachable();
+ go_unreachable();
}
}
case OPERATOR_AND:
case OPERATOR_MULT:
default:
- gcc_unreachable();
+ go_unreachable();
}
this->expr_->export_expression(exp);
}
op = OPERATOR_XOR;
break;
default:
- gcc_unreachable();
+ go_unreachable();
}
imp->require_c_string(" ");
Expression* expr = Expression::import_expression(imp);
case OPERATOR_GE:
return i >= 0;
default:
- gcc_unreachable();
+ go_unreachable();
}
}
case OPERATOR_GE:
return i >= 0;
default:
- gcc_unreachable();
+ go_unreachable();
}
}
case OPERATOR_NOTEQ:
return !is_equal;
default:
- gcc_unreachable();
+ go_unreachable();
}
}
}
break;
default:
- gcc_unreachable();
+ go_unreachable();
}
Type* type = left_type;
case OPERATOR_RSHIFT:
return false;
default:
- gcc_unreachable();
+ go_unreachable();
}
Type* type = left_type;
case OPERATOR_RSHIFT:
return false;
default:
- gcc_unreachable();
+ go_unreachable();
}
Type* type = left_type;
return this->left_->type();
default:
- gcc_unreachable();
+ go_unreachable();
}
}
break;
default:
- gcc_unreachable();
+ go_unreachable();
}
return true;
code = BIT_AND_EXPR;
break;
default:
- gcc_unreachable();
+ go_unreachable();
}
tree type = use_left_type ? TREE_TYPE(left) : TREE_TYPE(right);
exp->write_c_string(" &^ ");
break;
default:
- gcc_unreachable();
+ go_unreachable();
}
this->right_->export_expression(exp);
exp->write_c_string(")");
code = GE_EXPR;
break;
default:
- gcc_unreachable();
+ go_unreachable();
}
if (left_type->is_string_type() && right_type->is_string_type())
else if (name == "Sizeof")
this->code_ = BUILTIN_SIZEOF;
else
- gcc_unreachable();
+ go_unreachable();
}
// Return whether this is a call to recover. This is a virtual
}
}
else
- gcc_unreachable();
+ go_unreachable();
mpz_set_ui(val, val_long);
*ptype = NULL;
return true;
{
case BUILTIN_INVALID:
default:
- gcc_unreachable();
+ go_unreachable();
case BUILTIN_NEW:
case BUILTIN_MAKE:
else if (atype->is_abstract_boolean_type())
want_type = Type::lookup_bool_type();
else
- gcc_unreachable();
+ go_unreachable();
subcontext.type = want_type;
}
}
break;
default:
- gcc_unreachable();
+ go_unreachable();
}
}
case BUILTIN_INVALID:
case BUILTIN_NEW:
case BUILTIN_MAKE:
- gcc_unreachable();
+ go_unreachable();
case BUILTIN_LEN:
case BUILTIN_CAP:
arg_tree);
}
else
- gcc_unreachable();
+ go_unreachable();
}
else
{
arg_tree);
}
else
- gcc_unreachable();
+ go_unreachable();
}
if (val_tree == error_mark_node)
fnname = "__go_print_slice";
}
else
- gcc_unreachable();
+ go_unreachable();
tree call = Gogo::call_builtin(pfndecl,
location,
}
default:
- gcc_unreachable();
+ go_unreachable();
}
}
void
Call_expression::do_set_recover_arg(Expression*)
{
- gcc_unreachable();
+ go_unreachable();
}
// Get the type.
else if (interface_method != NULL)
fn = this->interface_method_function(context, interface_method, &args[0]);
else
- gcc_unreachable();
+ go_unreachable();
if (fn == error_mark_node || TREE_TYPE(fn) == error_mark_node)
{
tree
Interface_field_reference_expression::do_get_tree(Translate_context*)
{
- gcc_unreachable();
+ go_unreachable();
}
// Make a reference to a field in an interface.
// this in global scope.
void
do_export(Export*) const
- { gcc_unreachable(); }
+ { go_unreachable(); }
private:
// The composite literal which is being put on the heap.
case TYPE_INFO_FIELD_ALIGNMENT:
return Type::lookup_integer_type("uint8");
default:
- gcc_unreachable();
+ go_unreachable();
}
}
void
do_determine_type(const Type_context*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
void
do_check_types(Gogo*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
tree
do_get_tree(Translate_context*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
};
// An expression which is simply a variable.
case NAMED_OBJECT_VAR:
case NAMED_OBJECT_RESULT_VAR:
case NAMED_OBJECT_SINK:
- gcc_unreachable();
+ go_unreachable();
case NAMED_OBJECT_FUNC:
{
break;
default:
- gcc_unreachable();
+ go_unreachable();
}
if (TREE_TYPE(decl) == error_mark_node)
fndecl = no->func_declaration_value()->get_or_make_decl(this, no,
fnid);
else
- gcc_unreachable();
+ go_unreachable();
fndecl = build_fold_addr_expr(fndecl);
elt = VEC_quick_push(constructor_elt, pointers, NULL);
function);
}
else
- gcc_unreachable();
+ go_unreachable();
}
this->package_->bindings()->add_method(ret);
}
return ftype->add_method_declaration(name, type, location);
}
else
- gcc_unreachable();
+ go_unreachable();
}
}
case Named_object::NAMED_OBJECT_FUNC:
case Named_object::NAMED_OBJECT_FUNC_DECLARATION:
// FIXME: Where will nested functions be found?
- gcc_unreachable();
+ go_unreachable();
case Named_object::NAMED_OBJECT_TYPE:
if ((traverse_mask & Traverse::traverse_types) != 0
case Named_object::NAMED_OBJECT_PACKAGE:
case Named_object::NAMED_OBJECT_SINK:
- gcc_unreachable();
+ go_unreachable();
default:
- gcc_unreachable();
+ go_unreachable();
}
}
}
{
default:
case NAMED_OBJECT_UNINITIALIZED:
- gcc_unreachable();
+ go_unreachable();
case NAMED_OBJECT_UNKNOWN:
return this->unknown_value()->location();
return this->result_var_value()->location();
case NAMED_OBJECT_SINK:
- gcc_unreachable();
+ go_unreachable();
case NAMED_OBJECT_FUNC:
return this->func_value()->location();
default:
case NAMED_OBJECT_UNINITIALIZED:
case NAMED_OBJECT_UNKNOWN:
- gcc_unreachable();
+ go_unreachable();
case NAMED_OBJECT_CONST:
this->const_value()->export_const(exp, this->name_);
case NAMED_OBJECT_RESULT_VAR:
case NAMED_OBJECT_SINK:
- gcc_unreachable();
+ go_unreachable();
case NAMED_OBJECT_FUNC:
this->func_value()->export_func(exp, this->name_);
return this->result_var_value()->get_backend_variable(gogo, function,
this->name_);
else
- gcc_unreachable();
+ go_unreachable();
}
// Class Bindings.
return;
}
}
- gcc_unreachable();
+ go_unreachable();
}
// Add a method to the list of objects. This is not added to the
{
default:
case Named_object::NAMED_OBJECT_UNINITIALIZED:
- gcc_unreachable();
+ go_unreachable();
case Named_object::NAMED_OBJECT_UNKNOWN:
{
break;
case Named_object::NAMED_OBJECT_SINK:
- gcc_unreachable();
+ go_unreachable();
case Named_object::NAMED_OBJECT_FUNC:
if (new_object->is_function_declaration())
case Named_object::NAMED_OBJECT_SINK:
default:
- gcc_unreachable();
+ go_unreachable();
}
}
int
Traverse::variable(Named_object*)
{
- gcc_unreachable();
+ go_unreachable();
}
int
Traverse::constant(Named_object*, bool)
{
- gcc_unreachable();
+ go_unreachable();
}
int
Traverse::function(Named_object*)
{
- gcc_unreachable();
+ go_unreachable();
}
int
Traverse::block(Block*)
{
- gcc_unreachable();
+ go_unreachable();
}
int
Traverse::statement(Block*, size_t*, Statement*)
{
- gcc_unreachable();
+ go_unreachable();
}
int
Traverse::expression(Expression**)
{
- gcc_unreachable();
+ go_unreachable();
}
int
Traverse::type(Type*)
{
- gcc_unreachable();
+ go_unreachable();
}
mpfr_init_set(this->u_.float_value, tok.u_.float_value, GMP_RNDN);
break;
default:
- gcc_unreachable();
+ go_unreachable();
}
}
mpfr_init_set(this->u_.float_value, tok.u_.float_value, GMP_RNDN);
break;
default:
- gcc_unreachable();
+ go_unreachable();
}
return *this;
}
fprintf(file, "]");
break;
default:
- gcc_unreachable();
+ go_unreachable();
}
break;
default:
- gcc_unreachable();
+ go_unreachable();
}
}
// If we get here it means that a single nested function refers to
// two different variables defined in enclosing functions, and both
// variables have the same name. I think this is impossible.
- gcc_unreachable();
+ go_unreachable();
}
// Class Parse.
else if (named_object->is_unknown() || named_object->is_type_declaration())
return Type::make_forward_declaration(named_object);
else
- gcc_unreachable();
+ go_unreachable();
}
// ArrayType = "[" [ ArrayLength ] "]" ElementType .
case Named_object::NAMED_OBJECT_UNKNOWN:
return Expression::make_unknown_reference(named_object, location);
default:
- gcc_unreachable();
+ go_unreachable();
}
}
- gcc_unreachable();
+ go_unreachable();
case Token::TOKEN_STRING:
ret = Expression::make_string(token->string_value(), token->location());
case Token::TOKEN_IMAGINARY:
return true;
default:
- gcc_unreachable();
+ go_unreachable();
}
}
else if (token->is_op(OPERATOR_MINUSMINUS))
this->gogo_->add_statement(Statement::make_dec_statement(exp));
else
- gcc_unreachable();
+ go_unreachable();
this->advance_token();
}
else if (enclosing->classification() == Statement::STATEMENT_SELECT)
label = enclosing->select_statement()->break_label();
else
- gcc_unreachable();
+ go_unreachable();
this->gogo_->add_statement(Statement::make_break_statement(label,
location));
else if (enclosing->classification() == Statement::STATEMENT_FOR_RANGE)
label = enclosing->for_range_statement()->continue_label();
else
- gcc_unreachable();
+ go_unreachable();
this->gogo_->add_statement(Statement::make_continue_statement(label,
location));
{
default:
case RFT_VOID:
- gcc_unreachable();
+ go_unreachable();
case RFT_BOOL:
t = Type::lookup_bool_type();
{
default:
case RFT_VOID:
- gcc_unreachable();
+ go_unreachable();
case RFT_BOOL:
case RFT_BOOLPTR:
Bstatement*
do_get_backend(Translate_context*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
};
// Make an error statement.
bool
do_traverse_assignments(Traverse_assignments*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
Statement*
do_lower(Gogo*, Named_object*, Block*);
Bstatement*
do_get_backend(Translate_context*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
private:
// The operator (OPERATOR_PLUSEQ, etc.).
op = OPERATOR_BITCLEAR;
break;
default:
- gcc_unreachable();
+ go_unreachable();
}
Expression* binop = Expression::make_binary(op, lval, this->rhs_, loc);
bool
do_traverse_assignments(Traverse_assignments*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
Statement*
do_lower(Gogo*, Named_object*, Block*);
Bstatement*
do_get_backend(Translate_context*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
private:
// Left hand side--a list of lvalues.
bool
do_traverse_assignments(Traverse_assignments*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
Statement*
do_lower(Gogo*, Named_object*, Block*);
Bstatement*
do_get_backend(Translate_context*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
private:
// Lvalue which receives the value from the map.
bool
do_traverse_assignments(Traverse_assignments*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
Statement*
do_lower(Gogo*, Named_object*, Block*);
Bstatement*
do_get_backend(Translate_context*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
private:
// A reference to the map index which should be set or deleted.
bool
do_traverse_assignments(Traverse_assignments*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
Statement*
do_lower(Gogo*, Named_object*, Block*);
Bstatement*
do_get_backend(Translate_context*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
private:
// Lvalue which receives the value from the channel.
bool
do_traverse_assignments(Traverse_assignments*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
Statement*
do_lower(Gogo*, Named_object*, Block*);
Bstatement*
do_get_backend(Translate_context*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
private:
Call_expression*
bool
do_traverse_assignments(Traverse_assignments*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
Statement*
do_lower(Gogo*, Named_object*, Block*);
Bstatement*
do_get_backend(Translate_context*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
private:
// The l-value to increment or decrement.
vals->push_back(first_arg);
}
else
- gcc_unreachable();
+ go_unreachable();
if (ce->args() != NULL)
{
else if (this->classification() == STATEMENT_DEFER)
s = Statement::make_defer_statement(call, location);
else
- gcc_unreachable();
+ go_unreachable();
// The current block should end with the go statement.
go_assert(block->statements()->size() >= 1);
mpz_t ival;
mpz_init(ival);
if (!pe->integer_constant_value(true, ival, &itype))
- gcc_unreachable();
+ go_unreachable();
size_t ret = mpz_get_ui(ival);
mpz_clear(ival);
return ret;
mpz_init(bval);
if (!a->integer_constant_value(true, aval, &atype)
|| !b->integer_constant_value(true, bval, &btype))
- gcc_unreachable();
+ go_unreachable();
bool ret = mpz_cmp(aval, bval) == 0;
mpz_clear(aval);
mpz_clear(bval);
index_temp, value_temp, &init, &cond, &iter_init,
&post);
else
- gcc_unreachable();
+ go_unreachable();
if (iter_init != NULL)
body->add_statement(Statement::make_block_statement(iter_init, loc));
bool
do_traverse_assignments(Traverse_assignments*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
Statement*
do_lower(Gogo*, Named_object*, Block*);
Bstatement*
do_get_backend(Translate_context*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
private:
// The initialization statements. This may be NULL.
bool
do_traverse_assignments(Traverse_assignments*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
Statement*
do_lower(Gogo*, Named_object*, Block*);
Bstatement*
do_get_backend(Translate_context*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
private:
Expression*
Bstatement*
do_get_backend(Translate_context*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
private:
// The value to switch on. This may be NULL.
Bstatement*
do_get_backend(Translate_context*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
private:
// The variable holding the value we are switching on.
return this->base()->is_basic_type();
default:
- gcc_unreachable();
+ go_unreachable();
}
}
case TYPE_BOOLEAN:
return Type::lookup_bool_type();
default:
- gcc_unreachable();
+ go_unreachable();
}
}
return false;
default:
- gcc_unreachable();
+ go_unreachable();
}
}
bool
Type::do_check_make_expression(Expression_list*, source_location)
{
- gcc_unreachable();
+ go_unreachable();
}
// Return whether an expression has an integer value. Report an error
Type::do_make_expression_tree(Translate_context*, Expression_list*,
source_location)
{
- gcc_unreachable();
+ go_unreachable();
}
// Return a pointer to the type descriptor for this type.
case Type::TYPE_NAMED:
case Type::TYPE_FORWARD:
- gcc_unreachable();
+ go_unreachable();
default:
- gcc_unreachable();
+ go_unreachable();
}
}
void
Type::do_export(Export*) const
{
- gcc_unreachable();
+ go_unreachable();
}
// Import a type.
tree
do_get_init_tree(Gogo*, tree, bool)
- { gcc_unreachable(); }
+ { go_unreachable(); }
Expression*
do_type_descriptor(Gogo*, Named_type*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
void
do_reflection(Gogo*, std::string*) const
protected:
tree
do_get_tree(Gogo*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
tree
do_get_init_tree(Gogo*, tree, bool)
- { gcc_unreachable(); }
+ { go_unreachable(); }
Expression*
do_type_descriptor(Gogo*, Named_type*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
void
do_reflection(Gogo*, std::string*) const
- { gcc_unreachable(); }
+ { go_unreachable(); }
void
do_mangled_name(Gogo*, std::string*) const
- { gcc_unreachable(); }
+ { go_unreachable(); }
};
// Make the sink type.
Expression*
do_type_descriptor(Gogo*, Named_type*)
- { gcc_unreachable(); }
+ { go_unreachable(); }
void
do_reflection(Gogo*, std::string*) const
- { gcc_unreachable(); }
+ { go_unreachable(); }
void
do_mangled_name(Gogo*, std::string* ret) const
else if (t->named_type() != NULL)
return t->named_type()->name();
else
- gcc_unreachable();
+ go_unreachable();
}
}
}
++p, ++ret)
if (p->name() == name)
return ret;
- gcc_unreachable();
+ go_unreachable();
}
// Return whether NAME is an unexported method, for better error
else if (this->named_object_->is_function_declaration())
return this->named_object_->func_declaration_value()->type();
else
- gcc_unreachable();
+ go_unreachable();
}
// Return the location of the method receiver.
case Type::TYPE_NAMED:
case Type::TYPE_FORWARD:
default:
- gcc_unreachable();
+ go_unreachable();
}
}
case TYPE_CALL_MULTIPLE_RESULT:
case TYPE_NAMED:
case TYPE_FORWARD:
- gcc_unreachable();
+ go_unreachable();
}
this->named_tree_ = t;
case TYPE_CALL_MULTIPLE_RESULT:
case TYPE_NAMED:
case TYPE_FORWARD:
- gcc_unreachable();
+ go_unreachable();
}
// Create the named type.
case TYPE_CALL_MULTIPLE_RESULT:
case TYPE_NAMED:
case TYPE_FORWARD:
- gcc_unreachable();
+ go_unreachable();
}
- gcc_unreachable();
+ go_unreachable();
}
// Build a type descriptor for a named type.
else if (no->is_function_declaration())
fntype = no->func_declaration_value()->type();
else
- gcc_unreachable();
+ go_unreachable();
return fntype->receiver()->type()->points_to() != NULL;
}
else if (st != NULL)
m = st->method_function(name, NULL);
else
- gcc_unreachable();
+ go_unreachable();
go_assert(m != NULL);
if (!m->is_value_method() && expr->type()->points_to() == NULL)
expr = Expression::make_unary(OPERATOR_AND, expr, location);
// called, as we always create a stub.
Named_object*
do_named_object() const
- { gcc_unreachable(); }
+ { go_unreachable(); }
// The type of the method.
Function_type*
projects / gcc.git / commitdiff