diff --git a/tools/qfcc/include/expr.h b/tools/qfcc/include/expr.h
index f35fdcc34..883c40c36 100644
--- a/tools/qfcc/include/expr.h
+++ b/tools/qfcc/include/expr.h
@@ -218,6 +218,7 @@ typedef struct ex_value_s {
 	const type_t *type;
 	etype_t     lltype;
 	union {
+		uint8_t     raw_value;			///< for memcpy
 		const char *string_val;			///< string constant
 		double      double_val;			///< double constant
 		int64_t     long_val;			///< signed 64-bit constant
@@ -234,8 +235,9 @@ typedef struct ex_value_s {
 		uint16_t    ushort_val;			///< unsigned short constant
 #define VEC_TYPE(type_name, base_type) pr_##type_name##_t type_name##_val;
 #include "tools/qfcc/include/vec_types.h"
-	} v;
+	};
 } ex_value_t;
+#define value_size (sizeof(ex_value_t) - field_offset(ex_value_t, raw_value))
 
 typedef struct {
 	const type_t *type;			///< type to view the expression
diff --git a/tools/qfcc/source/dags.c b/tools/qfcc/source/dags.c
index 6969344d9..47d332191 100644
--- a/tools/qfcc/source/dags.c
+++ b/tools/qfcc/source/dags.c
@@ -577,8 +577,8 @@ dagnode_set_edges (dag_t *dag, dagnode_t *n, statement_t *s)
 				}
 				if (op->op_type == op_value
 					&& op->value->lltype == ev_ptr
-					&& op->value->v.pointer.def) {
-					def_visit_all (op->value->v.pointer.def, 1,
+					&& op->value->pointer.def) {
+					def_visit_all (op->value->pointer.def, 1,
 								   dagnode_def_set_edges_visit, n);
 				}
 				if (op->op_type == op_def
diff --git a/tools/qfcc/source/def.c b/tools/qfcc/source/def.c
index 4c791f0e9..c1d34b07a 100644
--- a/tools/qfcc/source/def.c
+++ b/tools/qfcc/source/def.c
@@ -424,9 +424,9 @@ init_elements (struct def_s *def, const expr_t *eles)
 			}
 			if (c->value->lltype == ev_string) {
 				EMIT_STRING (def->space, *(pr_string_t *) g,
-							 c->value->v.string_val);
+							 c->value->string_val);
 			} else {
-				memcpy (g, &c->value->v, type_size (get_type (c)) * 4);
+				memcpy (g, &c->value->raw_value, type_size (get_type (c)) * 4);
 			}
 		}
 	}
@@ -462,8 +462,8 @@ init_vector_components (symbol_t *vector_sym, int is_field, symtab_t *symtab)
 							error (0, "%s redefined", name);
 							sym = 0;
 						} else {
-							expr->value->v.pointer.def = vector_sym->def;
-							expr->value->v.pointer.val = i;
+							expr->value->pointer.def = vector_sym->def;
+							expr->value->pointer.val = i;
 						}
 					}
 				}
@@ -657,9 +657,9 @@ initialize_def (symbol_t *sym, const expr_t *init, defspace_t *space,
 			if (init->value->lltype == ev_ptr
 				|| init->value->lltype == ev_field) {
 				// FIXME offset pointers
-				D_INT (sym->def) = init->value->v.pointer.val;
-				if (init->value->v.pointer.def)
-					reloc_def_field (init->value->v.pointer.def, sym->def);
+				D_INT (sym->def) = init->value->pointer.val;
+				if (init->value->pointer.def)
+					reloc_def_field (init->value->pointer.def, sym->def);
 			} else {
 				ex_value_t *v = init->value;
 				if (!init->implicit
@@ -672,9 +672,9 @@ initialize_def (symbol_t *sym, const expr_t *init, defspace_t *space,
 					v = convert_value (v, sym->type);
 				if (v->lltype == ev_string) {
 					EMIT_STRING (sym->def->space, D_STRING (sym->def),
-								 v->v.string_val);
+								 v->string_val);
 				} else {
-					memcpy (D_POINTER (pr_type_t, sym->def), &v->v,
+					memcpy (D_POINTER (pr_type_t, sym->def), &v->raw_value,
 							type_size (sym->type) * sizeof (pr_type_t));
 				}
 			}
diff --git a/tools/qfcc/source/dot_type.c b/tools/qfcc/source/dot_type.c
index 33ff7a774..474c9c3ef 100644
--- a/tools/qfcc/source/dot_type.c
+++ b/tools/qfcc/source/dot_type.c
@@ -169,7 +169,7 @@ print_struct (dstring_t *dstr, const type_t *t, int level, int id)
 		int         val;
 		const char *port = "";
 		if (sym->sy_type == sy_const) {
-			val = sym->value->v.int_val;
+			val = sym->value->int_val;
 		} else {
 			if (sym->sy_type != sy_var) {
 				continue;
diff --git a/tools/qfcc/source/emit.c b/tools/qfcc/source/emit.c
index daacbf45a..51019fca3 100644
--- a/tools/qfcc/source/emit.c
+++ b/tools/qfcc/source/emit.c
@@ -87,12 +87,12 @@ get_value_def (const expr_t *expr, ex_value_t *value, const type_t *type)
 
 	if (is_short (type)) {
 		def = new_def (0, &type_short, 0, sc_extern);
-		def->offset = value->v.short_val;
+		def->offset = value->short_val;
 		return def;
 	}
-	if (is_ptr (type) && value->v.pointer.tempop && !value->v.pointer.def) {
-		value->v.pointer.def = get_tempop_def (expr, value->v.pointer.tempop,
-											   type->t.fldptr.type);
+	if (is_ptr (type) && value->pointer.tempop && !value->pointer.def) {
+		value->pointer.def = get_tempop_def (expr, value->pointer.tempop,
+											 type->t.fldptr.type);
 	}
 	def = emit_value (value, 0);
 	if (type != def->type)
diff --git a/tools/qfcc/source/evaluate.c b/tools/qfcc/source/evaluate.c
index 47f1537a3..5493ed7fc 100644
--- a/tools/qfcc/source/evaluate.c
+++ b/tools/qfcc/source/evaluate.c
@@ -172,7 +172,7 @@ convert_value (ex_value_t *value, const type_t *type)
 	int         addr = value_functions[vf_convert].first_statement;
 	value_statements[addr + 0].b = conv;
 	value_statements[addr + 1].c = type_size (type) - 1;
-	memcpy (value_globals, &value->v,
+	memcpy (value_globals, &value->raw_value,
 			type_size (value->type) * sizeof (pr_type_t));
 	value_pr.pr_trace = options.verbosity > 1;
 	PR_ExecuteProgram (&value_pr, vf_convert);
@@ -204,7 +204,7 @@ get_def (operand_t *op)
 {
 	if (is_short (op->type)) {
 		auto def = new_def (0, &type_short, 0, sc_extern);
-		def->offset = op->value->v.short_val;
+		def->offset = op->value->short_val;
 		return def;
 	}
 	switch (op->op_type) {
diff --git a/tools/qfcc/source/expr.c b/tools/qfcc/source/expr.c
index 85309f698..adb24a0f6 100644
--- a/tools/qfcc/source/expr.c
+++ b/tools/qfcc/source/expr.c
@@ -844,7 +844,7 @@ expr_long (const expr_t *e)
 		return 0;
 	}
 	if (e->type == ex_value && e->value->lltype == ev_long) {
-		return e->value->v.long_val;
+		return e->value->long_val;
 	}
 	internal_error (e, "not a long constant");
 }
@@ -954,7 +954,7 @@ expr_string (const expr_t *e)
 	if (e->type == ex_nil)
 		return 0;
 	if (e->type == ex_value && e->value->lltype == ev_string)
-		return e->value->v.string_val;
+		return e->value->string_val;
 	internal_error (e, "not a string constant");
 }
 
@@ -977,10 +977,10 @@ expr_double (const expr_t *e)
 	if (e->type == ex_nil)
 		return 0;
 	if (e->type == ex_value && e->value->lltype == ev_double)
-		return e->value->v.double_val;
+		return e->value->double_val;
 	if (e->type == ex_symbol && e->symbol->sy_type == sy_const
 		&& e->symbol->type->type == ev_double)
-		return e->symbol->value->v.double_val;
+		return e->symbol->value->double_val;
 	if (e->type == ex_symbol && e->symbol->sy_type == sy_var
 		&& e->symbol->def->constant
 		&& is_double (e->symbol->def->type))
@@ -994,10 +994,10 @@ expr_float (const expr_t *e)
 	if (e->type == ex_nil)
 		return 0;
 	if (e->type == ex_value && e->value->lltype == ev_float)
-		return e->value->v.float_val;
+		return e->value->float_val;
 	if (e->type == ex_symbol && e->symbol->sy_type == sy_const
 		&& e->symbol->type->type == ev_float)
-		return e->symbol->value->v.float_val;
+		return e->symbol->value->float_val;
 	if (e->type == ex_symbol && e->symbol->sy_type == sy_var
 		&& e->symbol->def->constant
 		&& is_float (e->symbol->def->type))
@@ -1024,10 +1024,10 @@ expr_vector (const expr_t *e)
 	if (e->type == ex_nil)
 		return vec3_origin;
 	if (e->type == ex_value && e->value->lltype == ev_vector)
-		return e->value->v.vector_val;
+		return e->value->vector_val;
 	if (e->type == ex_symbol && e->symbol->sy_type == sy_const
 		&& e->symbol->type->type == ev_vector)
-		return e->symbol->value->v.vector_val;
+		return e->symbol->value->vector_val;
 	if (e->type == ex_symbol && e->symbol->sy_type == sy_var
 		&& e->symbol->def->constant
 		&& e->symbol->def->type->type == ev_vector)
@@ -1054,10 +1054,10 @@ expr_quaternion (const expr_t *e)
 	if (e->type == ex_nil)
 		return quat_origin;
 	if (e->type == ex_value && e->value->lltype == ev_quaternion)
-		return e->value->v.quaternion_val;
+		return e->value->quaternion_val;
 	if (e->type == ex_symbol && e->symbol->sy_type == sy_const
 		&& e->symbol->type->type == ev_quaternion)
-		return e->symbol->value->v.quaternion_val;
+		return e->symbol->value->quaternion_val;
 	if (e->type == ex_symbol && e->symbol->sy_type == sy_var
 		&& e->symbol->def->constant
 		&& e->symbol->def->type->type == ev_quaternion)
@@ -1092,15 +1092,15 @@ expr_int (const expr_t *e)
 		return 0;
 	}
 	if (e->type == ex_value && e->value->lltype == ev_int) {
-		return e->value->v.int_val;
+		return e->value->int_val;
 	}
 	if (e->type == ex_value && e->value->lltype == ev_short) {
-		return e->value->v.short_val;
+		return e->value->short_val;
 	}
 	if (e->type == ex_symbol && e->symbol->sy_type == sy_const
 		&& (e->symbol->type->type == ev_int
 			|| is_enum (e->symbol->type))) {
-		return e->symbol->value->v.int_val;
+		return e->symbol->value->int_val;
 	}
 	if (e->type == ex_symbol && e->symbol->sy_type == sy_var
 		&& e->symbol->def->constant
@@ -1141,11 +1141,11 @@ expr_uint (const expr_t *e)
 		return 0;
 	}
 	if (e->type == ex_value && e->value->lltype == ev_uint) {
-		return e->value->v.uint_val;
+		return e->value->uint_val;
 	}
 	if (e->type == ex_symbol && e->symbol->sy_type == sy_const
 		&& e->symbol->type->type == ev_uint) {
-		return e->symbol->value->v.uint_val;
+		return e->symbol->value->uint_val;
 	}
 	if (e->type == ex_symbol && e->symbol->sy_type == sy_var
 		&& e->symbol->def->constant
@@ -1182,11 +1182,11 @@ expr_short (const expr_t *e)
 		return 0;
 	}
 	if (e->type == ex_value && e->value->lltype == ev_short) {
-		return e->value->v.short_val;
+		return e->value->short_val;
 	}
 	if (e->type == ex_symbol && e->symbol->sy_type == sy_const
 		&& e->symbol->type->type == ev_short) {
-		return e->symbol->value->v.short_val;
+		return e->symbol->value->short_val;
 	}
 	internal_error (e, "not a short constant");
 }
@@ -1198,11 +1198,11 @@ expr_ushort (const expr_t *e)
 		return 0;
 	}
 	if (e->type == ex_value && e->value->lltype == ev_ushort) {
-		return e->value->v.ushort_val;
+		return e->value->ushort_val;
 	}
 	if (e->type == ex_symbol && e->symbol->sy_type == sy_const
 		&& e->symbol->type->type == ev_ushort) {
-		return e->symbol->value->v.ushort_val;
+		return e->symbol->value->ushort_val;
 	}
 	internal_error (e, "not a ushort constant");
 }
@@ -1596,7 +1596,7 @@ field_expr (const expr_t *e1, const expr_t *e2)
 					   || e2->value->lltype != ev_field) {
 				internal_error (e2, "unexpected field exression");
 			}
-			auto fv = new_field_val (e2->value->v.pointer.val + field->offset, field->type, e2->value->v.pointer.def);
+			auto fv = new_field_val (e2->value->pointer.val + field->offset, field->type, e2->value->pointer.def);
 			scoped_src_loc (e2);
 			e2 = new_value_expr (fv, false);
 			// create a new . expression
diff --git a/tools/qfcc/source/flow.c b/tools/qfcc/source/flow.c
index 377fc9016..0ff832a45 100644
--- a/tools/qfcc/source/flow.c
+++ b/tools/qfcc/source/flow.c
@@ -1552,14 +1552,14 @@ flow_analyze_pointer_operand (operand_t *ptrop, set_t *def)
 	operand_t  *op = 0;
 
 	if (ptrop->op_type == op_value && ptrop->value->lltype == ev_ptr) {
-		ex_pointer_t *ptr = &ptrop->value->v.pointer;
-		if (ptrop->value->v.pointer.def) {
+		ex_pointer_t *ptr = &ptrop->value->pointer;
+		if (ptrop->value->pointer.def) {
 			def_t      *alias;
 			alias = alias_def (ptr->def, ptr->type, ptr->val);
 			op = def_operand (alias, ptr->type, ptrop->expr);
 		}
-		if (ptrop->value->v.pointer.tempop) {
-			op = ptrop->value->v.pointer.tempop;
+		if (ptrop->value->pointer.tempop) {
+			op = ptrop->value->pointer.tempop;
 		}
 		if (op) {
 			flow_add_op_var (def, op, 6);
@@ -1648,9 +1648,9 @@ flow_analyze_statement (statement_t *s, set_t *use, set_t *def, set_t *kill,
 			aux_op1 = s->opb;
 			if (s->type != st_ptrassign && s->opb->op_type == op_value) {
 				if (is_short (s->opb->type)) {
-					size = s->opb->value->v.short_val;
+					size = s->opb->value->short_val;
 				} else if (is_int (s->opb->type)) {
-					size = s->opb->value->v.int_val;
+					size = s->opb->value->int_val;
 				} else {
 					print_type (s->opb->type);
 					internal_error (s->expr, "unexpected type for memset/move");
@@ -1717,7 +1717,7 @@ flow_analyze_statement (statement_t *s, set_t *use, set_t *def, set_t *kill,
 				if (s->opc) {
 					// ruamoko
 					// opc always short
-					short       ret_mode = s->opc->value->v.short_val;
+					short       ret_mode = s->opc->value->short_val;
 					// -1 is void
 					// FIXME size and addressing
 					if (ret_mode >= 0) {
diff --git a/tools/qfcc/source/obj_type.c b/tools/qfcc/source/obj_type.c
index 730e29bb1..033dd2369 100644
--- a/tools/qfcc/source/obj_type.c
+++ b/tools/qfcc/source/obj_type.c
@@ -217,7 +217,7 @@ qfo_encode_struct (const type_t *type, defspace_t *space)
 		if (i == num_fields)
 			internal_error (0, "whoa, what happened?");
 		if (sym->sy_type == sy_const)
-			offset = sym->value->v.int_val;
+			offset = sym->value->int_val;
 		else
 			offset = sym->offset;
 		ENC_DEF (strct->fields[i].type, field_types[i]);
diff --git a/tools/qfcc/source/statements.c b/tools/qfcc/source/statements.c
index b3b813036..74d8e69ed 100644
--- a/tools/qfcc/source/statements.c
+++ b/tools/qfcc/source/statements.c
@@ -1057,7 +1057,7 @@ vector_call (sblock_t *sblock, const expr_t *earg, const expr_t *param, int ind,
 
 	for (i = 0; i < 3; i++) {
 		n = new_name_expr (names[i]);
-		v = new_float_expr (earg->value->v.vector_val[i]);
+		v = new_float_expr (earg->value->vector_val[i]);
 		a = assign_expr (field_expr (param, n), v);
 		param = new_param_expr (get_type (earg), ind);
 		//a->line = earg->line;
diff --git a/tools/qfcc/source/struct.c b/tools/qfcc/source/struct.c
index e0513f42c..84ad94583 100644
--- a/tools/qfcc/source/struct.c
+++ b/tools/qfcc/source/struct.c
@@ -286,7 +286,7 @@ add_enum (symbol_t *enm, symbol_t *name, const expr_t *val)
 	name->type = enum_type;
 	value = 0;
 	if (enum_tab->symbols)
-		value = ((symbol_t *)(enum_tab->symtail))->value->v.uint_val + 1;
+		value = ((symbol_t *)(enum_tab->symtail))->value->uint_val + 1;
 	if (val) {
 		val = convert_name (val);
 		if (!is_constant (val))
@@ -314,12 +314,12 @@ enum_as_bool (const type_t *enm, expr_t **zero, expr_t **one)
 	for (sym = symtab->symbols; sym; sym = sym->next) {
 		if (sym->sy_type != sy_const)
 			continue;
-		val = sym->value->v.int_val;
+		val = sym->value->int_val;
 		if (!val) {
 			zero_sym = sym;
 		} else {
 			if (one_sym) {
-				v = one_sym->value->v.int_val;
+				v = one_sym->value->int_val;
 				if (val * val > v * v)
 					continue;
 			}
diff --git a/tools/qfcc/source/switch.c b/tools/qfcc/source/switch.c
index ba2d65222..f7c4a928b 100644
--- a/tools/qfcc/source/switch.c
+++ b/tools/qfcc/source/switch.c
@@ -82,7 +82,7 @@ get_hash (const void *_cl, void *unused)
 	if (!cl->value)
 		return 0;
 	val = get_value (cl->value);
-	return Hash_Buffer (&val->v, sizeof (val->v)) + val->lltype;
+	return Hash_Buffer (&val->raw_value, value_size) + val->lltype;
 }
 
 static int
@@ -104,7 +104,7 @@ compare (const void *_cla, const void *_clb, void *unused)
 	val2 = get_value (v2);
 	if (val1->type != val2->type)
 		return 0;
-	return memcmp (&val1->v, &val2->v, sizeof (val1->v)) == 0;
+	return memcmp (&val1->raw_value, &val2->raw_value, value_size) == 0;
 }
 
 const expr_t *
@@ -383,7 +383,7 @@ check_enum_switch (switch_block_t *switch_block)
 
 	for (enum_val = type->t.symtab->symbols; enum_val;
 		 enum_val = enum_val->next) {
-		cl.value = new_int_expr (enum_val->value->v.int_val, false);
+		cl.value = new_int_expr (enum_val->value->int_val, false);
 		if (!Hash_FindElement (switch_block->labels, &cl)) {
 			warning (switch_block->test,
 					 "enumeration value `%s' not handled in switch",
diff --git a/tools/qfcc/source/value.c b/tools/qfcc/source/value.c
index 6b5166406..cdeb60dfe 100644
--- a/tools/qfcc/source/value.c
+++ b/tools/qfcc/source/value.c
@@ -79,7 +79,7 @@ static uintptr_t
 value_get_hash (const void *_val, void *unused)
 {
 	const ex_value_t *val = (const ex_value_t *) _val;
-	return Hash_Buffer (&val->v, sizeof (val->v)) ^ (uintptr_t) val->type;
+	return Hash_Buffer (&val->raw_value, value_size) ^ (uintptr_t) val->type;
 }
 
 static int
@@ -89,7 +89,7 @@ value_compare (const void *_val1, const void *_val2, void *unused)
 	const ex_value_t *val2 = (const ex_value_t *) _val2;
 	if (val1->type != val2->type)
 		return 0;
-	return memcmp (&val1->v, &val2->v, sizeof (val1->v)) == 0;
+	return memcmp (&val1->raw_value, &val2->raw_value, value_size) == 0;
 }
 
 static ex_value_t *
@@ -130,7 +130,7 @@ new_string_val (const char *string_val)
 	memset (&val, 0, sizeof (val));
 	set_val_type (&val, &type_string);
 	if (string_val)
-		val.v.string_val = save_string (string_val);
+		val.string_val = save_string (string_val);
 	return find_value (&val);
 }
 
@@ -140,7 +140,7 @@ new_double_val (double double_val)
 	ex_value_t  val;
 	memset (&val, 0, sizeof (val));
 	set_val_type (&val, &type_double);
-	val.v.double_val = double_val;
+	val.double_val = double_val;
 	return find_value (&val);
 }
 
@@ -150,7 +150,7 @@ new_float_val (float float_val)
 	ex_value_t  val;
 	memset (&val, 0, sizeof (val));
 	set_val_type (&val, &type_float);
-	val.v.float_val = float_val;
+	val.float_val = float_val;
 	return find_value (&val);
 }
 
@@ -160,7 +160,7 @@ new_vector_val (const float *vector_val)
 	ex_value_t  val;
 	memset (&val, 0, sizeof (val));
 	set_val_type (&val, &type_vector);
-	VectorCopy (vector_val, val.v.vector_val);
+	VectorCopy (vector_val, val.vector_val);
 	return find_value (&val);
 }
 
@@ -170,7 +170,7 @@ new_entity_val (int entity_val)
 	ex_value_t  val;
 	memset (&val, 0, sizeof (val));
 	set_val_type (&val, &type_entity);
-	val.v.entity_val = entity_val;
+	val.entity_val = entity_val;
 	return find_value (&val);
 }
 
@@ -180,9 +180,9 @@ new_field_val (int field_val, const type_t *type, def_t *def)
 	ex_value_t  val;
 	memset (&val, 0, sizeof (val));
 	set_val_type (&val, field_type (type));
-	val.v.pointer.val = field_val;
-	val.v.pointer.type = type;
-	val.v.pointer.def = def;
+	val.pointer.val = field_val;
+	val.pointer.type = type;
+	val.pointer.def = def;
 	return find_value (&val);
 }
 
@@ -192,8 +192,8 @@ new_func_val (int func_val, const type_t *type)
 	ex_value_t  val;
 	memset (&val, 0, sizeof (val));
 	set_val_type (&val, type);
-	val.v.func_val.val = func_val;
-	val.v.func_val.type = type;
+	val.func_val.val = func_val;
+	val.func_val.type = type;
 	return find_value (&val);
 }
 
@@ -207,10 +207,10 @@ new_pointer_val (int pointer_val, const type_t *type, def_t *def,
 	}
 	memset (&val, 0, sizeof (val));
 	set_val_type (&val, pointer_type (type));
-	val.v.pointer.val = pointer_val;
-	val.v.pointer.type = type;
-	val.v.pointer.def = def;
-	val.v.pointer.tempop = tempop;
+	val.pointer.val = pointer_val;
+	val.pointer.type = type;
+	val.pointer.def = def;
+	val.pointer.tempop = tempop;
 	return find_value (&val);
 }
 
@@ -220,7 +220,7 @@ new_quaternion_val (const float *quaternion_val)
 	ex_value_t  val;
 	memset (&val, 0, sizeof (val));
 	set_val_type (&val, &type_quaternion);
-	QuatCopy (quaternion_val, val.v.quaternion_val);
+	QuatCopy (quaternion_val, val.quaternion_val);
 	return find_value (&val);
 }
 
@@ -230,7 +230,7 @@ new_int_val (int int_val)
 	ex_value_t  val;
 	memset (&val, 0, sizeof (val));
 	set_val_type (&val, &type_int);
-	val.v.int_val = int_val;
+	val.int_val = int_val;
 	return find_value (&val);
 }
 
@@ -240,14 +240,14 @@ new_uint_val (int uint_val)
 	ex_value_t  val;
 	memset (&val, 0, sizeof (val));
 	set_val_type (&val, &type_uint);
-	val.v.uint_val = uint_val;
+	val.uint_val = uint_val;
 	return find_value (&val);
 }
 
 ex_value_t *
 new_long_val (pr_long_t long_val)
 {
-	ex_value_t  val = { .v = { .long_val = long_val } };
+	ex_value_t  val = { .long_val = long_val };
 	set_val_type (&val, &type_long);
 	return find_value (&val);
 }
@@ -255,7 +255,7 @@ new_long_val (pr_long_t long_val)
 ex_value_t *
 new_ulong_val (pr_ulong_t ulong_val)
 {
-	ex_value_t  val = { .v = { .ulong_val = ulong_val } };
+	ex_value_t  val = { .ulong_val = ulong_val };
 	set_val_type (&val, &type_ulong);
 	return find_value (&val);
 }
@@ -266,7 +266,7 @@ new_short_val (short short_val)
 	ex_value_t  val;
 	memset (&val, 0, sizeof (val));
 	set_val_type (&val, &type_short);
-	val.v.short_val = short_val;
+	val.short_val = short_val;
 	return find_value (&val);
 }
 
@@ -280,9 +280,9 @@ new_nil_val (const type_t *type)
 		val.lltype = type_nil->type;
 	}
 	if (val.lltype == ev_ptr || val.lltype == ev_field )
-		val.v.pointer.type = type->t.fldptr.type;
+		val.pointer.type = type->t.fldptr.type;
 	if (val.lltype == ev_func)
-		val.v.func_val.type = type;
+		val.func_val.type = type;
 	return find_value (&val);
 }
 
@@ -291,8 +291,8 @@ new_type_value (const type_t *type, const pr_type_t *data)
 {
 	size_t      typeSize = type_size (type) * sizeof (pr_type_t);
 	ex_value_t  val = {};
-	set_val_type (&val, (type_t *) type);//FIXME cast
-	memcpy (&val.v, data, typeSize);
+	set_val_type (&val, type);
+	memcpy (&val.raw_value, data, typeSize);
 	return find_value (&val);
 }
 
@@ -322,7 +322,7 @@ value_store (pr_type_t *dst, const type_t *dstType, const expr_t *src)
 	if (!val) {
 		internal_error (src, "unexpected constant expression type");
 	}
-	memcpy (dst, &val->v, dstSize);
+	memcpy (dst, &val->raw_value, dstSize);
 }
 
 const char *
@@ -332,135 +332,135 @@ get_value_string (const ex_value_t *value)
 	const char *str = "";
 	switch (type->type) {
 		case ev_string:
-			return va (0, "\"%s\"", quote_string (value->v.string_val));
+			return va (0, "\"%s\"", quote_string (value->string_val));
 		case ev_vector:
 		case ev_quaternion:
 		case ev_float:
 			switch (type_width (type)) {
 				case 1:
-					str = va (0, "%.9g", value->v.float_val);
+					str = va (0, "%.9g", value->float_val);
 					break;
 				case 2:
-					str = va (0, VEC2F_FMT, VEC2_EXP (value->v.vec2_val));
+					str = va (0, VEC2F_FMT, VEC2_EXP (value->vec2_val));
 					break;
 				case 3:
 					str = va (0, "[%.9g, %.9g, %.9g]",
-							  VectorExpand (value->v.vec3_val));
+							  VectorExpand (value->vec3_val));
 					break;
 				case 4:
-					str = va (0, VEC4F_FMT, VEC4_EXP (value->v.vec4_val));
+					str = va (0, VEC4F_FMT, VEC4_EXP (value->vec4_val));
 					break;
 			}
 			return va (0, "%s %s", type->name, str);
 		case ev_entity:
 		case ev_func:
-			return va (0, "%s %d", type->name, value->v.int_val);
+			return va (0, "%s %d", type->name, value->int_val);
 		case ev_field:
-			if (value->v.pointer.def) {
-				int         offset = value->v.pointer.val;
-				offset += value->v.pointer.def->offset;
+			if (value->pointer.def) {
+				int         offset = value->pointer.val;
+				offset += value->pointer.def->offset;
 				return va (0, "field %d", offset);
 			} else {
-				return va (0, "field %d", value->v.pointer.val);
+				return va (0, "field %d", value->pointer.val);
 			}
 		case ev_ptr:
-			if (value->v.pointer.def) {
-				str = va (0, "<%s>", value->v.pointer.def->name);
+			if (value->pointer.def) {
+				str = va (0, "<%s>", value->pointer.def->name);
 			}
 			return va (0, "(* %s)[%d]%s",
-					   value->v.pointer.type
-						? get_type_string (value->v.pointer.type) : "???",
-					   value->v.pointer.val, str);
+					   value->pointer.type
+						? get_type_string (value->pointer.type) : "???",
+					   value->pointer.val, str);
 		case ev_int:
 			switch (type_width (type)) {
 				case 1:
-					str = va (0, "%"PRIi32, value->v.int_val);
+					str = va (0, "%"PRIi32, value->int_val);
 					break;
 				case 2:
-					str = va (0, VEC2I_FMT, VEC2_EXP (value->v.ivec2_val));
+					str = va (0, VEC2I_FMT, VEC2_EXP (value->ivec2_val));
 					break;
 				case 3:
 					str = va (0, "[%"PRIi32", %"PRIi32", %"PRIi32"]",
-							  VectorExpand (value->v.ivec3_val));
+							  VectorExpand (value->ivec3_val));
 					break;
 				case 4:
-					str = va (0, VEC4I_FMT, VEC4_EXP (value->v.ivec4_val));
+					str = va (0, VEC4I_FMT, VEC4_EXP (value->ivec4_val));
 					break;
 			}
 			return va (0, "%s %s", type->name, str);
 		case ev_uint:
 			switch (type_width (type)) {
 				case 1:
-					str = va (0, "%"PRIu32, value->v.uint_val);
+					str = va (0, "%"PRIu32, value->uint_val);
 					break;
 				case 2:
 					str = va (0, "[%"PRIu32", %"PRIi32"]",
-							  VEC2_EXP (value->v.uivec2_val));
+							  VEC2_EXP (value->uivec2_val));
 					break;
 				case 3:
 					str = va (0, "[%"PRIu32", %"PRIi32", %"PRIi32"]",
-							  VectorExpand (value->v.uivec3_val));
+							  VectorExpand (value->uivec3_val));
 					break;
 				case 4:
 					str = va (0, "[%"PRIu32", %"PRIi32", %"PRIi32", %"PRIi32"]",
-							  VEC4_EXP (value->v.uivec4_val));
+							  VEC4_EXP (value->uivec4_val));
 					break;
 			}
 			return va (0, "%s %s", type->name, str);
 		case ev_short:
-			return va (0, "%s %"PRIi16, type->name, value->v.short_val);
+			return va (0, "%s %"PRIi16, type->name, value->short_val);
 		case ev_ushort:
-			return va (0, "%s %"PRIu16, type->name, value->v.ushort_val);
+			return va (0, "%s %"PRIu16, type->name, value->ushort_val);
 		case ev_double:
 			switch (type_width (type)) {
 				case 1:
-					str = va (0, "%.17g", value->v.double_val);
+					str = va (0, "%.17g", value->double_val);
 					break;
 				case 2:
-					str = va (0, VEC2D_FMT, VEC2_EXP (value->v.dvec2_val));
+					str = va (0, VEC2D_FMT, VEC2_EXP (value->dvec2_val));
 					break;
 				case 3:
 					str = va (0, "[%.17g, %.17g, %.17g]",
-							  VectorExpand (value->v.dvec3_val));
+							  VectorExpand (value->dvec3_val));
 					break;
 				case 4:
-					str = va (0, VEC4D_FMT, VEC4_EXP (value->v.dvec4_val));
+					str = va (0, VEC4D_FMT, VEC4_EXP (value->dvec4_val));
 					break;
 			}
 			return va (0, "%s %s", type->name, str);
 		case ev_long:
 			switch (type_width (type)) {
 				case 1:
-					str = va (0, "%"PRIi64, value->v.long_val);
+					str = va (0, "%"PRIi64, value->long_val);
 					break;
 				case 2:
-					str = va (0, VEC2L_FMT, VEC2_EXP (value->v.lvec2_val));
+					str = va (0, VEC2L_FMT, VEC2_EXP (value->lvec2_val));
 					break;
 				case 3:
 					str = va (0, "[%"PRIi64", %"PRIi64", %"PRIi64"]",
-							  VectorExpand (value->v.lvec3_val));
+							  VectorExpand (value->lvec3_val));
 					break;
 				case 4:
-					str = va (0, VEC4L_FMT, VEC4_EXP (value->v.lvec4_val));
+					str = va (0, VEC4L_FMT, VEC4_EXP (value->lvec4_val));
 					break;
 			}
 			return va (0, "%s %s", type->name, str);
 		case ev_ulong:
 			switch (type_width (type)) {
 				case 1:
-					str = va (0, "%"PRIu64, value->v.ulong_val);
+					str = va (0, "%"PRIu64, value->ulong_val);
 					break;
 				case 2:
 					str = va (0, "[%"PRIu64", %"PRIi64"]",
-							  VEC2_EXP (value->v.ulvec2_val));
+							  VEC2_EXP (value->ulvec2_val));
 					break;
 				case 3:
 					str = va (0, "[%"PRIu64", %"PRIi64", %"PRIi64"]",
-							  VectorExpand (value->v.ulvec3_val));
+							  VectorExpand (value->ulvec3_val));
 					break;
 				case 4:
 					str = va (0, "[%"PRIu64", %"PRIi64", %"PRIi64", %"PRIi64"]",
-							  VEC4_EXP (value->v.ulvec4_val));
+							  VEC4_EXP (value->ulvec4_val));
 					break;
 			}
 			return va (0, "%s %s", type->name, str);
@@ -546,7 +546,8 @@ offset_alias_value (ex_value_t *value, const type_t *type, int offset)
 		return value;
 	}
 	pr_type_t   data[type_size (value->type)];
-	memcpy (data, &value->v, sizeof (pr_type_t) * type_size (value->type));
+	size_t      data_size = sizeof (pr_type_t) * type_size (value->type);
+	memcpy (data, &value->raw_value, data_size);
 	return new_type_value (type, data + offset);
 }
 
@@ -572,7 +573,7 @@ make_def_imm (def_t *def, hashtab_t *tab, ex_value_t *val)
 	imm = aligned_alloc (__alignof__(immediate_t), sizeof (immediate_t));
 	memset (imm, 0, sizeof (immediate_t));
 	imm->def = def;
-	memcpy (&imm->i, &val->v, sizeof (imm->i));
+	memcpy (&imm->i, &val->raw_value, sizeof (imm->i));
 
 	Hash_AddElement (tab, imm);
 
@@ -593,7 +594,7 @@ emit_value_core (ex_value_t *val, def_t *def, defspace_t *data)
 			reloc_def_string (def);
 			break;
 		case ev_func:
-			if (val->v.func_val.val) {
+			if (val->func_val.val) {
 				reloc_t    *reloc;
 				reloc = new_reloc (def->space, def->offset, rel_def_func);
 				reloc->next = pr.relocs;
@@ -601,19 +602,20 @@ emit_value_core (ex_value_t *val, def_t *def, defspace_t *data)
 			}
 			break;
 		case ev_field:
-			if (val->v.pointer.def)
-				reloc_def_field_ofs (val->v.pointer.def, def);
+			if (val->pointer.def)
+				reloc_def_field_ofs (val->pointer.def, def);
 			break;
 		case ev_ptr:
-			if (val->v.pointer.def) {
-				EMIT_DEF_OFS (data, D_INT (def), val->v.pointer.def);
+			if (val->pointer.def) {
+				EMIT_DEF_OFS (data, D_INT (def), val->pointer.def);
 			}
 			break;
 		default:
 			break;
 	}
 
-	memcpy (D_POINTER (pr_type_t, def), &val->v, 4 * type_size (val->type));
+	size_t      data_size = sizeof (pr_type_t) * type_size (val->type);
+	memcpy (D_POINTER (pr_type_t, def), &val->raw_value, data_size);
 	return def;
 }
 
@@ -651,7 +653,7 @@ emit_value (ex_value_t *value, def_t *def)
 			type = ev_types[val.lltype];
 			break;
 		case ev_string:
-			val.v.int_val = ReuseString (val.v.string_val);
+			val.int_val = ReuseString (val.string_val);
 			tab = string_imm_defs;
 			type = &type_string;
 			break;
@@ -663,7 +665,7 @@ emit_value (ex_value_t *value, def_t *def)
 	}
 	def_t       search_def = { .type = type };
 	immediate_t search = { .def = &search_def };
-	memcpy (&search.i, &val.v, sizeof (search.i));
+	memcpy (&search.i, &val.raw_value, sizeof (search.i));
 	immediate_t *imm = Hash_FindElement (tab, &search);
 	if (imm && strcmp (imm->def->name, ".zero") == 0) {
 		if (def) {