[PATCH 27/73] sparse-llvm: Support arbitrary struct member counts and fix operand types

[Bart Van Assche <bvanassche@acm.org>]

Fix LLVM IR generation crashes and limits in sparse-llvm.c:
- Dynamically allocate elem_types in sym_struct_type() instead of asserting
  at 64 members, and handle zero-sized array element types in
  sym_array_type().
- Pass instruction operand types instead of NULL to pseudo_to_value() in
  output_op_compare(), output_op_cbr(), and output_op_sel().
- Read val->label_symbol instead of val->symbol for EXPR_LABEL in
  output_op_setval().
- Add a regression test in validation/backend/struct-large-members.c.

Signed-off-by: Bart Van Assche <bvanassche@acm.org>
---
 sparse-llvm.c                             | 23 +++----
 validation/backend/struct-large-members.c | 83 +++++++++++++++++++++++
 2 files changed, 92 insertions(+), 14 deletions(-)
 create mode 100644 validation/backend/struct-large-members.c

diff --git a/sparse-llvm.c b/sparse-llvm.c
index c422a13ce2a8..8f37bde1b98d 100644
--- a/sparse-llvm.c
+++ b/sparse-llvm.c
@@ -86,21 +86,17 @@ static LLVMTypeRef sym_array_type(struct symbol *sym)
 	struct symbol *base_type;
 
 	base_type = sym->ctype.base_type;
-	/* empty struct is undefined [6.7.2.1(8)] */
-	assert(base_type->bit_size > 0);
-
 	elem_type = symbol_type(base_type);
 	if (!elem_type)
 		return NULL;
 
-	return LLVMArrayType(elem_type, sym->bit_size / base_type->bit_size);
+	return LLVMArrayType(elem_type, base_type->bit_size > 0 ? sym->bit_size / base_type->bit_size : 0);
 }
 
-#define MAX_STRUCT_MEMBERS 64
-
 static LLVMTypeRef sym_struct_type(struct symbol *sym)
 {
-	LLVMTypeRef elem_types[MAX_STRUCT_MEMBERS];
+	unsigned n_memb = symbol_list_size(sym->symbol_list);
+	LLVMTypeRef *elem_types = calloc(n_memb, sizeof(LLVMTypeRef));
 	struct symbol *member;
 	char buffer[256];
 	LLVMTypeRef ret;
@@ -114,14 +110,13 @@ static LLVMTypeRef sym_struct_type(struct symbol *sym)
 	FOR_EACH_PTR(sym->symbol_list, member) {
 		LLVMTypeRef member_type;
 
-		assert(nr < MAX_STRUCT_MEMBERS);
-
 		member_type = symbol_type(member);
 
 		elem_types[nr++] = member_type; 
 	} END_FOR_EACH_PTR(member);
 
 	LLVMStructSetBody(ret, elem_types, nr, 0 /* packed? */); 
+	free(elem_types);
 	return ret;
 }
 
@@ -663,11 +658,11 @@ static void output_op_compare(struct function *fn, struct instruction *insn)
 	LLVMValueRef lhs, rhs, target;
 	char target_name[64];
 
-	lhs = pseudo_to_value(fn, NULL, insn->src1);
+	lhs = pseudo_to_value(fn, insn->itype, insn->src1);
 	if (insn->src2->type == PSEUDO_VAL)
 		rhs = constant_value(insn->src2->value, LLVMTypeOf(lhs));
 	else
-		rhs = pseudo_to_value(fn, NULL, insn->src2);
+		rhs = pseudo_to_value(fn, insn->itype, insn->src2);
 	if (!rhs)
 		rhs = LLVMGetUndef(symbol_type(insn->type));
 
@@ -785,7 +780,7 @@ static LLVMValueRef bool_value(struct function *fn, LLVMValueRef value)
 static void output_op_cbr(struct function *fn, struct instruction *br)
 {
 	LLVMValueRef cond = bool_value(fn,
-			pseudo_to_value(fn, NULL, br->cond));
+			pseudo_to_value(fn, br->type ? br->type : &int_ctype, br->cond));
 
 	LLVMBuildCondBr(fn->builder, cond,
 			br->bb_true->priv,
@@ -802,7 +797,7 @@ static void output_op_sel(struct function *fn, struct instruction *insn)
 	LLVMValueRef target, src1, src2, src3;
 	char name[MAX_PSEUDO_NAME];
 
-	src1 = bool_value(fn, pseudo_to_value(fn, NULL, insn->src1));
+	src1 = bool_value(fn, pseudo_to_value(fn, insn->itype ? insn->itype : insn->type, insn->src1));
 	src2 = get_operand(fn, insn->type, insn->src2);
 	src3 = get_operand(fn, insn->type, insn->src3);
 
@@ -1001,7 +996,7 @@ static void output_op_setval(struct function *fn, struct instruction *insn)
 
 	switch (val->type) {
 	case EXPR_LABEL:
-		target = LLVMBlockAddress(fn->fn, val->symbol->bb_target->priv);
+		target = LLVMBlockAddress(fn->fn, val->label_symbol->bb_target->priv);
 		break;
 	default:
 		assert(0);
diff --git a/validation/backend/struct-large-members.c b/validation/backend/struct-large-members.c
new file mode 100644
index 000000000000..65f382194d5d
--- /dev/null
+++ b/validation/backend/struct-large-members.c
@@ -0,0 +1,83 @@
+struct big_struct {
+	int f0;
+	int f1;
+	int f2;
+	int f3;
+	int f4;
+	int f5;
+	int f6;
+	int f7;
+	int f8;
+	int f9;
+	int f10;
+	int f11;
+	int f12;
+	int f13;
+	int f14;
+	int f15;
+	int f16;
+	int f17;
+	int f18;
+	int f19;
+	int f20;
+	int f21;
+	int f22;
+	int f23;
+	int f24;
+	int f25;
+	int f26;
+	int f27;
+	int f28;
+	int f29;
+	int f30;
+	int f31;
+	int f32;
+	int f33;
+	int f34;
+	int f35;
+	int f36;
+	int f37;
+	int f38;
+	int f39;
+	int f40;
+	int f41;
+	int f42;
+	int f43;
+	int f44;
+	int f45;
+	int f46;
+	int f47;
+	int f48;
+	int f49;
+	int f50;
+	int f51;
+	int f52;
+	int f53;
+	int f54;
+	int f55;
+	int f56;
+	int f57;
+	int f58;
+	int f59;
+	int f60;
+	int f61;
+	int f62;
+	int f63;
+	int f64;
+	int f65;
+	int f66;
+	int f67;
+	int f68;
+	int f69;
+};
+
+static struct big_struct s;
+static int get_f69(void)
+{
+	return s.f69;
+}
+
+/*
+ * check-name: struct-large-members
+ * check-command: sparsec -c $file -o tmp.o
+ */