void asm_out_fp(enum section_type sec, type *ty, floating_t f)
{
switch(type_primitive(ty)){
case type_float:
{
union { float f; unsigned u; } u;
u.f = f;
asm_out_section(sec, ".long %u # float %f\n", u.u, u.f);
break;
}
case type_double:
{
union { double d; unsigned long ul; } u;
u.d = f;
asm_out_section(sec, ".quad %lu # double %f\n", u.ul, u.d);
break;
}
case type_ldouble:
ICE("TODO");
default:
ICE("bad float type");
}
}
static void fold_cast_num(expr *const e, numeric *const num)
{
int to_fp, from_fp;
to_fp = type_is_floating(e->tree_type);
from_fp = type_is_floating(expr_cast_child(e)->tree_type);
if(to_fp){
if(from_fp){
UCC_ASSERT(K_FLOATING(*num), "i/f mismatch types");
/* float -> float - nothing to see here */
}else{
UCC_ASSERT(K_INTEGRAL(*num), "i/f mismatch types");
/* int -> float */
if(num->suffix & VAL_UNSIGNED){
num->val.f = num->val.i;
}else{
/* force a signed conversion, long long to long double */
num->val.f = (sintegral_t)num->val.i;
}
}
/* perform the trunc */
switch(type_primitive(e->tree_type)){
default:
ICE("fp expected");
#define TRUNC(cse, ty, bmask) \
case type_ ## cse: \
num->val.f = (ty)num->val.f; \
num->suffix = bmask; \
break
TRUNC(float, float, VAL_FLOAT);
TRUNC(double, double, VAL_DOUBLE);
TRUNC(ldouble, long double, VAL_LDOUBLE);
#undef TRUNC
}
return;
}else if(from_fp){
UCC_ASSERT(K_FLOATING(*num), "i/f mismatch types");
/* special case _Bool */
if(type_is_primitive(e->tree_type, type__Bool)){
num->val.i = !!num->val.f;
}else{
/* float -> int */
num->val.i = num->val.f;
}
num->suffix = 0;
/* fall through to int logic */
}
UCC_ASSERT(K_INTEGRAL(*num), "fp const?");
#define pv (&num->val.i)
/* need to cast the val.i down as appropriate */
if(type_is_primitive(e->tree_type, type__Bool)){
*pv = !!*pv; /* analagous to out/out.c::out_normalise()'s constant case */
}else if(!from_fp){
*pv = convert_integral_to_integral_warn(
*pv, e->expr->tree_type,
e->tree_type,
e->expr_cast_implicit, &e->where);
}
#undef pv
}
