r225000 - Reapply "DebugInfo: Generalize debug info location handling"
David Blaikie
dblaikie at gmail.com
Fri Jan 9 13:56:28 PST 2015
On Fri, Jan 9, 2015 at 1:51 PM, Adrian Prantl <aprantl at apple.com> wrote:
>
> On Jan 9, 2015, at 1:46 PM, David Blaikie <dblaikie at gmail.com> wrote:
>
>
>
> On Fri, Jan 9, 2015 at 1:34 PM, Adrian Prantl <aprantl at apple.com> wrote:
>
>>
>> On Jan 9, 2015, at 1:23 PM, David Blaikie <dblaikie at gmail.com> wrote:
>>
>>
>>
>> On Fri, Jan 9, 2015 at 1:10 PM, Adrian Prantl <aprantl at apple.com> wrote:
>>
>>>
>>> On Jan 9, 2015, at 1:04 PM, Adrian Prantl <aprantl at apple.com> wrote:
>>>
>>>
>>> On Jan 9, 2015, at 12:20 PM, David Blaikie <dblaikie at gmail.com> wrote:
>>>
>>>
>>>
>>> On Fri, Jan 9, 2015 at 11:52 AM, Adrian Prantl <aprantl at apple.com>
>>> wrote:
>>>
>>>> FYI: I’m hitting this assertion on today’s ToT with the following
>>>> program:
>>>>
>>>> @protocol NSObject
>>>> @end
>>>> @interface NSObject <NSObject>
>>>> @end
>>>> int printf(const char * __restrict, ...);
>>>> struct Foo
>>>> {
>>>> int mId;
>>>> ~Foo(){
>>>> printf("~Foo(%d)\n", mId);
>>>> };
>>>> };
>>>> @interface TNSObject : NSObject
>>>> {
>>>> Foo _cppObjectNonAtomic;
>>>> }
>>>> @property (assign, readwrite, nonatomic) const Foo& cppObjectNonAtomic;
>>>> @end
>>>> @implementation TNSObject
>>>> - (id)init
>>>> {
>>>> Foo cppObject;
>>>> self.cppObjectNonAtomic = cppObject;
>>>> }
>>>> @end
>>>>
>>>> $ clang "-cc1" "-triple" "x86_64-apple-macosx10.10.0" "-emit-obj"
>>>> "-gdwarf-2" "-stdlib=libc++" "-Os" "-fexceptions" "-x" "objective-c++"
>>>> test1.mm
>>>>
>>>> Looks like ~Foo() is getting inlined into [TNSObject init] without the
>>>> scope being updated with an InlinedAt location. I’ll keep digging.
>>>>
>>>
>>> I'll be reverting this shortly - there's a bunch of regressions of a
>>> similar flavor recorded on the relevant bug, but any reduced test cases
>>> will be handy when trying to ensure everything's covered before I recommit.
>>>
>>> The 'root cause' in (almost?) all of these should be something like this:
>>>
>>> 1) a function with debug info (a function appearing in the CU's
>>> subprogram list) calls
>>> 2) another function with debug info through
>>> 3) a call instruction with no debugloc
>>>
>>>
>>> In the particular case I posted above, the problem appears to be with
>>> the call to ~Foo from within the landingpad:
>>>
>>> lpad: ; preds = %entry
>>> %4 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)*
>>> @__gxx_personality_v0 to i8*)
>>> cleanup
>>> %5 = extractvalue { i8*, i32 } %4, 0
>>> store i8* %5, i8** %exn.slot
>>> %6 = extractvalue { i8*, i32 } %4, 1
>>> store i32 %6, i32* %ehselector.slot
>>> invoke void @_ZN3FooD1Ev(%struct.Foo* %cppObject)
>>> to label %invoke.cont1 unwind label %terminate.lpad ; Note
>>> that none of the insns in the landingpad have a DebugLoc
>>>
>>> which after inlining turns into
>>>
>>> lpad: ; preds = %entry
>>> %3 = landingpad { i8*, i32 } personality i8* bitcast (i32 (...)*
>>> @__gxx_personality_v0 to i8*)
>>> cleanup
>>> call void @llvm.dbg.value(metadata %struct.Foo* %cppObject, i64 0,
>>> metadata !64, metadata !76), !dbg !93
>>> call void @llvm.dbg.value(metadata %struct.Foo* %cppObject, i64 0,
>>> metadata !94, metadata !76), !dbg !96
>>> %mId.i.i3 = getelementptr inbounds %struct.Foo* %cppObject, i64 0, i32
>>> 0, !dbg !97
>>> %4 = load i32* %mId.i.i3, align 4, !dbg !97, !tbaa !88
>>> %call.i.i45 = invoke i32 (i8*, ...)* @_Z6printfPKcz(i8* getelementptr
>>> inbounds ([10 x i8]* @.str, i64 0, i64 0), i32 %4) #6
>>> to label %eh.resume unwind label %terminate.lpad, !dbg !97
>>>
>>> !97 = !{i32 10, i32 0, !87, !95}
>>> !95 = !{i32 9, i32 0, !62, null} <-- wrong. Should be _ZN3FooD2Ev
>>> inlined into _ZN3FooD1Ev
>>>
>>> One one hand this is a bug in InlineFunction.cpp:fixupLineNumbers(), but
>>> we could also attach DebugLocs to those instructions in CFE in the first
>>> place.
>>>
>>> -- adrian
>>>
>>> <test2.ll>
>>> <test1.ll>
>>>
>>>
>>>
>>> Looks like it’s actually pretty obvious why this happens:
>>>
>>> /// fixupLineNumbers - Update inlined instructions' line numbers to
>>> /// to encode location where these instructions are inlined.
>>> static void fixupLineNumbers(Function *Fn, Function::iterator FI,
>>> Instruction *TheCall) {
>>> DebugLoc TheCallDL = TheCall->getDebugLoc();
>>> if (TheCallDL.isUnknown())
>>> return; <------
>>>
>>> Instead it should create a new (line 0?) DebugLoc with a correct Inlined
>>> scope. A safe bet would be using the function scope of the call instruction.
>>>
>>
>> As I was saying in the other thread, I'd rather not make this acceptable
>> - I managed to clean up all the failures of this assertion previously and
>> in doing so found and fixed a lot of bugs. If we made this acceptable the
>> assertion wouldn't've found the bugs I just introduced with this patch. :/
>>
>>
>> I can’t follow you here: fixupLineNumbers() has to do _something_ to the
>> DebugLocs of the inlined instructions or the assertion would be triggered.
>>
>
> Not necessarily - the alternative (which is essentially, lazily, enforced
> by the assertion that fired) is to assert & not accept this state of
> affairs at all. That's worked for a few months now & I hope it continues to
> work because it helps find bugs rather than silently accepting them. Once
> that situation no longer asserts (either up front or lazily where it is
> now) these bugs will creep back in, which would be sad-making.
>
> IMO that’s not what happened at all: The assertion did find a bug, and it
> is in fixupLineNumbers().
>
> Here’s an example that would always trigger the assertion if we don’t fix
> fixupLineNumbers(): inlining a function built with debug info into one that
> was built without debug info.
>
Try it - it shouldn't assert. The assertion only fires when the caller has
debug info as well.
This assertion has been in clang for about 4 months after I finished
cleaning up all the cases I could find (& all the cases I found were bugs,
and not in the inliner). As I mentioned earlier, the situation arises (to
the best of my knowledge after months of tracking down failures found by
this assertion) when:
1) a function with debug info calls
2) a function with instructions with debuglocs (not necessarily a function
with debug info - it could be a nodebug function that's had debug functions
inlined into it already) through
3) a call without a debug location
(and that call is then inlined)
Notice that the assertion is in the LexicalScopes thing, and we only build
LexicalScopes if we're in a function with debug info.
- David
>
> -- adrian
>
>
> - David
>
>
>> And the assertion was triggered _because_ what fixupLineNumbers()
>> currently does is wrong if the call instruction has no debug location (and
>> the inlined instructions have one).
>>
>>
>> -- adrian
>>
>>
>> - David
>>
>>
>>>
>>> -- adrian
>>>
>>>
>>>
>>> When that situation is created and inlining can occur through that call,
>>> the debug info doesn't get updated with inlinedAt info and everything else
>>> is bad from there on.
>>>
>>> If you can produce any short test cases that demonstrate this commit
>>> causing such a call (3) to go from having a debugloc to not having a
>>> debugloc, that would be great to have.
>>>
>>> - David
>>>
>>>
>>>>
>>>> -- adrian
>>>>
>>>>
>>>> On Jan 7, 2015, at 10:30 AM, Nico Weber <thakis at chromium.org> wrote:
>>>>
>>>> On Mon, Jan 5, 2015 at 9:57 PM, Nico Weber <thakis at chromium.org> wrote:
>>>>
>>>>> On Mon, Jan 5, 2015 at 9:07 PM, Jiangning Liu <liujiangning1 at gmail.com
>>>>> > wrote:
>>>>>
>>>>>> Hi David,
>>>>>>
>>>>>> This commit introduced a regression for one of my benchmarks, and the
>>>>>> failure is an assertion failure.
>>>>>>
>>>>>> The failure point is at
>>>>>>
>>>>>> LexicalScope *LexicalScopes::getOrCreateRegularScope(MDNode *Scope) {
>>>>>> ......
>>>>>> if (!Parent) {
>>>>>> assert(DIDescriptor(Scope).isSubprogram());
>>>>>> assert(DISubprogram(Scope).describes(MF->getFunction())); //
>>>>>> Assertion failure here!
>>>>>>
>>>>>
>>>>> That looks like something I debugged earlier today. This is
>>>>> http://llvm.org/PR22096 , which already has a reduction.
>>>>>
>>>>
>>>> For me, the problem went away when I reverted r225085 (I landed the
>>>> revert in r225361), and they were unrelated to this change. Jinangning,
>>>> does trunk work for you? Are you sure that your problem was caused by this
>>>> change (r225000)?
>>>>
>>>>
>>>>>
>>>>>
>>>>>> assert(!CurrentFnLexicalScope);
>>>>>> CurrentFnLexicalScope = &I->second;
>>>>>> }
>>>>>>
>>>>>> return &I->second;
>>>>>> }
>>>>>>
>>>>>> And the call stack is like,
>>>>>>
>>>>>> 8 libLLVMCodeGen.so 0x00007fc17123eb31
>>>>>> llvm::LexicalScopes::getOrCreateRegularScope(llvm::MDNode*) + 305
>>>>>> 9 libLLVMCodeGen.so 0x00007fc17123e986
>>>>>> llvm::LexicalScopes::getOrCreateInlinedScope(llvm::MDNode*, llvm::MDNode*)
>>>>>> + 326
>>>>>> 10 libLLVMCodeGen.so 0x00007fc17123e979
>>>>>> llvm::LexicalScopes::getOrCreateInlinedScope(llvm::MDNode*, llvm::MDNode*)
>>>>>> + 313
>>>>>> 11 libLLVMCodeGen.so 0x00007fc17123e95a
>>>>>> llvm::LexicalScopes::getOrCreateInlinedScope(llvm::MDNode*, llvm::MDNode*)
>>>>>> + 282
>>>>>> 12 libLLVMCodeGen.so 0x00007fc17123e979
>>>>>> llvm::LexicalScopes::getOrCreateInlinedScope(llvm::MDNode*, llvm::MDNode*)
>>>>>> + 313
>>>>>> 13 libLLVMCodeGen.so 0x00007fc17123de78
>>>>>> llvm::LexicalScopes::extractLexicalScopes(llvm::SmallVectorImpl<std::pair<llvm::MachineInstr
>>>>>> const*, llvm::MachineInstr const*> >&, llvm::DenseMap<llvm::MachineInstr
>>>>>> const*, llvm::LexicalScope*, llvm::DenseMapInfo<llvm::MachineInstr const*>,
>>>>>> llvm::detail::DenseMapPair<llvm::MachineInstr const*, llvm::LexicalScope*>
>>>>>> >&) + 1064
>>>>>> 14 libLLVMCodeGen.so 0x00007fc17123d9ee
>>>>>> llvm::LexicalScopes::initialize(llvm::MachineFunction const&) + 78
>>>>>> 15 libLLVMCodeGen.so 0x00007fc171240815
>>>>>> llvm::LiveDebugVariables::runOnMachineFunction(llvm::MachineFunction&) + 933
>>>>>> 16 libLLVMCodeGen.so 0x00007fc1712a327c
>>>>>> llvm::MachineFunctionPass::runOnFunction(llvm::Function&) + 124
>>>>>> 17 libLLVMCore.so 0x00007fc17105ac7a
>>>>>> llvm::FPPassManager::runOnFunction(llvm::Function&) + 362
>>>>>> 18 libLLVMCore.so 0x00007fc17105af0b
>>>>>> llvm::FPPassManager::runOnModule(llvm::Module&) + 43
>>>>>> 19 libLLVMCore.so 0x00007fc17105b4a7
>>>>>> llvm::legacy::PassManagerImpl::run(llvm::Module&) + 999
>>>>>> 20 libclangCodeGen.so 0x00007fc16fe12c4d
>>>>>> clang::EmitBackendOutput(clang::DiagnosticsEngine&, clang::CodeGenOptions
>>>>>> const&, clang::TargetOptions const&, clang::LangOptions const&,
>>>>>> llvm::StringRef, llvm::Module*, clang::BackendAction, llvm::raw_ostream*) +
>>>>>> 7741
>>>>>> 21 libclangCodeGen.so 0x00007fc16ff60e85
>>>>>> 22 libclangParse.so 0x00007fc16f847da3
>>>>>> clang::ParseAST(clang::Sema&, bool, bool) + 467
>>>>>> 23 libclangCodeGen.so 0x00007fc16ff5fbbc
>>>>>> clang::CodeGenAction::ExecuteAction() + 204
>>>>>> 24 libclangFrontend.so 0x00007fc17047f21e
>>>>>> clang::FrontendAction::Execute() + 62
>>>>>> 25 libclangFrontend.so 0x00007fc17044e97c
>>>>>> clang::CompilerInstance::ExecuteAction(clang::FrontendAction&) + 892
>>>>>> 26 libclangFrontendTool.so 0x00007fc1703d603a
>>>>>> clang::ExecuteCompilerInvocation(clang::CompilerInstance*) + 3050
>>>>>> 27 clang-3.6 0x000000000040cb71
>>>>>> cc1_main(llvm::ArrayRef<char const*>, char const*, void*) + 577
>>>>>> 28 clang-3.6 0x000000000040ba64 main + 12276
>>>>>> 29 libc.so.6 0x00007fc16cf91de5 __libc_start_main + 245
>>>>>> 30 clang-3.6 0x0000000000408961
>>>>>>
>>>>>> ....
>>>>>> 1. <eof> parser at end of file
>>>>>> 2. Code generation
>>>>>> 3. Running pass 'Function Pass Manager' on module 'x.i.cc'.
>>>>>> 4. Running pass 'Debug Variable Analysis' on function
>>>>>> '@__cxx_global_var_init9'
>>>>>> clang-3.6: error: unable to execute command: Aborted (core dumped)
>>>>>> clang-3.6: error: clang frontend command failed due to signal (use -v
>>>>>> to see invocation)
>>>>>>
>>>>>> Since the test case is huge, I'm trying to narrow down to a small
>>>>>> test case. But before I can work out that, I want to let you know first, in
>>>>>> case you know something about that, and can get it fixed without a test
>>>>>> case.
>>>>>>
>>>>>> Thanks,
>>>>>> -Jiangning
>>>>>>
>>>>>>
>>>>>> 2015-01-03 3:55 GMT+08:00 Jeroen Ketema <j.ketema at imperial.ac.uk>:
>>>>>>
>>>>>>>
>>>>>>> On 02 Jan 2015, at 20:08, David Blaikie <dblaikie at gmail.com> wrote:
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> On Wed, Dec 31, 2014 at 2:52 AM, Jeroen Ketema <
>>>>>>> j.ketema at imperial.ac.uk> wrote:
>>>>>>>
>>>>>>>> Hi David ,
>>>>>>>>
>>>>>>>> This commit is giving me some problems with the code below when
>>>>>>>> compiled with
>>>>>>>>
>>>>>>>> clang -Wall -g -gcolumn-info -emit-llvm -c foo.c
>>>>>>>>
>>>>>>>> For the first loop the debug information attached to the srem
>>>>>>>> instruction generated for “j % 16” refers to line 10, which is correct.
>>>>>>>> However, for the second loop the debug information refers to line 17 and
>>>>>>>> not to the expected line 18; only the call to __f on line 18 has line 18
>>>>>>>> attached to it, while the call to __i, the srem instruction, etc. have line
>>>>>>>> 17 attached to it.
>>>>>>>>
>>>>>>>> void __i(int);
>>>>>>>> void __f(void);
>>>>>>>>
>>>>>>>> #define __fi(X) __f(),__i(X)
>>>>>>>>
>>>>>>>> void foo()
>>>>>>>> {
>>>>>>>> for(int j = 0;
>>>>>>>> __f(), __i(0 <= j),
>>>>>>>> __f(), __i((j % 16) == 0), // line 10
>>>>>>>> j < 1600;
>>>>>>>> j += 16)
>>>>>>>> {
>>>>>>>> }
>>>>>>>>
>>>>>>>> for(int j = 0;
>>>>>>>> __fi(0 <= j), // line 17
>>>>>>>> __fi((j % 16) == 0), // line 18
>>>>>>>> j < 1600;
>>>>>>>> j += 16)
>>>>>>>> {
>>>>>>>> }
>>>>>>>> }
>>>>>>>>
>>>>>>>>
>>>>>>> Thanks for the report/example/etc. This should be fixed in r225083.
>>>>>>> Let me know if it isn't or you see any other line info quality issues going
>>>>>>> forward.
>>>>>>>
>>>>>>>
>>>>>>> Thanks. This indeed fixes things for me.
>>>>>>>
>>>>>>> ---
>>>>>>> Jeroen
>>>>>>>
>>>>>>>
>>>>>>> - David
>>>>>>>
>>>>>>>
>>>>>>>> ---
>>>>>>>> Regards,
>>>>>>>>
>>>>>>>> Jeroen
>>>>>>>>
>>>>>>>> > On 30 Dec 2014, at 20:39, David Blaikie <dblaikie at gmail.com>
>>>>>>>> wrote:
>>>>>>>> >
>>>>>>>> > Author: dblaikie
>>>>>>>> > Date: Tue Dec 30 13:39:33 2014
>>>>>>>> > New Revision: 225000
>>>>>>>> >
>>>>>>>> > URL: http://llvm.org/viewvc/llvm-project?rev=225000&view=rev
>>>>>>>> > Log:
>>>>>>>> > Reapply "DebugInfo: Generalize debug info location handling"
>>>>>>>> >
>>>>>>>> > Originally committed in r224385 and reverted in r224441 due to
>>>>>>>> concerns
>>>>>>>> > this change might've introduced a crash. Turns out this change
>>>>>>>> fixes the
>>>>>>>> > crash introduced by one of my earlier more specific location
>>>>>>>> handling
>>>>>>>> > changes (those specific fixes are reverted by this patch, in
>>>>>>>> favor of
>>>>>>>> > the more general solution).
>>>>>>>> >
>>>>>>>> > Recommitted in r224941 and reverted in r224970 after it caused a
>>>>>>>> crash
>>>>>>>> > when building compiler-rt. Looks to be due to this change zeroing
>>>>>>>> out
>>>>>>>> > the debug location when emitting default arguments (which were
>>>>>>>> meant to
>>>>>>>> > inherit their outer expression's location) thus creating call
>>>>>>>> > instructions without locations - these create problems for
>>>>>>>> inlining and
>>>>>>>> > must not be created. That is fixed and tested in this version of
>>>>>>>> the
>>>>>>>> > change.
>>>>>>>> >
>>>>>>>> > Original commit message:
>>>>>>>> >
>>>>>>>> > This is a more scalable (fixed in mostly one place, rather than
>>>>>>>> many
>>>>>>>> > places that will need constant improvement/maintenance) solution
>>>>>>>> to
>>>>>>>> > several commits I've made recently to increase source fidelity for
>>>>>>>> > subexpressions.
>>>>>>>> >
>>>>>>>> > This resetting had to be done at the DebugLoc level (not the
>>>>>>>> > SourceLocation level) to preserve scoping information (if the
>>>>>>>> resetting
>>>>>>>> > was done with CGDebugInfo::EmitLocation, it would've caused the
>>>>>>>> tail end
>>>>>>>> > of an expression's codegen to end up in a potentially different
>>>>>>>> scope
>>>>>>>> > than the start, even though it was at the same source location).
>>>>>>>> The
>>>>>>>> > drawback to this is that it might leave CGDebugInfo out of sync.
>>>>>>>> Ideally
>>>>>>>> > CGDebugInfo shouldn't have a duplicate sense of the current
>>>>>>>> > SourceLocation, but for now it seems it does... - I don't think
>>>>>>>> I'm
>>>>>>>> > going to tackle removing that just now.
>>>>>>>> >
>>>>>>>> > I expect this'll probably cause some more buildbot fallout & I'll
>>>>>>>> > investigate that as it comes up.
>>>>>>>> >
>>>>>>>> > Also these sort of improvements might be starting to show a
>>>>>>>> weakness/bug
>>>>>>>> > in LLVM's line table handling: we don't correctly emit is_stmt for
>>>>>>>> > statements, we just put it on every line table entry. This means
>>>>>>>> one
>>>>>>>> > statement split over multiple lines appears as multiple
>>>>>>>> 'statements' and
>>>>>>>> > two statements on one line (without column info) are treated as
>>>>>>>> one
>>>>>>>> > statement.
>>>>>>>> >
>>>>>>>> > I don't think we have any IR representation of statements that
>>>>>>>> would
>>>>>>>> > help us distinguish these cases and identify the beginning of each
>>>>>>>> > statement - so that might be something we need to add (possibly
>>>>>>>> to the
>>>>>>>> > lexical scope chain - a scope for each statement). This does
>>>>>>>> cause some
>>>>>>>> > problems for GDB and possibly other DWARF consumers.
>>>>>>>> >
>>>>>>>> > Modified:
>>>>>>>> > cfe/trunk/lib/CodeGen/CGBlocks.cpp
>>>>>>>> > cfe/trunk/lib/CodeGen/CGClass.cpp
>>>>>>>> > cfe/trunk/lib/CodeGen/CGCleanup.cpp
>>>>>>>> > cfe/trunk/lib/CodeGen/CGDebugInfo.cpp
>>>>>>>> > cfe/trunk/lib/CodeGen/CGDebugInfo.h
>>>>>>>> > cfe/trunk/lib/CodeGen/CGDecl.cpp
>>>>>>>> > cfe/trunk/lib/CodeGen/CGDeclCXX.cpp
>>>>>>>> > cfe/trunk/lib/CodeGen/CGException.cpp
>>>>>>>> > cfe/trunk/lib/CodeGen/CGExpr.cpp
>>>>>>>> > cfe/trunk/lib/CodeGen/CGExprCXX.cpp
>>>>>>>> > cfe/trunk/lib/CodeGen/CGExprComplex.cpp
>>>>>>>> > cfe/trunk/lib/CodeGen/CGExprScalar.cpp
>>>>>>>> > cfe/trunk/lib/CodeGen/CGStmt.cpp
>>>>>>>> > cfe/trunk/lib/CodeGen/CGStmtOpenMP.cpp
>>>>>>>> > cfe/trunk/lib/CodeGen/CodeGenFunction.h
>>>>>>>> > cfe/trunk/test/CodeGenCXX/PR20038.cpp
>>>>>>>> > cfe/trunk/test/CodeGenCXX/debug-info-line.cpp
>>>>>>>> > cfe/trunk/test/CodeGenCXX/debug-info-scope.cpp
>>>>>>>> >
>>>>>>>> > Modified: cfe/trunk/lib/CodeGen/CGBlocks.cpp
>>>>>>>> > URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGBlocks.cpp?rev=225000&r1=224999&r2=225000&view=diff
>>>>>>>> >
>>>>>>>> ==============================================================================
>>>>>>>> > --- cfe/trunk/lib/CodeGen/CGBlocks.cpp (original)
>>>>>>>> > +++ cfe/trunk/lib/CodeGen/CGBlocks.cpp Tue Dec 30 13:39:33 2014
>>>>>>>> > @@ -874,7 +874,7 @@ llvm::Value *CodeGenFunction::EmitBlockL
>>>>>>>> > // locations of subexpressions in the initialization.
>>>>>>>> > EmitExprAsInit(&l2r, &blockFieldPseudoVar,
>>>>>>>> > MakeAddrLValue(blockField, type, align),
>>>>>>>> > - /*captured by init*/ false,
>>>>>>>> SourceLocation());
>>>>>>>> > + /*captured by init*/ false);
>>>>>>>> > }
>>>>>>>> >
>>>>>>>> > // Activate the cleanup if layout pushed one.
>>>>>>>> > @@ -1175,7 +1175,7 @@ CodeGenFunction::GenerateBlockFunction(G
>>>>>>>> > Alloca->setAlignment(Align);
>>>>>>>> > // Set the DebugLocation to empty, so the store is recognized
>>>>>>>> as a
>>>>>>>> > // frame setup instruction by
>>>>>>>> llvm::DwarfDebug::beginFunction().
>>>>>>>> > - NoLocation NL(*this, Builder);
>>>>>>>> > + ApplyDebugLocation NL(*this);
>>>>>>>> > Builder.CreateAlignedStore(BlockPointer, Alloca, Align);
>>>>>>>> > BlockPointerDbgLoc = Alloca;
>>>>>>>> > }
>>>>>>>> > @@ -1326,9 +1326,9 @@ CodeGenFunction::GenerateCopyHelperFunct
>>>>>>>> > false,
>>>>>>>> > false);
>>>>>>>> > // Create a scope with an artificial location for the body of
>>>>>>>> this function.
>>>>>>>> > - ArtificialLocation AL(*this, Builder);
>>>>>>>> > + ApplyDebugLocation NL(*this);
>>>>>>>> > StartFunction(FD, C.VoidTy, Fn, FI, args);
>>>>>>>> > - AL.Emit();
>>>>>>>> > + ArtificialLocation AL(*this);
>>>>>>>> >
>>>>>>>> > llvm::Type *structPtrTy =
>>>>>>>> blockInfo.StructureType->getPointerTo();
>>>>>>>> >
>>>>>>>> > @@ -1497,9 +1497,9 @@ CodeGenFunction::GenerateDestroyHelperFu
>>>>>>>> > nullptr, SC_Static,
>>>>>>>> > false, false);
>>>>>>>> > // Create a scope with an artificial location for the body of
>>>>>>>> this function.
>>>>>>>> > - ArtificialLocation AL(*this, Builder);
>>>>>>>> > + ApplyDebugLocation NL(*this);
>>>>>>>> > StartFunction(FD, C.VoidTy, Fn, FI, args);
>>>>>>>> > - AL.Emit();
>>>>>>>> > + ArtificialLocation AL(*this);
>>>>>>>> >
>>>>>>>> > llvm::Type *structPtrTy =
>>>>>>>> blockInfo.StructureType->getPointerTo();
>>>>>>>> >
>>>>>>>> >
>>>>>>>> > Modified: cfe/trunk/lib/CodeGen/CGClass.cpp
>>>>>>>> > URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGClass.cpp?rev=225000&r1=224999&r2=225000&view=diff
>>>>>>>> >
>>>>>>>> ==============================================================================
>>>>>>>> > --- cfe/trunk/lib/CodeGen/CGClass.cpp (original)
>>>>>>>> > +++ cfe/trunk/lib/CodeGen/CGClass.cpp Tue Dec 30 13:39:33 2014
>>>>>>>> > @@ -544,6 +544,7 @@ static void EmitMemberInitializer(CodeGe
>>>>>>>> > CXXCtorInitializer *MemberInit,
>>>>>>>> > const CXXConstructorDecl
>>>>>>>> *Constructor,
>>>>>>>> > FunctionArgList &Args) {
>>>>>>>> > + ApplyDebugLocation Loc(CGF, MemberInit->getMemberLocation());
>>>>>>>> > assert(MemberInit->isAnyMemberInitializer() &&
>>>>>>>> > "Must have member initializer!");
>>>>>>>> > assert(MemberInit->getInit() && "Must have initializer!");
>>>>>>>> > @@ -597,26 +598,25 @@ static void EmitMemberInitializer(CodeGe
>>>>>>>> > ArrayRef<VarDecl *> ArrayIndexes;
>>>>>>>> > if (MemberInit->getNumArrayIndices())
>>>>>>>> > ArrayIndexes = MemberInit->getArrayIndexes();
>>>>>>>> > - CGF.EmitInitializerForField(Field, LHS, MemberInit->getInit(),
>>>>>>>> ArrayIndexes,
>>>>>>>> > - MemberInit->getMemberLocation());
>>>>>>>> > + ApplyDebugLocation DL(CGF, MemberInit->getMemberLocation());
>>>>>>>> > + CGF.EmitInitializerForField(Field, LHS, MemberInit->getInit(),
>>>>>>>> ArrayIndexes);
>>>>>>>> > }
>>>>>>>> >
>>>>>>>> > -void CodeGenFunction::EmitInitializerForField(FieldDecl *Field,
>>>>>>>> LValue LHS,
>>>>>>>> > - Expr *Init,
>>>>>>>> > - ArrayRef<VarDecl
>>>>>>>> *> ArrayIndexes,
>>>>>>>> > - SourceLocation
>>>>>>>> DbgLoc) {
>>>>>>>> > +void CodeGenFunction::EmitInitializerForField(
>>>>>>>> > + FieldDecl *Field, LValue LHS, Expr *Init,
>>>>>>>> > + ArrayRef<VarDecl *> ArrayIndexes) {
>>>>>>>> > QualType FieldType = Field->getType();
>>>>>>>> > switch (getEvaluationKind(FieldType)) {
>>>>>>>> > case TEK_Scalar:
>>>>>>>> > if (LHS.isSimple()) {
>>>>>>>> > - EmitExprAsInit(Init, Field, LHS, false, DbgLoc);
>>>>>>>> > + EmitExprAsInit(Init, Field, LHS, false);
>>>>>>>> > } else {
>>>>>>>> > RValue RHS = RValue::get(EmitScalarExpr(Init));
>>>>>>>> > EmitStoreThroughLValue(RHS, LHS);
>>>>>>>> > }
>>>>>>>> > break;
>>>>>>>> > case TEK_Complex:
>>>>>>>> > - EmitComplexExprIntoLValue(Init, LHS, /*isInit*/ true,
>>>>>>>> DbgLoc);
>>>>>>>> > + EmitComplexExprIntoLValue(Init, LHS, /*isInit*/ true);
>>>>>>>> > break;
>>>>>>>> > case TEK_Aggregate: {
>>>>>>>> > llvm::Value *ArrayIndexVar = nullptr;
>>>>>>>> > @@ -783,8 +783,6 @@ void CodeGenFunction::EmitConstructorBod
>>>>>>>> > // delegation optimization.
>>>>>>>> > if (CtorType == Ctor_Complete &&
>>>>>>>> IsConstructorDelegationValid(Ctor) &&
>>>>>>>> > CGM.getTarget().getCXXABI().hasConstructorVariants()) {
>>>>>>>> > - if (CGDebugInfo *DI = getDebugInfo())
>>>>>>>> > - DI->EmitLocation(Builder, Ctor->getLocEnd());
>>>>>>>> > EmitDelegateCXXConstructorCall(Ctor, Ctor_Base, Args,
>>>>>>>> Ctor->getLocEnd());
>>>>>>>> > return;
>>>>>>>> > }
>>>>>>>> >
>>>>>>>> > Modified: cfe/trunk/lib/CodeGen/CGCleanup.cpp
>>>>>>>> > URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGCleanup.cpp?rev=225000&r1=224999&r2=225000&view=diff
>>>>>>>> >
>>>>>>>> ==============================================================================
>>>>>>>> > --- cfe/trunk/lib/CodeGen/CGCleanup.cpp (original)
>>>>>>>> > +++ cfe/trunk/lib/CodeGen/CGCleanup.cpp Tue Dec 30 13:39:33 2014
>>>>>>>> > @@ -861,10 +861,7 @@ void CodeGenFunction::PopCleanupBlock(bo
>>>>>>>> >
>>>>>>>> > // Emit the EH cleanup if required.
>>>>>>>> > if (RequiresEHCleanup) {
>>>>>>>> > - CGDebugInfo *DI = getDebugInfo();
>>>>>>>> > - SaveAndRestoreLocation AutoRestoreLocation(*this, Builder);
>>>>>>>> > - if (DI)
>>>>>>>> > - DI->EmitLocation(Builder, CurEHLocation);
>>>>>>>> > + ApplyDebugLocation AutoRestoreLocation(*this, CurEHLocation);
>>>>>>>> >
>>>>>>>> > CGBuilderTy::InsertPoint SavedIP = Builder.saveAndClearIP();
>>>>>>>> >
>>>>>>>> >
>>>>>>>> > Modified: cfe/trunk/lib/CodeGen/CGDebugInfo.cpp
>>>>>>>> > URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGDebugInfo.cpp?rev=225000&r1=224999&r2=225000&view=diff
>>>>>>>> >
>>>>>>>> ==============================================================================
>>>>>>>> > --- cfe/trunk/lib/CodeGen/CGDebugInfo.cpp (original)
>>>>>>>> > +++ cfe/trunk/lib/CodeGen/CGDebugInfo.cpp Tue Dec 30 13:39:33 2014
>>>>>>>> > @@ -52,54 +52,38 @@ CGDebugInfo::~CGDebugInfo() {
>>>>>>>> > "Region stack mismatch, stack not empty!");
>>>>>>>> > }
>>>>>>>> >
>>>>>>>> > -SaveAndRestoreLocation::SaveAndRestoreLocation(CodeGenFunction
>>>>>>>> &CGF,
>>>>>>>> > - CGBuilderTy &B)
>>>>>>>> > - : DI(CGF.getDebugInfo()), Builder(B) {
>>>>>>>> > - if (DI) {
>>>>>>>> > - SavedLoc = DI->getLocation();
>>>>>>>> > - DI->CurLoc = SourceLocation();
>>>>>>>> > - }
>>>>>>>> > -}
>>>>>>>> > -
>>>>>>>> > -SaveAndRestoreLocation::~SaveAndRestoreLocation() {
>>>>>>>> > - if (DI)
>>>>>>>> > - DI->EmitLocation(Builder, SavedLoc);
>>>>>>>> > -}
>>>>>>>> > -
>>>>>>>> > -NoLocation::NoLocation(CodeGenFunction &CGF, CGBuilderTy &B)
>>>>>>>> > - : SaveAndRestoreLocation(CGF, B) {
>>>>>>>> > - if (DI)
>>>>>>>> > - Builder.SetCurrentDebugLocation(llvm::DebugLoc());
>>>>>>>> > -}
>>>>>>>> > -
>>>>>>>> > -NoLocation::~NoLocation() {
>>>>>>>> > - if (DI)
>>>>>>>> > - assert(Builder.getCurrentDebugLocation().isUnknown());
>>>>>>>> > -}
>>>>>>>> > -
>>>>>>>> > -ArtificialLocation::ArtificialLocation(CodeGenFunction &CGF,
>>>>>>>> CGBuilderTy &B)
>>>>>>>> > - : SaveAndRestoreLocation(CGF, B) {
>>>>>>>> > - if (DI)
>>>>>>>> > - Builder.SetCurrentDebugLocation(llvm::DebugLoc());
>>>>>>>> > -}
>>>>>>>> > -
>>>>>>>> > -void ArtificialLocation::Emit() {
>>>>>>>> > - if (DI) {
>>>>>>>> > - // Sync the Builder.
>>>>>>>> > - DI->EmitLocation(Builder, SavedLoc);
>>>>>>>> > - DI->CurLoc = SourceLocation();
>>>>>>>> > +ArtificialLocation::ArtificialLocation(CodeGenFunction &CGF)
>>>>>>>> > + : ApplyDebugLocation(CGF) {
>>>>>>>> > + if (auto *DI = CGF.getDebugInfo()) {
>>>>>>>> > // Construct a location that has a valid scope, but no line
>>>>>>>> info.
>>>>>>>> > assert(!DI->LexicalBlockStack.empty());
>>>>>>>> > llvm::DIDescriptor Scope(DI->LexicalBlockStack.back());
>>>>>>>> > - Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(0, 0,
>>>>>>>> Scope));
>>>>>>>> > + CGF.Builder.SetCurrentDebugLocation(llvm::DebugLoc::get(0,
>>>>>>>> 0, Scope));
>>>>>>>> > + }
>>>>>>>> > +}
>>>>>>>> > +
>>>>>>>> > +ApplyDebugLocation::ApplyDebugLocation(CodeGenFunction &CGF,
>>>>>>>> > + SourceLocation
>>>>>>>> TemporaryLocation,
>>>>>>>> > + bool ForceColumnInfo)
>>>>>>>> > + : CGF(CGF) {
>>>>>>>> > + if (auto *DI = CGF.getDebugInfo()) {
>>>>>>>> > + OriginalLocation = CGF.Builder.getCurrentDebugLocation();
>>>>>>>> > + if (TemporaryLocation.isInvalid())
>>>>>>>> > + CGF.Builder.SetCurrentDebugLocation(llvm::DebugLoc());
>>>>>>>> > + else
>>>>>>>> > + DI->EmitLocation(CGF.Builder, TemporaryLocation,
>>>>>>>> ForceColumnInfo);
>>>>>>>> > }
>>>>>>>> > }
>>>>>>>> >
>>>>>>>> > -ArtificialLocation::~ArtificialLocation() {
>>>>>>>> > - if (DI)
>>>>>>>> > - assert(Builder.getCurrentDebugLocation().getLine() == 0);
>>>>>>>> > +ApplyDebugLocation::~ApplyDebugLocation() {
>>>>>>>> > + // Query CGF so the location isn't overwritten when location
>>>>>>>> updates are
>>>>>>>> > + // temporarily disabled (for C++ default function arguments)
>>>>>>>> > + if (CGF.getDebugInfo())
>>>>>>>> > + CGF.Builder.SetCurrentDebugLocation(OriginalLocation);
>>>>>>>> > }
>>>>>>>> >
>>>>>>>> > +/// ArtificialLocation - An RAII object that temporarily
>>>>>>>> switches to
>>>>>>>> > +/// an artificial debug location that has a valid scope, but no
>>>>>>>> line
>>>>>>>> > void CGDebugInfo::setLocation(SourceLocation Loc) {
>>>>>>>> > // If the new location isn't valid return.
>>>>>>>> > if (Loc.isInvalid())
>>>>>>>> >
>>>>>>>> > Modified: cfe/trunk/lib/CodeGen/CGDebugInfo.h
>>>>>>>> > URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGDebugInfo.h?rev=225000&r1=224999&r2=225000&view=diff
>>>>>>>> >
>>>>>>>> ==============================================================================
>>>>>>>> > --- cfe/trunk/lib/CodeGen/CGDebugInfo.h (original)
>>>>>>>> > +++ cfe/trunk/lib/CodeGen/CGDebugInfo.h Tue Dec 30 13:39:33 2014
>>>>>>>> > @@ -448,27 +448,16 @@ private:
>>>>>>>> > }
>>>>>>>> > };
>>>>>>>> >
>>>>>>>> > -/// SaveAndRestoreLocation - An RAII object saves the current
>>>>>>>> location
>>>>>>>> > -/// and automatically restores it to the original value.
>>>>>>>> > -class SaveAndRestoreLocation {
>>>>>>>> > +class ApplyDebugLocation {
>>>>>>>> > protected:
>>>>>>>> > - SourceLocation SavedLoc;
>>>>>>>> > - CGDebugInfo *DI;
>>>>>>>> > - CGBuilderTy &Builder;
>>>>>>>> > -public:
>>>>>>>> > - SaveAndRestoreLocation(CodeGenFunction &CGF, CGBuilderTy &B);
>>>>>>>> > - /// Autorestore everything back to normal.
>>>>>>>> > - ~SaveAndRestoreLocation();
>>>>>>>> > -};
>>>>>>>> > + llvm::DebugLoc OriginalLocation;
>>>>>>>> > + CodeGenFunction &CGF;
>>>>>>>> >
>>>>>>>> > -/// NoLocation - An RAII object that temporarily disables debug
>>>>>>>> > -/// locations. This is useful for emitting instructions that
>>>>>>>> should be
>>>>>>>> > -/// counted towards the function prologue.
>>>>>>>> > -class NoLocation : public SaveAndRestoreLocation {
>>>>>>>> > public:
>>>>>>>> > - NoLocation(CodeGenFunction &CGF, CGBuilderTy &B);
>>>>>>>> > - /// Autorestore everything back to normal.
>>>>>>>> > - ~NoLocation();
>>>>>>>> > + ApplyDebugLocation(CodeGenFunction &CGF,
>>>>>>>> > + SourceLocation TemporaryLocation =
>>>>>>>> SourceLocation(),
>>>>>>>> > + bool ForceColumnInfo = false);
>>>>>>>> > + ~ApplyDebugLocation();
>>>>>>>> > };
>>>>>>>> >
>>>>>>>> > /// ArtificialLocation - An RAII object that temporarily switches
>>>>>>>> to
>>>>>>>> > @@ -482,16 +471,9 @@ public:
>>>>>>>> > /// This is necessary because passing an empty SourceLocation to
>>>>>>>> > /// CGDebugInfo::setLocation() will result in the last valid
>>>>>>>> location
>>>>>>>> > /// being reused.
>>>>>>>> > -class ArtificialLocation : public SaveAndRestoreLocation {
>>>>>>>> > +class ArtificialLocation : public ApplyDebugLocation {
>>>>>>>> > public:
>>>>>>>> > - ArtificialLocation(CodeGenFunction &CGF, CGBuilderTy &B);
>>>>>>>> > -
>>>>>>>> > - /// Set the current location to line 0, but within the current
>>>>>>>> scope
>>>>>>>> > - /// (= the top of the LexicalBlockStack).
>>>>>>>> > - void Emit();
>>>>>>>> > -
>>>>>>>> > - /// Autorestore everything back to normal.
>>>>>>>> > - ~ArtificialLocation();
>>>>>>>> > + ArtificialLocation(CodeGenFunction &CGF);
>>>>>>>> > };
>>>>>>>> >
>>>>>>>> >
>>>>>>>> >
>>>>>>>> > Modified: cfe/trunk/lib/CodeGen/CGDecl.cpp
>>>>>>>> > URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGDecl.cpp?rev=225000&r1=224999&r2=225000&view=diff
>>>>>>>> >
>>>>>>>> ==============================================================================
>>>>>>>> > --- cfe/trunk/lib/CodeGen/CGDecl.cpp (original)
>>>>>>>> > +++ cfe/trunk/lib/CodeGen/CGDecl.cpp Tue Dec 30 13:39:33 2014
>>>>>>>> > @@ -597,14 +597,13 @@ static void drillIntoBlockVariable(CodeG
>>>>>>>> > }
>>>>>>>> >
>>>>>>>> > void CodeGenFunction::EmitScalarInit(const Expr *init, const
>>>>>>>> ValueDecl *D,
>>>>>>>> > - LValue lvalue, bool
>>>>>>>> capturedByInit,
>>>>>>>> > - SourceLocation DbgLoc) {
>>>>>>>> > + LValue lvalue, bool
>>>>>>>> capturedByInit) {
>>>>>>>> > Qualifiers::ObjCLifetime lifetime = lvalue.getObjCLifetime();
>>>>>>>> > if (!lifetime) {
>>>>>>>> > llvm::Value *value = EmitScalarExpr(init);
>>>>>>>> > if (capturedByInit)
>>>>>>>> > drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
>>>>>>>> > - EmitStoreThroughLValue(RValue::get(value), lvalue, true,
>>>>>>>> DbgLoc);
>>>>>>>> > + EmitStoreThroughLValue(RValue::get(value), lvalue, true);
>>>>>>>> > return;
>>>>>>>> > }
>>>>>>>> >
>>>>>>>> > @@ -1088,6 +1087,7 @@ void CodeGenFunction::EmitAutoVarInit(co
>>>>>>>> > if (emission.wasEmittedAsGlobal()) return;
>>>>>>>> >
>>>>>>>> > const VarDecl &D = *emission.Variable;
>>>>>>>> > + ApplyDebugLocation DL(*this, D.getLocation());
>>>>>>>> > QualType type = D.getType();
>>>>>>>> >
>>>>>>>> > // If this local has an initializer, emit it now.
>>>>>>>> > @@ -1126,7 +1126,7 @@ void CodeGenFunction::EmitAutoVarInit(co
>>>>>>>> > if (!constant) {
>>>>>>>> > LValue lv = MakeAddrLValue(Loc, type, alignment);
>>>>>>>> > lv.setNonGC(true);
>>>>>>>> > - return EmitExprAsInit(Init, &D, lv, capturedByInit,
>>>>>>>> D.getLocation());
>>>>>>>> > + return EmitExprAsInit(Init, &D, lv, capturedByInit);
>>>>>>>> > }
>>>>>>>> >
>>>>>>>> > if (!emission.IsConstantAggregate) {
>>>>>>>> > @@ -1192,26 +1192,25 @@ void CodeGenFunction::EmitAutoVarInit(co
>>>>>>>> > /// \param capturedByInit true if the variable is a __block
>>>>>>>> variable
>>>>>>>> > /// whose address is potentially changed by the initializer
>>>>>>>> > void CodeGenFunction::EmitExprAsInit(const Expr *init, const
>>>>>>>> ValueDecl *D,
>>>>>>>> > - LValue lvalue, bool
>>>>>>>> capturedByInit,
>>>>>>>> > - SourceLocation DbgLoc) {
>>>>>>>> > + LValue lvalue, bool
>>>>>>>> capturedByInit) {
>>>>>>>> > QualType type = D->getType();
>>>>>>>> >
>>>>>>>> > if (type->isReferenceType()) {
>>>>>>>> > RValue rvalue = EmitReferenceBindingToExpr(init);
>>>>>>>> > if (capturedByInit)
>>>>>>>> > drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
>>>>>>>> > - EmitStoreThroughLValue(rvalue, lvalue, true, DbgLoc);
>>>>>>>> > + EmitStoreThroughLValue(rvalue, lvalue, true);
>>>>>>>> > return;
>>>>>>>> > }
>>>>>>>> > switch (getEvaluationKind(type)) {
>>>>>>>> > case TEK_Scalar:
>>>>>>>> > - EmitScalarInit(init, D, lvalue, capturedByInit, DbgLoc);
>>>>>>>> > + EmitScalarInit(init, D, lvalue, capturedByInit);
>>>>>>>> > return;
>>>>>>>> > case TEK_Complex: {
>>>>>>>> > ComplexPairTy complex = EmitComplexExpr(init);
>>>>>>>> > if (capturedByInit)
>>>>>>>> > drillIntoBlockVariable(*this, lvalue, cast<VarDecl>(D));
>>>>>>>> > - EmitStoreOfComplex(complex, lvalue, /*init*/ true, DbgLoc);
>>>>>>>> > + EmitStoreOfComplex(complex, lvalue, /*init*/ true);
>>>>>>>> > return;
>>>>>>>> > }
>>>>>>>> > case TEK_Aggregate:
>>>>>>>> >
>>>>>>>> > Modified: cfe/trunk/lib/CodeGen/CGDeclCXX.cpp
>>>>>>>> > URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGDeclCXX.cpp?rev=225000&r1=224999&r2=225000&view=diff
>>>>>>>> >
>>>>>>>> ==============================================================================
>>>>>>>> > --- cfe/trunk/lib/CodeGen/CGDeclCXX.cpp (original)
>>>>>>>> > +++ cfe/trunk/lib/CodeGen/CGDeclCXX.cpp Tue Dec 30 13:39:33 2014
>>>>>>>> > @@ -474,11 +474,11 @@ CodeGenFunction::GenerateCXXGlobalInitFu
>>>>>>>> >
>>>>>>>> ArrayRef<llvm::Function *> Decls,
>>>>>>>> > llvm::GlobalVariable
>>>>>>>> *Guard) {
>>>>>>>> > {
>>>>>>>> > - ArtificialLocation AL(*this, Builder);
>>>>>>>> > + ApplyDebugLocation NL(*this);
>>>>>>>> > StartFunction(GlobalDecl(), getContext().VoidTy, Fn,
>>>>>>>> > getTypes().arrangeNullaryFunction(),
>>>>>>>> FunctionArgList());
>>>>>>>> > // Emit an artificial location for this function.
>>>>>>>> > - AL.Emit();
>>>>>>>> > + ArtificialLocation AL(*this);
>>>>>>>> >
>>>>>>>> > llvm::BasicBlock *ExitBlock = nullptr;
>>>>>>>> > if (Guard) {
>>>>>>>> > @@ -525,11 +525,11 @@ void CodeGenFunction::GenerateCXXGlobalD
>>>>>>>> > const std::vector<std::pair<llvm::WeakVH,
>>>>>>>> llvm::Constant*> >
>>>>>>>> > &DtorsAndObjects)
>>>>>>>> {
>>>>>>>> > {
>>>>>>>> > - ArtificialLocation AL(*this, Builder);
>>>>>>>> > + ApplyDebugLocation NL(*this);
>>>>>>>> > StartFunction(GlobalDecl(), getContext().VoidTy, Fn,
>>>>>>>> > getTypes().arrangeNullaryFunction(),
>>>>>>>> FunctionArgList());
>>>>>>>> > // Emit an artificial location for this function.
>>>>>>>> > - AL.Emit();
>>>>>>>> > + ArtificialLocation AL(*this);
>>>>>>>> >
>>>>>>>> > // Emit the dtors, in reverse order from construction.
>>>>>>>> > for (unsigned i = 0, e = DtorsAndObjects.size(); i != e; ++i)
>>>>>>>> {
>>>>>>>> >
>>>>>>>> > Modified: cfe/trunk/lib/CodeGen/CGException.cpp
>>>>>>>> > URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGException.cpp?rev=225000&r1=224999&r2=225000&view=diff
>>>>>>>> >
>>>>>>>> ==============================================================================
>>>>>>>> > --- cfe/trunk/lib/CodeGen/CGException.cpp (original)
>>>>>>>> > +++ cfe/trunk/lib/CodeGen/CGException.cpp Tue Dec 30 13:39:33 2014
>>>>>>>> > @@ -734,9 +734,7 @@ llvm::BasicBlock *CodeGenFunction::EmitL
>>>>>>>> >
>>>>>>>> > // Save the current IR generation state.
>>>>>>>> > CGBuilderTy::InsertPoint savedIP = Builder.saveAndClearIP();
>>>>>>>> > - SaveAndRestoreLocation AutoRestoreLocation(*this, Builder);
>>>>>>>> > - if (CGDebugInfo *DI = getDebugInfo())
>>>>>>>> > - DI->EmitLocation(Builder, CurEHLocation);
>>>>>>>> > + ApplyDebugLocation AutoRestoreLocation(*this, CurEHLocation);
>>>>>>>> >
>>>>>>>> > const EHPersonality &personality = EHPersonality::get(CGM);
>>>>>>>> >
>>>>>>>> >
>>>>>>>> > Modified: cfe/trunk/lib/CodeGen/CGExpr.cpp
>>>>>>>> > URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGExpr.cpp?rev=225000&r1=224999&r2=225000&view=diff
>>>>>>>> >
>>>>>>>> ==============================================================================
>>>>>>>> > --- cfe/trunk/lib/CodeGen/CGExpr.cpp (original)
>>>>>>>> > +++ cfe/trunk/lib/CodeGen/CGExpr.cpp Tue Dec 30 13:39:33 2014
>>>>>>>> > @@ -1438,11 +1438,7 @@ RValue CodeGenFunction::EmitLoadOfGlobal
>>>>>>>> > /// lvalue, where both are guaranteed to the have the same type,
>>>>>>>> and that type
>>>>>>>> > /// is 'Ty'.
>>>>>>>> > void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue
>>>>>>>> Dst,
>>>>>>>> > - bool isInit,
>>>>>>>> > - SourceLocation
>>>>>>>> DbgLoc) {
>>>>>>>> > - if (auto *DI = getDebugInfo())
>>>>>>>> > - DI->EmitLocation(Builder, DbgLoc);
>>>>>>>> > -
>>>>>>>> > + bool isInit) {
>>>>>>>> > if (!Dst.isSimple()) {
>>>>>>>> > if (Dst.isVectorElt()) {
>>>>>>>> > // Read/modify/write the vector, inserting the new element.
>>>>>>>> > @@ -2408,9 +2404,6 @@ LValue CodeGenFunction::EmitArraySubscri
>>>>>>>> > // The element count here is the total number of non-VLA
>>>>>>>> elements.
>>>>>>>> > llvm::Value *numElements = getVLASize(vla).first;
>>>>>>>> >
>>>>>>>> > - if (auto *DI = getDebugInfo())
>>>>>>>> > - DI->EmitLocation(Builder, E->getLocStart());
>>>>>>>> > -
>>>>>>>> > // Effectively, the multiply by the VLA size is part of the
>>>>>>>> GEP.
>>>>>>>> > // GEP indexes are signed, and scaling an index isn't
>>>>>>>> permitted to
>>>>>>>> > // signed-overflow, so we use the same semantics for our
>>>>>>>> explicit
>>>>>>>> > @@ -2456,9 +2449,6 @@ LValue CodeGenFunction::EmitArraySubscri
>>>>>>>> > // Propagate the alignment from the array itself to the
>>>>>>>> result.
>>>>>>>> > ArrayAlignment = ArrayLV.getAlignment();
>>>>>>>> >
>>>>>>>> > - if (auto *DI = getDebugInfo())
>>>>>>>> > - DI->EmitLocation(Builder, E->getLocStart());
>>>>>>>> > -
>>>>>>>> > if (getLangOpts().isSignedOverflowDefined())
>>>>>>>> > Address = Builder.CreateGEP(ArrayPtr, Args, "arrayidx");
>>>>>>>> > else
>>>>>>>> > @@ -2466,8 +2456,6 @@ LValue CodeGenFunction::EmitArraySubscri
>>>>>>>> > } else {
>>>>>>>> > // The base must be a pointer, which is not an aggregate.
>>>>>>>> Emit it.
>>>>>>>> > llvm::Value *Base = EmitScalarExpr(E->getBase());
>>>>>>>> > - if (auto *DI = getDebugInfo())
>>>>>>>> > - DI->EmitLocation(Builder, E->getLocStart());
>>>>>>>> > if (getLangOpts().isSignedOverflowDefined())
>>>>>>>> > Address = Builder.CreateGEP(Base, Idx, "arrayidx");
>>>>>>>> > else
>>>>>>>> > @@ -3024,18 +3012,15 @@ RValue CodeGenFunction::EmitRValueForFie
>>>>>>>> >
>>>>>>>> > RValue CodeGenFunction::EmitCallExpr(const CallExpr *E,
>>>>>>>> > ReturnValueSlot ReturnValue)
>>>>>>>> {
>>>>>>>> > - if (CGDebugInfo *DI = getDebugInfo()) {
>>>>>>>> > - SourceLocation Loc = E->getLocStart();
>>>>>>>> > - // Force column info to be generated so we can differentiate
>>>>>>>> > - // multiple call sites on the same line in the debug info.
>>>>>>>> > - // FIXME: This is insufficient. Two calls coming from the
>>>>>>>> same macro
>>>>>>>> > - // expansion will still get the same line/column and break
>>>>>>>> debug info. It's
>>>>>>>> > - // possible that LLVM can be fixed to not rely on this
>>>>>>>> uniqueness, at which
>>>>>>>> > - // point this workaround can be removed.
>>>>>>>> > - const FunctionDecl* Callee = E->getDirectCallee();
>>>>>>>> > - bool ForceColumnInfo = Callee && Callee->isInlineSpecified();
>>>>>>>> > - DI->EmitLocation(Builder, Loc, ForceColumnInfo);
>>>>>>>> > - }
>>>>>>>> > + // Force column info to be generated so we can differentiate
>>>>>>>> > + // multiple call sites on the same line in the debug info.
>>>>>>>> > + // FIXME: This is insufficient. Two calls coming from the same
>>>>>>>> macro
>>>>>>>> > + // expansion will still get the same line/column and break
>>>>>>>> debug info. It's
>>>>>>>> > + // possible that LLVM can be fixed to not rely on this
>>>>>>>> uniqueness, at which
>>>>>>>> > + // point this workaround can be removed.
>>>>>>>> > + ApplyDebugLocation DL(*this, E->getLocStart(),
>>>>>>>> > + E->getDirectCallee() &&
>>>>>>>> > +
>>>>>>>> E->getDirectCallee()->isInlineSpecified());
>>>>>>>> >
>>>>>>>> > // Builtins never have block type.
>>>>>>>> > if (E->getCallee()->getType()->isBlockPointerType())
>>>>>>>> > @@ -3151,8 +3136,6 @@ LValue CodeGenFunction::EmitBinaryOperat
>>>>>>>> >
>>>>>>>> > RValue RV = EmitAnyExpr(E->getRHS());
>>>>>>>> > LValue LV = EmitCheckedLValue(E->getLHS(), TCK_Store);
>>>>>>>> > - if (CGDebugInfo *DI = getDebugInfo())
>>>>>>>> > - DI->EmitLocation(Builder, E->getLocStart());
>>>>>>>> > EmitStoreThroughLValue(RV, LV);
>>>>>>>> > return LV;
>>>>>>>> > }
>>>>>>>> >
>>>>>>>> > Modified: cfe/trunk/lib/CodeGen/CGExprCXX.cpp
>>>>>>>> > URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGExprCXX.cpp?rev=225000&r1=224999&r2=225000&view=diff
>>>>>>>> >
>>>>>>>> ==============================================================================
>>>>>>>> > --- cfe/trunk/lib/CodeGen/CGExprCXX.cpp (original)
>>>>>>>> > +++ cfe/trunk/lib/CodeGen/CGExprCXX.cpp Tue Dec 30 13:39:33 2014
>>>>>>>> > @@ -187,8 +187,6 @@ RValue CodeGenFunction::EmitCXXMemberOrO
>>>>>>>> > unsigned ArgsToSkip = isa<CXXOperatorCallExpr>(CE) ? 1 :
>>>>>>>> 0;
>>>>>>>> > llvm::Value *RHS =
>>>>>>>> > EmitLValue(*(CE->arg_begin() +
>>>>>>>> ArgsToSkip)).getAddress();
>>>>>>>> > - if (auto *DI = getDebugInfo())
>>>>>>>> > - DI->EmitLocation(Builder, CE->getLocStart());
>>>>>>>> > EmitAggregateAssign(This, RHS, CE->getType());
>>>>>>>> > return RValue::get(This);
>>>>>>>> > }
>>>>>>>> > @@ -754,15 +752,13 @@ static llvm::Value *EmitCXXNewAllocSize(
>>>>>>>> > }
>>>>>>>> >
>>>>>>>> > static void StoreAnyExprIntoOneUnit(CodeGenFunction &CGF, const
>>>>>>>> Expr *Init,
>>>>>>>> > - QualType AllocType,
>>>>>>>> llvm::Value *NewPtr,
>>>>>>>> > - SourceLocation DbgLoc =
>>>>>>>> SourceLocation()) {
>>>>>>>> > + QualType AllocType,
>>>>>>>> llvm::Value *NewPtr) {
>>>>>>>> > // FIXME: Refactor with EmitExprAsInit.
>>>>>>>> > CharUnits Alignment =
>>>>>>>> CGF.getContext().getTypeAlignInChars(AllocType);
>>>>>>>> > switch (CGF.getEvaluationKind(AllocType)) {
>>>>>>>> > case TEK_Scalar:
>>>>>>>> > CGF.EmitScalarInit(Init, nullptr,
>>>>>>>> > - CGF.MakeAddrLValue(NewPtr, AllocType,
>>>>>>>> Alignment), false,
>>>>>>>> > - DbgLoc);
>>>>>>>> > + CGF.MakeAddrLValue(NewPtr, AllocType,
>>>>>>>> Alignment), false);
>>>>>>>> > return;
>>>>>>>> > case TEK_Complex:
>>>>>>>> > CGF.EmitComplexExprIntoLValue(Init,
>>>>>>>> CGF.MakeAddrLValue(NewPtr, AllocType,
>>>>>>>> > @@ -1020,12 +1016,12 @@ static void EmitNewInitializer(CodeGenFu
>>>>>>>> > llvm::Value *NewPtr,
>>>>>>>> > llvm::Value *NumElements,
>>>>>>>> > llvm::Value
>>>>>>>> *AllocSizeWithoutCookie) {
>>>>>>>> > + ApplyDebugLocation DL(CGF, E->getStartLoc());
>>>>>>>> > if (E->isArray())
>>>>>>>> > CGF.EmitNewArrayInitializer(E, ElementType, NewPtr,
>>>>>>>> NumElements,
>>>>>>>> > AllocSizeWithoutCookie);
>>>>>>>> > else if (const Expr *Init = E->getInitializer())
>>>>>>>> > - StoreAnyExprIntoOneUnit(CGF, Init, E->getAllocatedType(),
>>>>>>>> NewPtr,
>>>>>>>> > - E->getStartLoc());
>>>>>>>> > + StoreAnyExprIntoOneUnit(CGF, Init, E->getAllocatedType(),
>>>>>>>> NewPtr);
>>>>>>>> > }
>>>>>>>> >
>>>>>>>> > /// Emit a call to an operator new or operator delete function,
>>>>>>>> as implicitly
>>>>>>>> > @@ -1269,9 +1265,6 @@ llvm::Value *CodeGenFunction::EmitCXXNew
>>>>>>>> > E->placement_arg_end(), /* CalleeDecl */ nullptr,
>>>>>>>> > /*ParamsToSkip*/ 1);
>>>>>>>> >
>>>>>>>> > - if (auto *DI = getDebugInfo())
>>>>>>>> > - DI->EmitLocation(Builder, E->getLocStart());
>>>>>>>> > -
>>>>>>>> > // Emit the allocation call. If the allocator is a global
>>>>>>>> placement
>>>>>>>> > // operator, just "inline" it directly.
>>>>>>>> > RValue RV;
>>>>>>>> >
>>>>>>>> > Modified: cfe/trunk/lib/CodeGen/CGExprComplex.cpp
>>>>>>>> > URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGExprComplex.cpp?rev=225000&r1=224999&r2=225000&view=diff
>>>>>>>> >
>>>>>>>> ==============================================================================
>>>>>>>> > --- cfe/trunk/lib/CodeGen/CGExprComplex.cpp (original)
>>>>>>>> > +++ cfe/trunk/lib/CodeGen/CGExprComplex.cpp Tue Dec 30 13:39:33
>>>>>>>> 2014
>>>>>>>> > @@ -81,8 +81,7 @@ public:
>>>>>>>> >
>>>>>>>> > /// EmitStoreOfComplex - Store the specified real/imag parts
>>>>>>>> into the
>>>>>>>> > /// specified value pointer.
>>>>>>>> > - void EmitStoreOfComplex(ComplexPairTy Val, LValue LV, bool
>>>>>>>> isInit,
>>>>>>>> > - SourceLocation DbgLoc);
>>>>>>>> > + void EmitStoreOfComplex(ComplexPairTy Val, LValue LV, bool
>>>>>>>> isInit);
>>>>>>>> >
>>>>>>>> > /// EmitComplexToComplexCast - Emit a cast from complex value
>>>>>>>> Val to DestType.
>>>>>>>> > ComplexPairTy EmitComplexToComplexCast(ComplexPairTy Val,
>>>>>>>> QualType SrcType,
>>>>>>>> > @@ -335,11 +334,7 @@ ComplexPairTy ComplexExprEmitter::EmitLo
>>>>>>>> > /// EmitStoreOfComplex - Store the specified real/imag parts into
>>>>>>>> the
>>>>>>>> > /// specified value pointer.
>>>>>>>> > void ComplexExprEmitter::EmitStoreOfComplex(ComplexPairTy Val,
>>>>>>>> LValue lvalue,
>>>>>>>> > - bool isInit,
>>>>>>>> > - SourceLocation
>>>>>>>> DbgLoc) {
>>>>>>>> > - if (auto *DI = CGF.getDebugInfo())
>>>>>>>> > - DI->EmitLocation(CGF.Builder, DbgLoc);
>>>>>>>> > -
>>>>>>>> > + bool isInit) {
>>>>>>>> > if (lvalue.getType()->isAtomicType())
>>>>>>>> > return CGF.EmitAtomicStore(RValue::getComplex(Val), lvalue,
>>>>>>>> isInit);
>>>>>>>> >
>>>>>>>> > @@ -869,7 +864,7 @@ EmitCompoundAssignLValue(const CompoundA
>>>>>>>> > // Truncate the result and store it into the LHS lvalue.
>>>>>>>> > if (LHSTy->isAnyComplexType()) {
>>>>>>>> > ComplexPairTy ResVal = EmitComplexToComplexCast(Result,
>>>>>>>> OpInfo.Ty, LHSTy);
>>>>>>>> > - EmitStoreOfComplex(ResVal, LHS, /*isInit*/ false,
>>>>>>>> E->getLocStart());
>>>>>>>> > + EmitStoreOfComplex(ResVal, LHS, /*isInit*/ false);
>>>>>>>> > Val = RValue::getComplex(ResVal);
>>>>>>>> > } else {
>>>>>>>> > llvm::Value *ResVal =
>>>>>>>> > @@ -914,7 +909,7 @@ LValue ComplexExprEmitter::EmitBinAssign
>>>>>>>> > LValue LHS = CGF.EmitLValue(E->getLHS());
>>>>>>>> >
>>>>>>>> > // Store the result value into the LHS lvalue.
>>>>>>>> > - EmitStoreOfComplex(Val, LHS, /*isInit*/ false,
>>>>>>>> E->getLocStart());
>>>>>>>> > + EmitStoreOfComplex(Val, LHS, /*isInit*/ false);
>>>>>>>> >
>>>>>>>> > return LHS;
>>>>>>>> > }
>>>>>>>> > @@ -1042,19 +1037,18 @@ ComplexPairTy CodeGenFunction::EmitCompl
>>>>>>>> > }
>>>>>>>> >
>>>>>>>> > void CodeGenFunction::EmitComplexExprIntoLValue(const Expr *E,
>>>>>>>> LValue dest,
>>>>>>>> > - bool isInit,
>>>>>>>> > - SourceLocation
>>>>>>>> DbgLoc) {
>>>>>>>> > + bool isInit) {
>>>>>>>> > assert(E && getComplexType(E->getType()) &&
>>>>>>>> > "Invalid complex expression to emit");
>>>>>>>> > ComplexExprEmitter Emitter(*this);
>>>>>>>> > ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E));
>>>>>>>> > - Emitter.EmitStoreOfComplex(Val, dest, isInit, DbgLoc);
>>>>>>>> > + Emitter.EmitStoreOfComplex(Val, dest, isInit);
>>>>>>>> > }
>>>>>>>> >
>>>>>>>> > /// EmitStoreOfComplex - Store a complex number into the
>>>>>>>> specified l-value.
>>>>>>>> > void CodeGenFunction::EmitStoreOfComplex(ComplexPairTy V, LValue
>>>>>>>> dest,
>>>>>>>> > - bool isInit,
>>>>>>>> SourceLocation DbgLoc) {
>>>>>>>> > - ComplexExprEmitter(*this).EmitStoreOfComplex(V, dest, isInit,
>>>>>>>> DbgLoc);
>>>>>>>> > + bool isInit) {
>>>>>>>> > + ComplexExprEmitter(*this).EmitStoreOfComplex(V, dest, isInit);
>>>>>>>> > }
>>>>>>>> >
>>>>>>>> > /// EmitLoadOfComplex - Load a complex number from the specified
>>>>>>>> address.
>>>>>>>> >
>>>>>>>> > Modified: cfe/trunk/lib/CodeGen/CGExprScalar.cpp
>>>>>>>> > URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGExprScalar.cpp?rev=225000&r1=224999&r2=225000&view=diff
>>>>>>>> >
>>>>>>>> ==============================================================================
>>>>>>>> > --- cfe/trunk/lib/CodeGen/CGExprScalar.cpp (original)
>>>>>>>> > +++ cfe/trunk/lib/CodeGen/CGExprScalar.cpp Tue Dec 30 13:39:33
>>>>>>>> 2014
>>>>>>>> > @@ -196,6 +196,7 @@ public:
>>>>>>>> >
>>>>>>>> //===--------------------------------------------------------------------===//
>>>>>>>> >
>>>>>>>> > Value *Visit(Expr *E) {
>>>>>>>> > + ApplyDebugLocation DL(CGF, E->getLocStart());
>>>>>>>> > return StmtVisitor<ScalarExprEmitter, Value*>::Visit(E);
>>>>>>>> > }
>>>>>>>> >
>>>>>>>> > @@ -3042,7 +3043,7 @@ Value *ScalarExprEmitter::VisitBinLAnd(c
>>>>>>>> > // Emit an unconditional branch from this block to ContBlock.
>>>>>>>> > {
>>>>>>>> > // There is no need to emit line number for unconditional
>>>>>>>> branch.
>>>>>>>> > - SuppressDebugLocation S(Builder);
>>>>>>>> > + ApplyDebugLocation DL(CGF);
>>>>>>>> > CGF.EmitBlock(ContBlock);
>>>>>>>> > }
>>>>>>>> > // Insert an entry into the phi node for the edge with the
>>>>>>>> value of RHSCond.
>>>>>>>> >
>>>>>>>> > Modified: cfe/trunk/lib/CodeGen/CGStmt.cpp
>>>>>>>> > URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGStmt.cpp?rev=225000&r1=224999&r2=225000&view=diff
>>>>>>>> >
>>>>>>>> ==============================================================================
>>>>>>>> > --- cfe/trunk/lib/CodeGen/CGStmt.cpp (original)
>>>>>>>> > +++ cfe/trunk/lib/CodeGen/CGStmt.cpp Tue Dec 30 13:39:33 2014
>>>>>>>> > @@ -565,7 +565,7 @@ void CodeGenFunction::EmitIfStmt(const I
>>>>>>>> > if (const Stmt *Else = S.getElse()) {
>>>>>>>> > {
>>>>>>>> > // There is no need to emit line number for unconditional
>>>>>>>> branch.
>>>>>>>> > - SuppressDebugLocation S(Builder);
>>>>>>>> > + ApplyDebugLocation DL(*this);
>>>>>>>> > EmitBlock(ElseBlock);
>>>>>>>> > }
>>>>>>>> > {
>>>>>>>> > @@ -574,7 +574,7 @@ void CodeGenFunction::EmitIfStmt(const I
>>>>>>>> > }
>>>>>>>> > {
>>>>>>>> > // There is no need to emit line number for unconditional
>>>>>>>> branch.
>>>>>>>> > - SuppressDebugLocation S(Builder);
>>>>>>>> > + ApplyDebugLocation DL(*this);
>>>>>>>> > EmitBranch(ContBlock);
>>>>>>>> > }
>>>>>>>> > }
>>>>>>>> >
>>>>>>>> > Modified: cfe/trunk/lib/CodeGen/CGStmtOpenMP.cpp
>>>>>>>> > URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CGStmtOpenMP.cpp?rev=225000&r1=224999&r2=225000&view=diff
>>>>>>>> >
>>>>>>>> ==============================================================================
>>>>>>>> > --- cfe/trunk/lib/CodeGen/CGStmtOpenMP.cpp (original)
>>>>>>>> > +++ cfe/trunk/lib/CodeGen/CGStmtOpenMP.cpp Tue Dec 30 13:39:33
>>>>>>>> 2014
>>>>>>>> > @@ -86,13 +86,13 @@ static void EmitOMPIfClause(CodeGenFunct
>>>>>>>> > // Emit the 'else' code if present.
>>>>>>>> > {
>>>>>>>> > // There is no need to emit line number for unconditional
>>>>>>>> branch.
>>>>>>>> > - SuppressDebugLocation SDL(CGF.Builder);
>>>>>>>> > + ApplyDebugLocation DL(CGF);
>>>>>>>> > CGF.EmitBlock(ElseBlock);
>>>>>>>> > }
>>>>>>>> > CodeGen(/*ThenBlock*/ false);
>>>>>>>> > {
>>>>>>>> > // There is no need to emit line number for unconditional
>>>>>>>> branch.
>>>>>>>> > - SuppressDebugLocation SDL(CGF.Builder);
>>>>>>>> > + ApplyDebugLocation DL(CGF);
>>>>>>>> > CGF.EmitBranch(ContBlock);
>>>>>>>> > }
>>>>>>>> > // Emit the continuation block for code after the if.
>>>>>>>> >
>>>>>>>> > Modified: cfe/trunk/lib/CodeGen/CodeGenFunction.h
>>>>>>>> > URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/lib/CodeGen/CodeGenFunction.h?rev=225000&r1=224999&r2=225000&view=diff
>>>>>>>> >
>>>>>>>> ==============================================================================
>>>>>>>> > --- cfe/trunk/lib/CodeGen/CodeGenFunction.h (original)
>>>>>>>> > +++ cfe/trunk/lib/CodeGen/CodeGenFunction.h Tue Dec 30 13:39:33
>>>>>>>> 2014
>>>>>>>> > @@ -93,19 +93,6 @@ enum TypeEvaluationKind {
>>>>>>>> > TEK_Aggregate
>>>>>>>> > };
>>>>>>>> >
>>>>>>>> > -class SuppressDebugLocation {
>>>>>>>> > - llvm::DebugLoc CurLoc;
>>>>>>>> > - llvm::IRBuilderBase &Builder;
>>>>>>>> > -public:
>>>>>>>> > - SuppressDebugLocation(llvm::IRBuilderBase &Builder)
>>>>>>>> > - : CurLoc(Builder.getCurrentDebugLocation()),
>>>>>>>> Builder(Builder) {
>>>>>>>> > - Builder.SetCurrentDebugLocation(llvm::DebugLoc());
>>>>>>>> > - }
>>>>>>>> > - ~SuppressDebugLocation() {
>>>>>>>> > - Builder.SetCurrentDebugLocation(CurLoc);
>>>>>>>> > - }
>>>>>>>> > -};
>>>>>>>> > -
>>>>>>>> > /// CodeGenFunction - This class organizes the per-function state
>>>>>>>> that is used
>>>>>>>> > /// while generating LLVM code.
>>>>>>>> > class CodeGenFunction : public CodeGenTypeCache {
>>>>>>>> > @@ -1300,8 +1287,7 @@ public:
>>>>>>>> > FunctionArgList &Args);
>>>>>>>> >
>>>>>>>> > void EmitInitializerForField(FieldDecl *Field, LValue LHS, Expr
>>>>>>>> *Init,
>>>>>>>> > - ArrayRef<VarDecl *> ArrayIndexes,
>>>>>>>> > - SourceLocation DbgLoc =
>>>>>>>> SourceLocation());
>>>>>>>> > + ArrayRef<VarDecl *> ArrayIndexes);
>>>>>>>> >
>>>>>>>> > /// InitializeVTablePointer - Initialize the vtable pointer of
>>>>>>>> the given
>>>>>>>> > /// subobject.
>>>>>>>> > @@ -1546,7 +1532,7 @@ public:
>>>>>>>> > /// EmitExprAsInit - Emits the code necessary to initialize a
>>>>>>>> > /// location in memory with the given initializer.
>>>>>>>> > void EmitExprAsInit(const Expr *init, const ValueDecl *D,
>>>>>>>> LValue lvalue,
>>>>>>>> > - bool capturedByInit, SourceLocation
>>>>>>>> DbgLoc);
>>>>>>>> > + bool capturedByInit);
>>>>>>>> >
>>>>>>>> > /// hasVolatileMember - returns true if aggregate type has a
>>>>>>>> volatile
>>>>>>>> > /// member.
>>>>>>>> > @@ -1833,8 +1819,7 @@ public:
>>>>>>>> > void EmitVarDecl(const VarDecl &D);
>>>>>>>> >
>>>>>>>> > void EmitScalarInit(const Expr *init, const ValueDecl *D,
>>>>>>>> LValue lvalue,
>>>>>>>> > - bool capturedByInit,
>>>>>>>> > - SourceLocation DbgLoc = SourceLocation());
>>>>>>>> > + bool capturedByInit);
>>>>>>>> > void EmitScalarInit(llvm::Value *init, LValue lvalue);
>>>>>>>> >
>>>>>>>> > typedef void SpecialInitFn(CodeGenFunction &Init, const VarDecl
>>>>>>>> &D,
>>>>>>>> > @@ -2164,8 +2149,7 @@ public:
>>>>>>>> > /// EmitStoreThroughLValue - Store the specified rvalue into
>>>>>>>> the specified
>>>>>>>> > /// lvalue, where both are guaranteed to the have the same
>>>>>>>> type, and that type
>>>>>>>> > /// is 'Ty'.
>>>>>>>> > - void EmitStoreThroughLValue(RValue Src, LValue Dst, bool
>>>>>>>> isInit = false,
>>>>>>>> > - SourceLocation DbgLoc =
>>>>>>>> SourceLocation());
>>>>>>>> > + void EmitStoreThroughLValue(RValue Src, LValue Dst, bool
>>>>>>>> isInit = false);
>>>>>>>> > void EmitStoreThroughExtVectorComponentLValue(RValue Src,
>>>>>>>> LValue Dst);
>>>>>>>> > void EmitStoreThroughGlobalRegLValue(RValue Src, LValue Dst);
>>>>>>>> >
>>>>>>>> > @@ -2537,12 +2521,10 @@ public:
>>>>>>>> >
>>>>>>>> > /// EmitComplexExprIntoLValue - Emit the given expression of
>>>>>>>> complex
>>>>>>>> > /// type and place its result into the specified l-value.
>>>>>>>> > - void EmitComplexExprIntoLValue(const Expr *E, LValue dest,
>>>>>>>> bool isInit,
>>>>>>>> > - SourceLocation DbgLoc =
>>>>>>>> SourceLocation());
>>>>>>>> > + void EmitComplexExprIntoLValue(const Expr *E, LValue dest,
>>>>>>>> bool isInit);
>>>>>>>> >
>>>>>>>> > /// EmitStoreOfComplex - Store a complex number into the
>>>>>>>> specified l-value.
>>>>>>>> > - void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool
>>>>>>>> isInit,
>>>>>>>> > - SourceLocation DbgLoc =
>>>>>>>> SourceLocation());
>>>>>>>> > + void EmitStoreOfComplex(ComplexPairTy V, LValue dest, bool
>>>>>>>> isInit);
>>>>>>>> >
>>>>>>>> > /// EmitLoadOfComplex - Load a complex number from the
>>>>>>>> specified l-value.
>>>>>>>> > ComplexPairTy EmitLoadOfComplex(LValue src, SourceLocation loc);
>>>>>>>> >
>>>>>>>> > Modified: cfe/trunk/test/CodeGenCXX/PR20038.cpp
>>>>>>>> > URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGenCXX/PR20038.cpp?rev=225000&r1=224999&r2=225000&view=diff
>>>>>>>> >
>>>>>>>> ==============================================================================
>>>>>>>> > --- cfe/trunk/test/CodeGenCXX/PR20038.cpp (original)
>>>>>>>> > +++ cfe/trunk/test/CodeGenCXX/PR20038.cpp Tue Dec 30 13:39:33 2014
>>>>>>>> > @@ -1,4 +1,4 @@
>>>>>>>> > -// RUN: %clang_cc1 -triple %itanium_abi_triple -g -emit-llvm %s
>>>>>>>> -o - | FileCheck %s
>>>>>>>> > +// RUN: %clang_cc1 -triple %itanium_abi_triple -g -mllvm
>>>>>>>> -no-discriminators -emit-llvm %s -o - | FileCheck %s
>>>>>>>> >
>>>>>>>> > struct C {
>>>>>>>> > ~C();
>>>>>>>> > @@ -8,9 +8,7 @@ extern bool b;
>>>>>>>> > // CHECK: call {{.*}}, !dbg [[DTOR_CALL2_LOC:![0-9]*]]
>>>>>>>> > // CHECK: [[FUN1:.*]] = {{.*}}; [ DW_TAG_subprogram ] {{.*}}
>>>>>>>> [def] [fun1]
>>>>>>>> > // CHECK: [[FUN2:.*]] = {{.*}}; [ DW_TAG_subprogram ] {{.*}}
>>>>>>>> [def] [fun2]
>>>>>>>> > -// CHECK: [[DTOR_CALL1_LOC]] = !{i32 [[@LINE+2]], i32 0,
>>>>>>>> [[FUN1_BLOCK:.*]], null}
>>>>>>>> > -// CHECK: [[FUN1_BLOCK]] = !{!"0xb{{[^,]*}}", {{[^,]*}},
>>>>>>>> [[FUN1]]}
>>>>>>>> > +// CHECK: [[DTOR_CALL1_LOC]] = !{i32 [[@LINE+1]], i32 0,
>>>>>>>> [[FUN1]], null}
>>>>>>>> > void fun1() { b && (C(), 1); }
>>>>>>>> > -// CHECK: [[DTOR_CALL2_LOC]] = !{i32 [[@LINE+2]], i32 0,
>>>>>>>> [[FUN2_BLOCK1:.*]], null}
>>>>>>>> > -// CHECK: [[FUN2_BLOCK1]] = !{!"0xb{{[^,]*}}", {{[^,]*}},
>>>>>>>> [[FUN2]]}
>>>>>>>> > +// CHECK: [[DTOR_CALL2_LOC]] = !{i32 [[@LINE+1]], i32 0,
>>>>>>>> [[FUN2]], null}
>>>>>>>> > bool fun2() { return (C(), b) && 0; }
>>>>>>>> >
>>>>>>>> > Modified: cfe/trunk/test/CodeGenCXX/debug-info-line.cpp
>>>>>>>> > URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGenCXX/debug-info-line.cpp?rev=225000&r1=224999&r2=225000&view=diff
>>>>>>>> >
>>>>>>>> ==============================================================================
>>>>>>>> > --- cfe/trunk/test/CodeGenCXX/debug-info-line.cpp (original)
>>>>>>>> > +++ cfe/trunk/test/CodeGenCXX/debug-info-line.cpp Tue Dec 30
>>>>>>>> 13:39:33 2014
>>>>>>>> > @@ -1,4 +1,5 @@
>>>>>>>> > // RUN: %clang_cc1 -g -std=c++11 -S -emit-llvm %s -o - |
>>>>>>>> FileCheck %s
>>>>>>>> > +// RUN: %clang_cc1 -triple i686-linux-gnu -g -std=c++11 -S
>>>>>>>> -emit-llvm %s -o - | FileCheck %s
>>>>>>>> >
>>>>>>>> > int &src();
>>>>>>>> > int *sink();
>>>>>>>> > @@ -110,6 +111,23 @@ void f10() {
>>>>>>>> > new (void_src()) int(src()));
>>>>>>>> > }
>>>>>>>> >
>>>>>>>> > +// CHECK-LABEL: define
>>>>>>>> > +__complex double f11() {
>>>>>>>> > + __complex double f;
>>>>>>>> > +// CHECK: store {{.*}} !dbg [[DBG_F11:!.*]]
>>>>>>>> > +#line 1200
>>>>>>>> > + return f;
>>>>>>>> > +}
>>>>>>>> > +
>>>>>>>> > +// CHECK-LABEL: define
>>>>>>>> > +void f12() {
>>>>>>>> > + int f12_1();
>>>>>>>> > + void f12_2(int = f12_1());
>>>>>>>> > +// CHECK: call i32 {{.*}} !dbg [[DBG_F12:!.*]]
>>>>>>>> > +#line 1300
>>>>>>>> > + f12_2();
>>>>>>>> > +}
>>>>>>>> > +
>>>>>>>> > // CHECK: [[DBG_F1]] = !{i32 100,
>>>>>>>> > // CHECK: [[DBG_FOO_VALUE]] = !{i32 200,
>>>>>>>> > // CHECK: [[DBG_FOO_REF]] = !{i32 202,
>>>>>>>> > @@ -124,3 +142,5 @@ void f10() {
>>>>>>>> > // CHECK: [[DBG_F9]] = !{i32 1000,
>>>>>>>> > // CHECK: [[DBG_F10_ICMP]] = !{i32 1100,
>>>>>>>> > // CHECK: [[DBG_F10_STORE]] = !{i32 1100,
>>>>>>>> > +// CHECK: [[DBG_F11]] = !{i32 1200,
>>>>>>>> > +// CHECK: [[DBG_F12]] = !{i32 1300,
>>>>>>>> >
>>>>>>>> > Modified: cfe/trunk/test/CodeGenCXX/debug-info-scope.cpp
>>>>>>>> > URL:
>>>>>>>> http://llvm.org/viewvc/llvm-project/cfe/trunk/test/CodeGenCXX/debug-info-scope.cpp?rev=225000&r1=224999&r2=225000&view=diff
>>>>>>>> >
>>>>>>>> ==============================================================================
>>>>>>>> > --- cfe/trunk/test/CodeGenCXX/debug-info-scope.cpp (original)
>>>>>>>> > +++ cfe/trunk/test/CodeGenCXX/debug-info-scope.cpp Tue Dec 30
>>>>>>>> 13:39:33 2014
>>>>>>>> > @@ -36,12 +36,12 @@ void func() {
>>>>>>>> > // CHECK: = !{!"0x100\00{{.*}}", [[FOR:![0-9]*]], {{.*}} ; [
>>>>>>>> DW_TAG_auto_variable ] [i] [line [[@LINE+2]]]
>>>>>>>> > // CHECK: [[FOR]] = !{!"0xb\00[[@LINE+1]]\00{{.*}}", !{{.*}}} ;
>>>>>>>> [ DW_TAG_lexical_block ]
>>>>>>>> > for (int i = 0; i != 10; ++i) {
>>>>>>>> > - // FIXME: Do not include scopes that have only other scopes
>>>>>>>> (and no variables
>>>>>>>> > - // or using declarations) as direct children, they just waste
>>>>>>>> > - // space/relocations/etc.
>>>>>>>> > - // CHECK: = !{!"0x100\00{{.*}}", [[FOR_COMPOUND:![0-9]*]],
>>>>>>>> {{.*}} ; [ DW_TAG_auto_variable ] [b] [line [[@LINE+3]]]
>>>>>>>> > - // CHECK: [[FOR_COMPOUND]] = !{!"0xb\00[[@LINE-5]]\00{{.*}}",
>>>>>>>> !{{[0-9]+}}, [[FOR_BODY:![0-9]+]]} ; [ DW_TAG_lexical_block ]
>>>>>>>> > - // CHECK: [[FOR_BODY]] = !{!"0xb\00[[@LINE-6]]\00{{.*}}",
>>>>>>>> !{{[0-9]+}}, [[FOR]]} ; [ DW_TAG_lexical_block ]
>>>>>>>> > + // FIXME: Do not include scopes that have only other scopes
>>>>>>>> (and no variables
>>>>>>>> > + // or using declarations) as direct children, they just waste
>>>>>>>> > + // space/relocations/etc.
>>>>>>>> > + // CHECK: [[FOR_LOOP_INCLUDING_COND:!.*]] =
>>>>>>>> !{!"0xb\00[[@LINE-4]]\00{{.*}}", !{{[0-9]+}}, [[FOR]]} ; [
>>>>>>>> DW_TAG_lexical_block ]
>>>>>>>> > + // CHECK: = !{!"0x100\00{{.*}}", [[FOR_COMPOUND:![0-9]*]],
>>>>>>>> {{.*}} ; [ DW_TAG_auto_variable ] [b] [line [[@LINE+2]]]
>>>>>>>> > + // CHECK: [[FOR_COMPOUND]] =
>>>>>>>> !{!"0xb\00[[@LINE-6]]\00{{.*}}", !{{[0-9]+}}, [[FOR_LOOP_INCLUDING_COND]]}
>>>>>>>> ; [ DW_TAG_lexical_block ]
>>>>>>>> > bool b = i % 2;
>>>>>>>> > }
>>>>>>>> >
>>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>> _______________________________________________
>>>>>>> cfe-commits mailing list
>>>>>>> cfe-commits at cs.uiuc.edu
>>>>>>> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
>>>>>>>
>>>>>>>
>>>>>>
>>>>>> _______________________________________________
>>>>>> cfe-commits mailing list
>>>>>> cfe-commits at cs.uiuc.edu
>>>>>> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
>>>>>>
>>>>>>
>>>>>
>>>> _______________________________________________
>>>> cfe-commits mailing list
>>>> cfe-commits at cs.uiuc.edu
>>>> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
>>>>
>>>>
>>>>
>>>> _______________________________________________
>>>> cfe-commits mailing list
>>>> cfe-commits at cs.uiuc.edu
>>>> http://lists.cs.uiuc.edu/mailman/listinfo/cfe-commits
>>>>
>>>>
>>>
>>>
>>>
>>
>>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://lists.llvm.org/pipermail/cfe-commits/attachments/20150109/fc716a66/attachment.html>
More information about the cfe-commits
mailing list