Add artificial debug information to avoid compiler crash

[ygao]

Summary

Hi,
The compiler crashed with the following test program:

/* test.c

• To reproduce:
• $ clang -c -g -fstack-protector-strong test.c
• (fatal error: error in backend: Broken function found, compilation aborted!)
• (need an assertion-enabled build of the compiler) */

void __stack_chk_fail(void) { return; }

void foo() {

char bar[5];

}
/* end of test.c */

This is not a legitimate input C file because __stack_chk_fail is a reserved function name.
On the other hand, it seems that the compiler should be able to give a nicer diagnostic or
otherwise fail more gracefully instead of having to crash on invalid input (in the spirit of all
"internal compiler error"s are compiler bugs).

The proposed patch here attempts to add artificial debug information when the compiler
generates the call to __stack_chk_fail. Does this look like a reasonable thing to do?

Many thanks in advance,

• Gao

[aprantl]

Is it possible to just use

auto NL = ApplyDebugLocation::CreateArtificial(CodeGenFunction);

instead?

[aprantl]

See r267904 for a similar change.

[probinson]

Any time we spontaneously emit a call at the IR level, we'd need to put in a line-0 location. Is this the only one?
Fred's patch (D16569) won't help here because that happens after instruction selection, and this looks like an IR verifier crash.

[ygao]

Hi @aprantl,
I looked at r267904 per your suggestion. Thanks. It looks like it is a cfe patch, and ApplyDebugLocation::CreateArtificial() is defined in clang. Is it okay to use clang functions in the LLVM backend? This particular stackprotector pass is in the llvm backend, and I am under the impression that it is not allowed to use clang functions, but I could be wrong,

• Gao

Any time we spontaneously emit a call at the IR level, we'd need to put in a line-0 location. Is this the only one?

I do not know. I'm willing to bet that this is not the only one, but I do not know yet how to find out for sure,

[aprantl]

Sorry! I completely missed the fact that this was not a clang patch. In that case this patch LGTM.

thanks!

llvm/trunk/lib/CodeGen/StackProtector.cpp

 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/BranchProbabilityInfo.h"
 #include "llvm/Analysis/EHPersonalities.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/IR/Attributes.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
+#include "llvm/IR/DebugInfo.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/Intrinsics.h"

 }
 
 /// CreateFailBB - Create a basic block to jump to when the stack protector
 /// check fails.
 BasicBlock *StackProtector::CreateFailBB() {
   LLVMContext &Context = F->getContext();
   BasicBlock *FailBB = BasicBlock::Create(Context, "CallStackCheckFailBlk", F);
   IRBuilder<> B(FailBB);
+  B.SetCurrentDebugLocation(DebugLoc::get(0, 0, F->getSubprogram()));
   if (Trip.isOSOpenBSD()) {
     Constant *StackChkFail =
         M->getOrInsertFunction("__stack_smash_handler",
                                Type::getVoidTy(Context),
                                Type::getInt8PtrTy(Context), nullptr);
 
     B.CreateCall(StackChkFail, B.CreateGlobalStringPtr(F->getName(), "SSH"));
   } else {

llvm/trunk/test/CodeGen/X86/stack-protector.ll

; MSVC-I386: calll @__security_check_cookie@4
   %test = alloca i8*, align 8
   %0 = alloca i8, i64 5
   store i8* %0, i8** %test, align 8
   %1 = load i8*, i8** %test, align 8
   %call = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i32 0, i32 0), i8* %1)
   ret i32 %call
 }
 
+define void @__stack_chk_fail() #1 !dbg !6 {
+entry:
+  ret void
+}
+
+define void @test32() #1 !dbg !7 {
+entry:
+  %0 = alloca [5 x i8], align 1
+  ret void
+}
+
 declare double @testi_aux()
 declare i8* @strcpy(i8*, i8*)
 declare i32 @printf(i8*, ...)
 declare void @funcall(i32*)
 declare void @funcall2(i32**)
 declare void @funfloat(float*)
 declare void @funfloat2(float**)
 declare void @_Z3exceptPi(i32*)
 declare i32 @__gxx_personality_v0(...)
 declare i32* @getp()
 declare i32 @dummy(...)
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i32, i1)
 
 attributes #0 = { ssp }
 attributes #1 = { sspstrong }
 attributes #2 = { sspreq }
 attributes #3 = { ssp "stack-protector-buffer-size"="33" }
 attributes #4 = { ssp "stack-protector-buffer-size"="5" }
 attributes #5 = { ssp "stack-protector-buffer-size"="6" }
+
+!llvm.dbg.cu = !{!0}
+!llvm.module.flags = !{!3, !4}
+!llvm.ident = !{!5}
+
+!0 = distinct !DICompileUnit(language: DW_LANG_C99, file: !1)
+!1 = !DIFile(filename: "test.c", directory: "/tmp")
+!2 = !{}
+!3 = !{i32 2, !"Dwarf Version", i32 4}
+!4 = !{i32 2, !"Debug Info Version", i32 3}
+!5 = !{!"clang version x.y.z"}
+!6 = distinct !DISubprogram(name: "__stack_chk_fail", scope: !1, unit: !0)
+!7 = distinct !DISubprogram(name: "foo", scope: !1, unit: !0)