[llc] New diagnostic handler

[rovka]

Summary

Without a diagnostic handler installed, llc's behaviour is to exit on the first error that it encounters. This is very different from the behaviour of clang and other front ends, which try to gather as many errors as possible before exiting.

This commit adds a diagnostic handler to llc, allowing it to find and report more than one error. The old behaviour is preserved under a flag (-exit-on-error).

Some of the tests fail with the new diagnostic handler, so they have to use the new flag in order to run under the previous behaviour. Some of these are known bugs, others need further investigation. Ideally, we should fix the tests and remove the flag at some point in the future.

[rengolin]

tools/llc/llc.cpp

468

I think this could be before "if (CompileTwice)" above. Unless we're expecting it to fail one time and not the other, which I think it's a very slim chance.

Also, this cast is a bit odd. Maybe keeping that original HasError up there in in a global (anonymous) namespace would be better?

[rovka]

tools/llc/llc.cpp

468

It has to be after a PM.run, because that's where the errors may happen. We can add it after the first PM.run as well, for a quick exit in case of errors, but it still needs to be here as well in case CompileTwice is false.

WRT the cast: I'm not a big fan of either globals or casts, so I wouldn't mind using a global instead if you think that's cleaner.

[rnk]

tools/llc/llc.cpp

191

How about making this a static method of LLVMContext rather than duplicating it from LLVMContext.cpp?

468

I think it's better the way you have it. You're exercising the diagnostic context just the way it is intended: by downcasting a void*.

[rengolin]

tools/llc/llc.cpp

468

If that's how it was supposed to work, looks good. :)

[rovka]

Addressed some of the comments.

Added a new llc flag, -exit-on-error (which preserves the old behaviour).

Added -exit-on-error to the tests that fail under the new behaviour.

I also had to specify an underlying integer type for DiagnosticSeverity, so we can forward declare it in LLVMContext.h (otherwise we'd have to include DiagnosticInfo.h, which doesn't seem very nice considering how slender LLVMContext.h is).

[rnk]

lgtm

[rovka]

In D20202#429530, @rnk wrote:

lgtm

Thanks

[rengolin]

Committed in r269428. Thanks!

[rovka]

Get rid of some UB that I accidentally introduced along with the new flag.

[rovka]

...and a style fix : )

include/llvm/IR/DiagnosticInfo.h

 class DiagnosticPrinter;
 class Function;
 class Instruction;
 class LLVMContext;
 class Module;
 class SMDiagnostic;
 
 /// \brief Defines the different supported severity of a diagnostic.
-enum DiagnosticSeverity {
+enum DiagnosticSeverity : char {
   DS_Error,
   DS_Warning,
   DS_Remark,
   // A note attaches additional information to one of the previous diagnostic
   // types.
   DS_Note
 };
 

include/llvm/IR/LLVMContext.h

 class StringRef;
 class Twine;
 class Instruction;
 class Module;
 class MDString;
 class DICompositeType;
 class SMDiagnostic;
 class DiagnosticInfo;
+enum DiagnosticSeverity : char;
 template <typename T> class SmallVectorImpl;
 class Function;
 class DebugLoc;
 class OptBisect;
 
 /// This is an important class for using LLVM in a threaded context.  It
 /// (opaquely) owns and manages the core "global" data of LLVM's core
 /// infrastructure, including the type and constant uniquing tables.
public:
   /// getDiagnosticHandler - Return the diagnostic handler set by
   /// setDiagnosticHandler.
   DiagnosticHandlerTy getDiagnosticHandler() const;
 
   /// getDiagnosticContext - Return the diagnostic context set by
   /// setDiagnosticContext.
   void *getDiagnosticContext() const;
 
+  /// \brief Get the prefix that should be printed in front of a diagnostic of
+  ///        the given \p Severity
+  static const char *getDiagnosticMessagePrefix(DiagnosticSeverity Severity);
+
   /// \brief Report a message to the currently installed diagnostic handler.
   ///
   /// This function returns, in particular in the case of error reporting
   /// (DI.Severity == \a DS_Error), so the caller should leave the compilation
   /// process in a self-consistent state, even though the generated code
   /// need not be correct.
   ///
   /// The diagnostic message will be implicitly prefixed with a severity keyword

lib/IR/LLVMContext.cpp

static bool isDiagnosticEnabled(const DiagnosticInfo &DI) {
   // the pass that is emitting the diagnostic. If there is no match, ignore the
   // diagnostic and return.
   if (auto *Remark = dyn_cast<DiagnosticInfoOptimizationBase>(&DI))
     return Remark->isEnabled();
 
   return true;
 }
 
-static const char *getDiagnosticMessagePrefix(DiagnosticSeverity Severity) {
+const char *
+LLVMContext::getDiagnosticMessagePrefix(DiagnosticSeverity Severity) {
   switch (Severity) {
   case DS_Error:
     return "error";
   case DS_Warning:
     return "warning";
   case DS_Remark:
     return "remark";
   case DS_Note:

test/CodeGen/AArch64/arm64-inline-asm-error-I.ll

-; RUN: not llc -march=arm64 < %s  2> %t
+; RUN: not llc -march=arm64 -exit-on-error < %s  2> %t
 ; RUN: FileCheck --check-prefix=CHECK-ERRORS < %t %s
 
 ; Check for at least one invalid constant.
 ; CHECK-ERRORS: error: invalid operand for inline asm constraint 'I'
 
 define i32 @constraint_I(i32 %i, i32 %j) nounwind ssp {
 entry:
   %0 = tail call i32 asm sideeffect "add $0, $1, $2", "=r,r,I"(i32 %i, i32 4097) nounwind
   ret i32 %0
 }

test/CodeGen/AArch64/arm64-inline-asm-error-J.ll

-; RUN: not llc -march=arm64 < %s  2> %t
+; RUN: not llc -march=arm64 -exit-on-error < %s  2> %t
 ; RUN: FileCheck --check-prefix=CHECK-ERRORS < %t %s
 
 ; Check for at least one invalid constant.
 ; CHECK-ERRORS: error: invalid operand for inline asm constraint 'J'
 
 define i32 @constraint_J(i32 %i, i32 %j) nounwind ssp {
 entry:
   %0 = tail call i32 asm sideeffect "sub $0, $1, $2", "=r,r,J"(i32 %i, i32 2) nounwind
   ret i32 %0
 }

test/CodeGen/AArch64/arm64-inline-asm-error-K.ll

-; RUN: not llc -march=arm64 < %s  2> %t
+; RUN: not llc -march=arm64 -exit-on-error < %s  2> %t
 ; RUN: FileCheck --check-prefix=CHECK-ERRORS < %t %s
 
 ; Check for at least one invalid constant.
 ; CHECK-ERRORS: error: invalid operand for inline asm constraint 'K'
 
 define i32 @constraint_K(i32 %i, i32 %j) nounwind {
 entry:
   %0 = tail call i32 asm sideeffect "eor $0, $1, $2", "=r,r,K"(i32 %i, i32 -1) nounwind
   ret i32 %0
 }

test/CodeGen/AArch64/arm64-inline-asm-error-L.ll

-; RUN: not llc -march=arm64 < %s  2> %t
+; RUN: not llc -march=arm64 -exit-on-error < %s  2> %t
 ; RUN: FileCheck --check-prefix=CHECK-ERRORS < %t %s
 
 ; Check for at least one invalid constant.
 ; CHECK-ERRORS: error: invalid operand for inline asm constraint 'L'
 
 define i32 @constraint_L(i32 %i, i32 %j) nounwind {
 entry:
   %0 = tail call i32 asm sideeffect "eor $0, $1, $2", "=r,r,L"(i32 %i, i64 -1) nounwind
   ret i32 %0
 }

test/CodeGen/AArch64/arm64-inline-asm-error-M.ll

-; RUN: not llc -march=arm64 < %s  2> %t
+; RUN: not llc -march=arm64 -exit-on-error < %s  2> %t
 ; RUN: FileCheck --check-prefix=CHECK-ERRORS < %t %s
 
 ; Check for at least one invalid constant.
 ; CHECK-ERRORS: error: invalid operand for inline asm constraint 'M'
 
 define i32 @constraint_M(i32 %i, i32 %j) nounwind {
 entry:
   %0 = tail call i32 asm sideeffect "movk $0, $1", "=r,M"(i32 305418240) nounwind
   ret i32 %0
 }

test/CodeGen/AArch64/arm64-inline-asm-error-N.ll

-; RUN: not llc -march=arm64 < %s  2> %t
+; RUN: not llc -march=arm64 -exit-on-error < %s  2> %t
 ; RUN: FileCheck --check-prefix=CHECK-ERRORS < %t %s
 
 ; Check for at least one invalid constant.
 ; CHECK-ERRORS: error: invalid operand for inline asm constraint 'N'
 
 define i32 @constraint_N(i32 %i, i32 %j) nounwind {
 entry:
   %0 = tail call i32 asm sideeffect "movk $0, $1", "=r,N"(i64 1311761352401879040) nounwind
   ret i32 %0
 }

test/CodeGen/AMDGPU/call.ll

-; RUN: not llc -march=amdgcn -mcpu=SI -verify-machineinstrs< %s 2>&1 | FileCheck %s
-; RUN: not llc -march=amdgcn -mcpu=tonga -verify-machineinstrs< %s 2>&1 | FileCheck %s
-; RUN: not llc -march=r600 -mcpu=cypress < %s 2>&1 | FileCheck %s
+; RUN: not llc -march=amdgcn -mcpu=SI -verify-machineinstrs -exit-on-error < %s 2>&1 | FileCheck %s
+; RUN: not llc -march=amdgcn -mcpu=tonga -verify-machineinstrs -exit-on-error < %s 2>&1 | FileCheck %s
+; RUN: not llc -march=r600 -mcpu=cypress -exit-on-error < %s 2>&1 | FileCheck %s
 
 ; CHECK: in function test_call_external{{.*}}: unsupported call to function external_function
 
 
 declare i32 @external_function(i32) nounwind
 
 define void @test_call_external(i32 addrspace(1)* %out, i32 addrspace(1)* %in) {
   %b_ptr = getelementptr i32, i32 addrspace(1)* %in, i32 1

test/CodeGen/AMDGPU/dynamic_stackalloc.ll

-; RUN: not llc -march=amdgcn -mcpu=tahiti -mattr=+promote-alloca -verify-machineinstrs < %s 2>&1 | FileCheck %s
-; RUN: not llc -march=amdgcn -mcpu=tahiti -mattr=-promote-alloca -verify-machineinstrs < %s 2>&1 | FileCheck %s
-; RUN: not llc -march=r600 -mcpu=cypress < %s 2>&1 | FileCheck %s
+; RUN: not llc -march=amdgcn -mcpu=tahiti -mattr=+promote-alloca -verify-machineinstrs -exit-on-error < %s 2>&1 | FileCheck %s
+; RUN: not llc -march=amdgcn -mcpu=tahiti -mattr=-promote-alloca -verify-machineinstrs -exit-on-error < %s 2>&1 | FileCheck %s
+; RUN: not llc -march=r600 -mcpu=cypress -exit-on-error < %s 2>&1 | FileCheck %s
 
 ; CHECK: in function test_dynamic_stackalloc{{.*}}: unsupported dynamic alloca
 
 define void @test_dynamic_stackalloc(i32 addrspace(1)* %out, i32 %n) {
   %alloca = alloca i32, i32 %n
   store volatile i32 0, i32* %alloca
   ret void
 }

test/CodeGen/AMDGPU/no-hsa-graphics-shaders.ll

-; RUN: not llc -march=amdgcn -mtriple=amdgcn-unknown-amdhsa < %s 2>&1 | FileCheck %s
+; RUN: not llc -march=amdgcn -mtriple=amdgcn-unknown-amdhsa -exit-on-error < %s 2>&1 | FileCheck %s
 
 ; CHECK: in function pixel_s{{.*}}: unsupported non-compute shaders with HSA
 define amdgpu_ps void @pixel_shader() #0 {
   ret void
 }
 
 define amdgpu_vs void @vertex_shader() #0 {
   ret void
 }
 
 define amdgpu_gs void @geometry_shader() #0 {
   ret void
 }

test/CodeGen/AMDGPU/private-memory-broken.ll

-; RUN: not llc -verify-machineinstrs -march=amdgcn -mcpu=SI %s -o /dev/null 2>&1 | FileCheck %s
-; RUN: not llc -verify-machineinstrs -march=amdgcn -mcpu=tonga %s -o /dev/null 2>&1 | FileCheck %s
+; RUN: not llc -verify-machineinstrs -march=amdgcn -mcpu=SI -exit-on-error %s -o /dev/null 2>&1 | FileCheck %s
+; RUN: not llc -verify-machineinstrs -march=amdgcn -mcpu=tonga -exit-on-error %s -o /dev/null 2>&1 | FileCheck %s
 
 ; Make sure promote alloca pass doesn't crash
 
 ; CHECK: unsupported call
 
 declare i32 @foo(i32*) nounwind
 
 define void @call_private(i32 addrspace(1)* %out, i32 %in) nounwind {

test/CodeGen/AMDGPU/promote-alloca-bitcast-function.ll

-; RUN: not llc -march=amdgcn < %s 2>&1 | FileCheck %s
+; RUN: not llc -march=amdgcn -exit-on-error < %s 2>&1 | FileCheck %s
 
 ; Make sure that AMDGPUPromoteAlloca doesn't crash if the called
 ; function is a constantexpr cast of a function.
 
 declare void @foo(float*) #0
 declare void @foo.varargs(...) #0
 
 ; CHECK: in function crash_call_constexpr_cast{{.*}}: unsupported call to function foo

test/CodeGen/ARM/2012-09-25-InlineAsmScalarToVectorConv2.ll

-; RUN: not llc -mtriple=arm-eabi -mcpu=cortex-a8 %s -o - 2>&1 | FileCheck %s
+; RUN: not llc -mtriple=arm-eabi -mcpu=cortex-a8 -exit-on-error %s -o - 2>&1 | FileCheck %s
 
 ; Check for error message:
 ; CHECK: scalar-to-vector conversion failed, possible invalid constraint for vector type
 
 define hidden void @f(i32* %corr, i32 %order) nounwind ssp {
   tail call void asm sideeffect "vst1.s32 { ${1:q}, ${2:q} }, [$0]", "r,{q0},{q1}"(i32* %corr, <2 x i64>* undef, <2 x i64>* undef) nounwind, !srcloc !0
   ret void
 }
 
 !0 = !{i32 257}

test/CodeGen/BPF/many_args1.ll

-; RUN: not llc -march=bpf < %s 2> %t1
+; RUN: not llc -march=bpf -exit-on-error < %s 2> %t1
 ; RUN: FileCheck %s < %t1
 ; CHECK: too many args
 
 ; Function Attrs: nounwind uwtable
 define i32 @foo(i32 %a, i32 %b, i32 %c) #0 {
 entry:
   %call = tail call i32 @bar(i32 %a, i32 %b, i32 %c, i32 1, i32 2, i32 3) #3
   ret i32 %call
 }
 
 declare i32 @bar(i32, i32, i32, i32, i32, i32) #1

test/CodeGen/BPF/many_args2.ll

-; RUN: not llc -march=bpf < %s 2> %t1
+; RUN: not llc -march=bpf -exit-on-error < %s 2> %t1
 ; RUN: FileCheck %s < %t1
 ; CHECK: too many args
 
 ; Function Attrs: nounwind readnone uwtable
 define i32 @bar(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e, i32 %f) #0 {
 entry:
   ret i32 1
 }
 
 ; Function Attrs: nounwind readnone uwtable
 define i32 @foo(i32 %a, i32 %b, i32 %c) #0 {
 entry:
   ret i32 1
 }

test/CodeGen/BPF/struct_ret1.ll

-; RUN: not llc -march=bpf < %s 2> %t1
+; RUN: not llc -march=bpf -exit-on-error < %s 2> %t1
 ; RUN: FileCheck %s < %t1
 ; CHECK: only integer returns
 
 %struct.S = type { i32, i32, i32 }
 
 @s = common global %struct.S zeroinitializer, align 4
 
 ; Function Attrs: nounwind readonly uwtable
 define { i64, i32 } @bar(i32 %a, i32 %b, i32 %c, i32 %d, i32 %e) #0 {
 entry:
   %retval.sroa.0.0.copyload = load i64, i64* bitcast (%struct.S* @s to i64*), align 4
   %retval.sroa.2.0.copyload = load i32, i32* getelementptr inbounds (%struct.S, %struct.S* @s, i64 0, i32 2), align 4
   %.fca.0.insert = insertvalue { i64, i32 } undef, i64 %retval.sroa.0.0.copyload, 0
   %.fca.1.insert = insertvalue { i64, i32 } %.fca.0.insert, i32 %retval.sroa.2.0.copyload, 1
   ret { i64, i32 } %.fca.1.insert
 }

test/CodeGen/BPF/struct_ret2.ll

-; RUN: not llc -march=bpf < %s 2> %t1
+; RUN: not llc -march=bpf -exit-on-error < %s 2> %t1
 ; RUN: FileCheck %s < %t1
 ; CHECK: only small returns
 
 ; Function Attrs: nounwind uwtable
 define { i64, i32 } @foo(i32 %a, i32 %b, i32 %c) #0 {
 entry:
   %call = tail call { i64, i32 } @bar(i32 %a, i32 %b, i32 %c, i32 1, i32 2) #3
   ret { i64, i32 } %call
 }
 
 declare { i64, i32 } @bar(i32, i32, i32, i32, i32) #1

test/CodeGen/MIR/Generic/invalid-jump-table-kind.mir

-# RUN: not llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s
+# RUN: not llc -start-after branch-folder -stop-after branch-folder -exit-on-error -o /dev/null %s 2>&1 | FileCheck %s
 
 --- |
 
   define i32 @test_jumptable(i32 %in) {
   entry:
     switch i32 %in, label %def [
       i32 0, label %lbl1
       i32 1, label %lbl2

test/CodeGen/MIR/Generic/llvm-ir-error-reported.mir

-# RUN: not llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s
+# RUN: not llc -start-after branch-folder -stop-after branch-folder -exit-on-error -o /dev/null %s 2>&1 | FileCheck %s
 # This test ensures an error is reported if the embedded LLVM IR contains an
 # error.
 
 --- |
   
   ; CHECK: [[@LINE+3]]:15: use of undefined value '%a'
   define i32 @foo(i32 %x, i32 %y) {
     %z = alloca i32, align 4

test/CodeGen/MIR/Generic/machine-function-missing-function.mir

-# RUN: not llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s
+# RUN: not llc -start-after branch-folder -stop-after branch-folder -exit-on-error -o /dev/null %s 2>&1 | FileCheck %s
 # This test ensures that an error is reported when the mir file has LLVM IR and
 # one of the machine functions has a name that doesn't match any function in
 # the LLVM IR.
 
 --- |
 
   define i32 @foo() {
     ret i32 0

test/CodeGen/MIR/Generic/machine-function-missing-name.mir

-# RUN: not llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s
+# RUN: not llc -start-after branch-folder -stop-after branch-folder -exit-on-error -o /dev/null %s 2>&1 | FileCheck %s
 # This test ensures that an error is reported when a machine function doesn't
 # have a name attribute.
 
 --- |
 
   define i32 @foo() {
     ret i32 0
   }

test/CodeGen/MIR/Generic/machine-function-redefinition-error.mir

-# RUN: not llc -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s
+# RUN: not llc -start-after branch-folder -stop-after branch-folder -exit-on-error -o /dev/null %s 2>&1 | FileCheck %s
 # This test ensures that the machine function errors are reported correctly.
 
 ---
 name:            foo
 ...
 ---
 # CHECK: redefinition of machine function 'foo'
 name:            foo
 ...

test/CodeGen/MIR/X86/spill-slot-fixed-stack-object-aliased.mir

-# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s
+# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -exit-on-error -o /dev/null %s 2>&1 | FileCheck %s
 
 --- |
 
   define i32 @test(i32 %a) #0 {
   entry:
     %b = alloca i32
     store i32 %a, i32* %b
     %c = load i32, i32* %b

test/CodeGen/MIR/X86/spill-slot-fixed-stack-object-immutable.mir

-# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s
+# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -exit-on-error -o /dev/null %s 2>&1 | FileCheck %s
 
 --- |
 
   define i32 @test(i32 %a) #0 {
   entry:
     %b = alloca i32
     store i32 %a, i32* %b
     %c = load i32, i32* %b

test/CodeGen/MIR/X86/variable-sized-stack-object-size-error.mir

-# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -o /dev/null %s 2>&1 | FileCheck %s
+# RUN: not llc -march=x86-64 -start-after branch-folder -stop-after branch-folder -exit-on-error -o /dev/null %s 2>&1 | FileCheck %s
 --- |
 
   define i32 @test(i32 %a) {
   entry:
     %b = alloca i32
     %x = alloca i64
     %y = alloca i32, i32 %a
     store i32 %a, i32* %b

test/CodeGen/PowerPC/crbit-asm-disabled.ll

-; RUN: not llc -mcpu=pwr7 -o /dev/null %s 2>&1 | FileCheck %s
+; RUN: not llc -mcpu=pwr7 -exit-on-error -o /dev/null %s 2>&1 | FileCheck %s
 target datalayout = "E-m:e-i64:64-n32:64"
 target triple = "powerpc64-unknown-linux-gnu"
 
 define zeroext i1 @testi1(i1 zeroext %b1, i1 zeroext %b2) #0 {
 entry:
   %0 = tail call i8 asm "crand $0, $1, $2", "=^wc,^wc,^wc"(i1 %b1, i1 %b2) #0
   %1 = and i8 %0, 1
   %tobool3 = icmp ne i8 %1, 0
   ret i1 %tobool3
 
 ; CHECK: error: couldn't allocate output register for constraint 'wc'
 }
 
 attributes #0 = { nounwind "target-features"="-crbits" }
 

test/CodeGen/PowerPC/vec-asm-disabled.ll

-; RUN: not llc -mcpu=pwr7 -o /dev/null %s 2>&1 | FileCheck %s
+; RUN: not llc -mcpu=pwr7 -exit-on-error -o /dev/null %s 2>&1 | FileCheck %s
 target datalayout = "E-m:e-i64:64-n32:64"
 target triple = "powerpc64-unknown-linux-gnu"
 
 define <4 x i32> @testi1(<4 x i32> %b1, <4 x i32> %b2) #0 {
 entry:
   %0 = call <4 x i32> asm "xxland $0, $1, $2", "=^wd,^wd,^wd"(<4 x i32> %b1, <4 x i32> %b2) #0
   ret <4 x i32> %0
 
 ; CHECK: error: couldn't allocate output register for constraint 'wd'
 }
 
 attributes #0 = { nounwind "target-features"="-vsx" }
 

test/CodeGen/X86/asm-reject-reg-type-mismatch.ll

-; RUN: not llc -o /dev/null %s 2>&1 | FileCheck %s
+; RUN: not llc -exit-on-error -o /dev/null %s 2>&1 | FileCheck %s
 target triple = "x86_64--"
 
 ; CHECK: error: couldn't allocate output register for constraint '{ax}'
 define i128 @blup() {
   %v = tail call i128 asm "", "={ax},0"(i128 0)
   ret i128 %v
 }

tools/llc/llc.cpp

 #include "llvm/CodeGen/CommandFlags.h"
 #include "llvm/CodeGen/LinkAllAsmWriterComponents.h"
 #include "llvm/CodeGen/LinkAllCodegenComponents.h"
 #include "llvm/CodeGen/MIRParser/MIRParser.h"
 #include "llvm/CodeGen/MachineFunctionPass.h"
 #include "llvm/CodeGen/MachineModuleInfo.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/IR/DataLayout.h"
+#include "llvm/IR/DiagnosticInfo.h"
+#include "llvm/IR/DiagnosticPrinter.h"
 #include "llvm/IR/IRPrintingPasses.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/MC/SubtargetFeature.h"
 #include "llvm/Pass.h"
CompileTwice("compile-twice", cl::Hidden,
                           "manager and verify the result is the same."),
                  cl::init(false));
 
 static cl::opt<bool> DiscardValueNames(
     "discard-value-names",
     cl::desc("Discard names from Value (other than GlobalValue)."),
     cl::init(false), cl::Hidden);
 
+static cl::opt<bool> ExitOnError(
+    "exit-on-error",
+    cl::desc("Exit as soon as an error is encountered."),
+    cl::init(false), cl::Hidden);
+
 static int compileModule(char **, LLVMContext &);
 
 static std::unique_ptr<tool_output_file>
 GetOutputStream(const char *TargetName, Triple::OSType OS,
                 const char *ProgName) {
   // If we don't yet have an output filename, make one.
   if (OutputFilename.empty()) {
     if (InputFilename == "-")
GetOutputStream(const char *TargetName, Triple::OSType OS,
   if (EC) {
     errs() << EC.message() << '\n';
     return nullptr;
   }
 
   return FDOut;
 }
 
+static void DiagnosticHandler(const DiagnosticInfo &DI, void *Context) {
+  bool *HasError = static_cast<bool *>(Context);
+  if (DI.getSeverity() == DS_Error)
+    *HasError = true;
+
+  DiagnosticPrinterRawOStream DP(errs());
+  errs() << LLVMContext::getDiagnosticMessagePrefix(DI.getSeverity()) << ": ";
+  DI.print(DP);
+  errs() << "\n";
+}
+
 // main - Entry point for the llc compiler.
 //
 int main(int argc, char **argv) {
   sys::PrintStackTraceOnErrorSignal();
   PrettyStackTraceProgram X(argc, argv);
 
   // Enable debug stream buffering.
   EnableDebugBuffering = true;
int main(int argc, char **argv) {
 
   // Register the target printer for --version.
   cl::AddExtraVersionPrinter(TargetRegistry::printRegisteredTargetsForVersion);
 
   cl::ParseCommandLineOptions(argc, argv, "llvm system compiler\n");
 
   Context.setDiscardValueNames(DiscardValueNames);
 
+  // Set a diagnostic handler that doesn't exit on the first error
+  if (!ExitOnError) {
+    bool HasError = false;
+    Context.setDiagnosticHandler(DiagnosticHandler, &HasError);
+  }
+
   // Compile the module TimeCompilations times to give better compile time
   // metrics.
   for (unsigned I = TimeCompilations; I; --I)
     if (int RetVal = compileModule(argv, Context))
       return RetVal;
   return 0;
 }
 
if (CompileTwice) {
       std::unique_ptr<Module> M2(llvm::CloneModule(M.get()));
       PM.run(*M2);
       CompileTwiceBuffer = Buffer;
       Buffer.clear();
     }
 
     PM.run(*M);
 
+    if (!ExitOnError) {
+      auto HasError = *static_cast<bool *>(Context.getDiagnosticContext());
+      if (HasError)
+        return 1;
+    }
+
     // Compare the two outputs and make sure they're the same
     if (CompileTwice) {
       if (Buffer.size() != CompileTwiceBuffer.size() ||
           (memcmp(Buffer.data(), CompileTwiceBuffer.data(), Buffer.size()) !=
            0)) {
         errs()
             << "Running the pass manager twice changed the output.\n"
                "Writing the result of the second run to the specified output\n"