diff --git a/test/CodeGen/PowerPC/2006-12-07-SelectCrash.ll b/test/CodeGen/PowerPC/2006-12-07-SelectCrash.ll
new file mode 100644
index 0000000..d59e091
--- /dev/null
+++ b/test/CodeGen/PowerPC/2006-12-07-SelectCrash.ll
@@ -0,0 +1,27 @@
+; RUN: llvm-as < %s | llc -march=ppc64 &&
+; RUN: llvm-as < %s | llc -march=ppc32 &&
+; RUN: llvm-as < %s | llc
+
+%qsz.b = external global bool		; <bool*> [#uses=1]
+
+implementation   ; Functions:
+
+fastcc void %qst() {
+entry:
+	br bool true, label %cond_next71, label %cond_true
+
+cond_true:		; preds = %entry
+	ret void
+
+cond_next71:		; preds = %entry
+	%tmp73.b = load bool* %qsz.b		; <bool> [#uses=1]
+	%ii.4.ph = select bool %tmp73.b, ulong 4, ulong 0		; <ulong> [#uses=1]
+	br label %bb139
+
+bb82:		; preds = %bb139
+	ret void
+
+bb139:		; preds = %bb139, %cond_next71
+	%exitcond89 = seteq ulong 0, %ii.4.ph		; <bool> [#uses=1]
+	br bool %exitcond89, label %bb82, label %bb139
+}
