[DebugInfo] Support for DW_OP_implicit_pointer (DW_OP_LLVM_argN)

[alok]

Summary

This patch (1/N) stems from D69787
It is suggested by @aprantl

Summary:

It Introduces a new Dwarf operator DW_OP_LLVM_argN (N=0-7).
Which represents Nth argument of containing intrinsic.

Example:

For example in intrinsic
  "call @llvm.dbg.someintrinsic(DILocalVariable("x"), DILocalVariable("y"),
         metadata !DIExpression(DW_OP_LLVM_arg0, DW_OP_LLVM_arg1, DW_OP_plus))"
  'DW_OP_LLVM_arg0' represents 'DILocalVariable("x")' and
  'DW_OP_LLVM_arg1' represents 'DILocalVariable("y")'.

[TWeaver]

Hiya,

thanks for the patch!

just a small nit from me.

Cheers.

llvm/docs/LangRef.rst

4828

'argumnet' should be 'argument'

[alok]

llvm/docs/LangRef.rst

4828

Thanks for pointing this out. It will be corrected in next version.

[alok]

Updated to incorporated review comment.

[aprantl]

Thanks! This will need some bitcode-compatibility planning as well:

We'll need to bump the version number, and then in MetadataLoader.cpp / upradeDIExpression() add an a DW_OP_LLVM_arg0 at the beginning for all older versions.
This should be tested with a .bc file that contains an old-form DIExpression, run through llvm-dis | llvm-as | llvm-dis and checked that the expression is upgraded correctly.

llvm/include/llvm/BinaryFormat/Dwarf.def

663 ↗

(On Diff #230859)

Since these extensions are only used inside LLVM IR, they shouldn't leak into dwarfdump & friends. Can you take a look at how DW_OP_LLVM_fragment is defined and copy that? I think it is hardcoded in Dwarf.cpp

[alok]

In D70642#1765515, @aprantl wrote:

Thanks! This will need some bitcode-compatibility planning as well:

We'll need to bump the version number, and then in MetadataLoader.cpp / upradeDIExpression() add an a DW_OP_LLVM_arg0 at the beginning for all older versions.
This should be tested with a .bc file that contains an old-form DIExpression, run through llvm-dis | llvm-as | llvm-dis and checked that the expression is upgraded correctly.

Thanks for your comment. I shall look into it.

llvm/include/llvm/BinaryFormat/Dwarf.def

663 ↗

(On Diff #230859)

Thanks for your comment. It will be incorporated in next version.

[alok]

This is updated to incorporate comments from @aprantl.

[aprantl]

Thanks. This part looks good, but the bitcode upgrade is still missing.

[alok]

In D70642#1767321, @aprantl wrote:

Thanks. This part looks good, but the bitcode upgrade is still missing.

Sorry as I could not include that in first set of modifications. I was just thinking about which operations can be upgraded. One candidate for this was new expression DW_OP_LLVM_implicit_pointer which comes later that the current patch so escapes the need for upgrade. Should I look for existing operations for potential candidates for upgrade. or should i re-arrange the DW_OP_LLVM_implicit_pointer patch such as first it should not use DW_OP_LLVM_arg0 and then after current patch it needs upgrade. Could you please clear my doubt here ?

[aprantl]

In D70642#1769175, @alok wrote:

In D70642#1767321, @aprantl wrote:

Thanks. This part looks good, but the bitcode upgrade is still missing.

Sorry as I could not include that in first set of modifications. I was just thinking about which operations can be upgraded. One candidate for this was new expression DW_OP_LLVM_implicit_pointer which comes later that the current patch so escapes the need for upgrade. Should I look for existing operations for potential candidates for upgrade. or should i re-arrange the DW_OP_LLVM_implicit_pointer patch such as first it should not use DW_OP_LLVM_arg0 and then after current patch it needs upgrade. Could you please clear my doubt here ?

The upgrade I was thinking about here is reading old bitcode that contains

llvm.dbg.value(%foo, DILocalVariable(...), DIExpression(DW_OP_deref))

and upgrades it to

llvm.dbg.value(%foo, DILocalVariable(...), DIExpression(DW_OP_arg0, DW_OP_deref))

However, for this to work, we also need to implement support for DW_OP_argN to AsmPrinter to interpret the new operands and DIBuilder.

My assumption is that after this change DIExpression() is illegal and should be replaced by DIExpression(DW_OP_LLVM_arg0).
This transformation will cause a lot of churn in the Clang and LLVM testsuite (most of which you will be able to fix with a a sed script), but it will allow to resolve the ambiguity between:

!DIGlobalVariableExpression(!DIGlobalVariable("a"), !DIExpression())
!DIGlobalVariableExpression(!DIGlobalVariable("a"), !DIExpression(DW_OP_constu 42, DW_OP_stack_value))
!DIGlobalVariableExpression(!DIGlobalVariable("a"), !DIExpression(DW_OP_constu 42, DW_OP_plus, DW_OP_stack_value))

in the new scheme, these expressions would be

!DIExpression(DW_OP_LLVM_arg0)
!DIExpression(DW_OP_constu 42, DW_OP_stack_value) # constant, no arg!
!DIExpression(DW_OP_LLVM_arg0, DW_OP_constu 42, DW_OP_plus, DW_OP_stack_value))

respectively. We currently disambiguate between these cases by context: if the DIGlobalVariableExpression is a !dbg attachment of an llvm::Global, the global is the implicit arg0, otherwise there is no implict argument.

Since this is going to be a lot of work, we could also opt for a smaller, incremental change first that introduces only DW_OP_LLVM_arg1..DW_OP_LLVM_arg7 and keep the DW_OP_LLVM_arg0 implicit. Then we don't need to worry about bitcode upgrades now.

llvm/docs/LangRef.rst

4833

I just realized that DIGLobalVariableExpression also takes a DIExpression. I think we should also allow DW_OP_LLVM_arg0 there.

[alok]

In D70642#1769887, @aprantl wrote:

In D70642#1769175, @alok wrote:

In D70642#1767321, @aprantl wrote:

Thanks. This part looks good, but the bitcode upgrade is still missing.

Sorry as I could not include that in first set of modifications. I was just thinking about which operations can be upgraded. One candidate for this was new expression DW_OP_LLVM_implicit_pointer which comes later that the current patch so escapes the need for upgrade. Should I look for existing operations for potential candidates for upgrade. or should i re-arrange the DW_OP_LLVM_implicit_pointer patch such as first it should not use DW_OP_LLVM_arg0 and then after current patch it needs upgrade. Could you please clear my doubt here ?

The upgrade I was thinking about here is reading old bitcode that contains

llvm.dbg.value(%foo, DILocalVariable(...), DIExpression(DW_OP_deref))

and upgrades it to

llvm.dbg.value(%foo, DILocalVariable(...), DIExpression(DW_OP_arg0, DW_OP_deref))

However, for this to work, we also need to implement support for DW_OP_argN to AsmPrinter to interpret the new operands and DIBuilder.

My assumption is that after this change DIExpression() is illegal and should be replaced by DIExpression(DW_OP_LLVM_arg0).
This transformation will cause a lot of churn in the Clang and LLVM testsuite (most of which you will be able to fix with a a sed script), but it will allow to resolve the ambiguity between:

!DIGlobalVariableExpression(!DIGlobalVariable("a"), !DIExpression())
!DIGlobalVariableExpression(!DIGlobalVariable("a"), !DIExpression(DW_OP_constu 42, DW_OP_stack_value))
!DIGlobalVariableExpression(!DIGlobalVariable("a"), !DIExpression(DW_OP_constu 42, DW_OP_plus, DW_OP_stack_value))

in the new scheme, these expressions would be

!DIExpression(DW_OP_LLVM_arg0)
!DIExpression(DW_OP_constu 42, DW_OP_stack_value) # constant, no arg!
!DIExpression(DW_OP_LLVM_arg0, DW_OP_constu 42, DW_OP_plus, DW_OP_stack_value))

respectively. We currently disambiguate between these cases by context: if the DIGlobalVariableExpression is a !dbg attachment of an llvm::Global, the global is the implicit arg0, otherwise there is no implict argument.

Since this is going to be a lot of work, we could also opt for a smaller, incremental change first that introduces only DW_OP_LLVM_arg1..DW_OP_LLVM_arg7 and keep the DW_OP_LLVM_arg0 implicit. Then we don't need to worry about bitcode upgrades now.

Thanks a lot for the clarification. Next version of patch will include this.

[alok]

This is re-based and updated to apply LLVM_arg0 to existing DWARF operator and to upgrade for older styled DWARF expressions. This is done as suggested by @aprantl .

[alok]

Re-based and some cleanup.

clang/lib/CodeGen/CGDebugInfo.cpp

llvm::DILocalVariable *CGDebugInfo::EmitDeclare(const VarDecl *VD,
 
   // Clang stores the sret pointer provided by the caller in a static alloca.
   // Use DW_OP_deref to tell the debugger to load the pointer and treat it as
   // the address of the variable.
   if (UsePointerValue) {
     assert(std::find(Expr.begin(), Expr.end(), llvm::dwarf::DW_OP_deref) ==
                Expr.end() &&
            "Debug info already contains DW_OP_deref.");
+    if (Expr.size() == 0)
+      Expr.push_back(llvm::dwarf::DW_OP_LLVM_arg0);
     Expr.push_back(llvm::dwarf::DW_OP_deref);
   }
 
+  if (Expr.size() == 0)
+    Expr.push_back(llvm::dwarf::DW_OP_LLVM_arg0);
+
   // Create the descriptor for the variable.
   auto *D = ArgNo ? DBuilder.createParameterVariable(
                         Scope, Name, *ArgNo, Unit, Line, Ty,
                         CGM.getLangOpts().Optimize, Flags)
                   : DBuilder.createAutoVariable(Scope, Name, Unit, Line, Ty,
                                                 CGM.getLangOpts().Optimize,
                                                 Flags, Align);
 
void CGDebugInfo::EmitDeclareOfBlockDeclRefVariable(
 
   const llvm::DataLayout &target = CGM.getDataLayout();
 
   CharUnits offset = CharUnits::fromQuantity(
       target.getStructLayout(blockInfo.StructureType)
           ->getElementOffset(blockInfo.getCapture(VD).getIndex()));
 
   SmallVector<int64_t, 9> addr;
+  addr.push_back(llvm::dwarf::DW_OP_LLVM_arg0);
   addr.push_back(llvm::dwarf::DW_OP_deref);
   addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
   addr.push_back(offset.getQuantity());
   if (isByRef) {
     addr.push_back(llvm::dwarf::DW_OP_deref);
     addr.push_back(llvm::dwarf::DW_OP_plus_uconst);
     // offset of __forwarding field
     offset =

clang/test/CodeGen/2009-10-20-GlobalDebug.c

 // REQUIRES: x86-registered-target
 // RUN: %clang -target i386-apple-darwin10 -flto -S -g %s -o - | FileCheck %s
 
 // CHECK: @main.localstatic = internal global i32 0, align 4, !dbg [[L:![0-9]+]]
 // CHECK: @global = common global i32 0, align 4, !dbg [[G:![0-9]+]]
 
 int global;
 int main() { 
   static int localstatic;
   return 0;
 }
 
-// CHECK: [[L]] = !DIGlobalVariableExpression(var: [[LV:.*]], expr: !DIExpression())
+// CHECK: [[L]] = !DIGlobalVariableExpression(var: [[LV:.*]], expr: !DIExpression(DW_OP_LLVM_arg0))
 // CHECK: [[LV]] = distinct !DIGlobalVariable(name: "localstatic"
 // CHECK-NOT:                                 linkageName:
 // CHECK-SAME:                                line: 9,
-// CHECK: [[G]] = !DIGlobalVariableExpression(var: [[GV:.*]], expr: !DIExpression())
+// CHECK: [[G]] = !DIGlobalVariableExpression(var: [[GV:.*]], expr: !DIExpression(DW_OP_LLVM_arg0))
 // CHECK: [[GV]] = distinct !DIGlobalVariable(name: "global"
 // CHECK-NOT:                                 linkageName:
 // CHECK-SAME:                                line: 7,

clang/test/CodeGen/debug-info-static-const-fp.c

 // CHECK: [[FVAL]] = distinct !DIGlobalVariable(name: "fVal",
 // CHECK-SAME:                                  isLocal: true, isDefinition: true
 
 // CHECK: !DIGlobalVariableExpression(var: [[DVAL:.*]], expr: !DIExpression(DW_OP_constu, 4658387303597904457, DW_OP_stack_value))
 // CHECK: [[DVAL]] = distinct !DIGlobalVariable(name: "dVal",
 // CHECK-SAME:                                  isLocal: true, isDefinition: true
 
 // CHECK-LDlg-DAG: [[LDVAL:.*]] = distinct !DIGlobalVariable(name: "ldVal", {{.*}}, isLocal: true, isDefinition: true)
-// CHECK-LDlg-DAG: !DIGlobalVariableExpression(var: [[LDVAL]], expr: !DIExpression())
+// CHECK-LDlg-DAG: !DIGlobalVariableExpression(var: [[LDVAL]], expr: !DIExpression(DW_OP_LLVM_arg0))
 // CHECK-LDsm-DAG: [[LDVAL:.*]] = distinct !DIGlobalVariable(name: "ldVal", {{.*}}, isLocal: true, isDefinition: true)
 // CHECK-LDsm-DAG: !DIGlobalVariableExpression(var: [[LDVAL]], expr:

clang/test/CodeGen/debug-info-static.c

 // RUN: %clang_cc1  -debug-info-kind=limited -emit-llvm -o - %s | FileCheck %s
 
 // CHECK: @f.xyzzy = internal global i32 0, align 4, !dbg [[XYZZY:![0-9]+]]
 
-// CHECK: [[XYZZY]] = !DIGlobalVariableExpression(var: [[VAR:.*]], expr: !DIExpression())
+// CHECK: [[XYZZY]] = !DIGlobalVariableExpression(var: [[VAR:.*]], expr: !DIExpression(DW_OP_LLVM_arg0))
 // CHECK: [[VAR]] = distinct !DIGlobalVariable
 void f(void)
 {
    static int xyzzy;
    xyzzy += 3;
 }

clang/test/CodeGenCUDA/debug-info-address-class.cu

 // RUN: %clang_cc1 -emit-llvm %s -o - -fcuda-is-device -triple nvptx-unknown-unknown -debug-info-kind=limited -dwarf-version=2 -debugger-tuning=gdb | FileCheck %s
 
 #include "Inputs/cuda.h"
 
 // CHECK-DAG: ![[FILEVAR0:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar0", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
-// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR0]], expr: !DIExpression())
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR0]], expr: !DIExpression(DW_OP_LLVM_arg0))
 __device__ int FileVar0;
 // CHECK-DAG: ![[FILEVAR1:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar1", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
 // CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR1]], expr: !DIExpression(DW_OP_constu, 8, DW_OP_swap, DW_OP_xderef))
 __device__ __shared__ int FileVar1;
 // CHECK-DAG: ![[FILEVAR2:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar2", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
 // CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR2]], expr: !DIExpression(DW_OP_constu, 4, DW_OP_swap, DW_OP_xderef))
 __device__ __constant__ int FileVar2;
 
 __device__ void kernel1(
     // CHECK-DAG: ![[ARG:[0-9]+]] = !DILocalVariable(name: "Arg", arg: {{[0-9]+}}, scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}})
-    // CHECK-DAG: call void @llvm.dbg.declare(metadata i32* {{.*}}, metadata ![[ARG]], metadata !DIExpression()), !dbg !{{[0-9]+}}
+    // CHECK-DAG: call void @llvm.dbg.declare(metadata i32* {{.*}}, metadata ![[ARG]], metadata !DIExpression(DW_OP_LLVM_arg0)), !dbg !{{[0-9]+}}
     int Arg) {
     // CHECK-DAG: ![[FUNCVAR0:[0-9]+]] = distinct !DIGlobalVariable(name: "FuncVar0", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: true, isDefinition: true)
     // CHECK-DAG: !DIGlobalVariableExpression(var: ![[FUNCVAR0]], expr: !DIExpression(DW_OP_constu, 8, DW_OP_swap, DW_OP_xderef))
   __shared__ int FuncVar0;
   // CHECK-DAG: ![[FUNCVAR1:[0-9]+]] = !DILocalVariable(name: "FuncVar1", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}})
-  // CHECK-DAG: call void @llvm.dbg.declare(metadata i32* {{.*}}, metadata ![[FUNCVAR1]], metadata !DIExpression()), !dbg !{{[0-9]+}}
+  // CHECK-DAG: call void @llvm.dbg.declare(metadata i32* {{.*}}, metadata ![[FUNCVAR1]], metadata !DIExpression(DW_OP_LLVM_arg0)), !dbg !{{[0-9]+}}
   int FuncVar1;
 }

clang/test/CodeGenCXX/debug-info-inheriting-constructor.cpp

 // RUN: %clang_cc1 -debug-info-kind=standalone -std=c++11 -triple x86_64-darwin -emit-llvm -o - %s | FileCheck %s
 
 struct A {
   A(int, ...);
 };
 struct B : A {
   using A::A;
 };
 
 A::A(int i, ...) {}
 // CHECK: define void @{{.*}}foo
 // CHECK-NOT: ret void
 // CHECK: call void @llvm.dbg.declare
 // CHECK-NOT: ret void
 // CHECK: call void @llvm.dbg.declare(metadata %{{.*}}** %{{[^,]+}},
-// CHECK-SAME: metadata ![[THIS:[0-9]+]], metadata !DIExpression()), !dbg ![[LOC:[0-9]+]]
+// CHECK-SAME: metadata ![[THIS:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_arg0)), !dbg ![[LOC:[0-9]+]]
 // CHECK: ret void, !dbg ![[NOINL:[0-9]+]]
 // CHECK: ![[FOO:.*]] = distinct !DISubprogram(name: "foo"
 // CHECK-DAG: ![[A:.*]] = distinct !DISubprogram(name: "A", linkageName: "_ZN1BCI11AEiz"
 void foo() {
 // CHECK-DAG: ![[LOC]] = !DILocation(line: 0, scope: ![[A]], inlinedAt: ![[INL:[0-9]+]])
 // CHECK-DAG: ![[INL]] = !DILocation(line: [[@LINE+1]], scope: ![[FOO]])
   B b(0);
 // CHECK: ![[NOINL]] = !DILocation(line: [[@LINE+1]], scope: !{{[0-9]+}})
 }

clang/test/CodeGenCXX/debug-info-nrvo.cpp

int main() {
   return bar.x;
 }
 
 // Check that NRVO variables are stored as a pointer with deref if they are
 // stored in the return register.
 
 // CHECK: %[[RESULT:.*]] = alloca i8*, align 8
 // CHECK: call void @llvm.dbg.declare(metadata i8** %[[RESULT]],
-// CHECK-SAME: metadata !DIExpression(DW_OP_deref)
+// CHECK-SAME: metadata !DIExpression(DW_OP_LLVM_arg0, DW_OP_deref)
 
 // NOELIDE: %[[FOO:.*]] = alloca %struct.Foo, align 4
 // NOELIDE: call void @llvm.dbg.declare(metadata %struct.Foo* %[[FOO]],
-// NOELIDE-SAME:                        metadata !DIExpression()
+// NOELIDE-SAME:                        metadata !DIExpression(DW_OP_LLVM_arg0)

clang/test/CodeGenCXX/debug-info-static-member.cpp

public:
   int d;
   static X x_a;
 };
 
 // The definition of C::a drives the emission of class C, which is
 // why the definition of "a" comes before the declarations while
 // "b" and "c" come after.
 
-// CHECK: [[A]] = !DIGlobalVariableExpression(var: [[AV:.*]], expr: !DIExpression())
+// CHECK: [[A]] = !DIGlobalVariableExpression(var: [[AV:.*]], expr: !DIExpression(DW_OP_LLVM_arg0))
 // CHECK: [[AV]] = distinct !DIGlobalVariable(name: "a",
 // CHECK-SAME:                                declaration: ![[DECL_A:[0-9]+]])
 // MSVC: distinct !DIGlobalVariable(name: "a"
 //
 // CHECK: !DICompositeType(tag: DW_TAG_enumeration_type, name: "X"{{.*}}, identifier: "_ZTS1X")
 // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "anon_static_decl_struct"
 // CHECK: !DIDerivedType(tag: DW_TAG_member, name: "anon_static_decl_var"
 // CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "static_decl_templ<int>"
 // CHECK-NOT:              DIFlagFwdDecl
 // CHECK-SAME:             ){{$}}
 // CHECK: !DIDerivedType(tag: DW_TAG_member, name: "static_decl_templ_var"
 
 int C::a = 4;
-// CHECK: [[B]] = !DIGlobalVariableExpression(var: [[BV:.*]], expr: !DIExpression())
+// CHECK: [[B]] = !DIGlobalVariableExpression(var: [[BV:.*]], expr: !DIExpression(DW_OP_LLVM_arg0))
 // CHECK: [[BV]] = distinct !DIGlobalVariable(name: "b",
 // CHECK-SAME:                                declaration: ![[DECL_B:[0-9]+]])
 // MSVC: distinct !DIGlobalVariable(name: "b"
 // CHECK: ![[DECL_B]] = !DIDerivedType(tag: DW_TAG_member, name: "b"
 // CHECK-NOT:                                 size:
 // CHECK-NOT:                                 align:
 // CHECK-NOT:                                 offset:
 // CHECK-SAME:                                flags: DIFlagProtected | DIFlagStaticMember)

 // CHECK-NOT:            offset:
 // CHECK-SAME:           flags: DIFlagPublic | DIFlagStaticMember,
 // CHECK-SAME:           extraData: i32 18)
 //
 // CHECK: !DIDerivedType(tag: DW_TAG_member, name: "x_a"
 // CHECK-SAME:           flags: DIFlagPublic | DIFlagStaticMember)
 
 int C::b = 2;
-// CHECK: [[C]] = !DIGlobalVariableExpression(var: [[CV:.*]], expr: !DIExpression())
+// CHECK: [[C]] = !DIGlobalVariableExpression(var: [[CV:.*]], expr: !DIExpression(DW_OP_LLVM_arg0))
 // CHECK: [[CV]] = distinct !DIGlobalVariable(name: "c", {{.*}} declaration: ![[DECL_C]])
 // MSVC: distinct !DIGlobalVariable(name: "c"
 int C::c = 1;
 
 int main()
 {
         C instance_C;
         instance_C.d = 8;

clang/test/CodeGenCXX/debug-info-template-member.cpp

int add2(int x) {
   return MyClass().add<2>(x);
 }
 
 inline int add3(int x) {
   return MyClass().add<3>(x); // even though add<3> is ODR used, don't emit it since we don't codegen it
 }
 
 // The compile unit pulls in the global variables first.
-// CHECK: [[X]] = !DIGlobalVariableExpression(var: [[XV:.*]], expr: !DIExpression())
+// CHECK: [[X]] = !DIGlobalVariableExpression(var: [[XV:.*]], expr: !DIExpression(DW_OP_LLVM_arg0))
 // CHECK: [[XV]] = distinct !DIGlobalVariable(name: "x",
 // CHECK-SAME:                                type: ![[OUTER_FOO_INNER_ID:[0-9]+]]
 //
 // CHECK: {{![0-9]+}} = distinct !DIGlobalVariable(
 // CHECK-SAME: name: "var"
 // CHECK-SAME: templateParams: {{![0-9]+}}
 // CHECK: !DITemplateTypeParameter(name: "T", type: [[TY:![0-9]+]])
 // CHECK: {{![0-9]+}} = distinct !DIGlobalVariable(

clang/test/CodeGenCXX/debug-info-template.cpp

 struct TC {
   struct nested {
   };
 };
 
 int glb;
 void func();
 
-// CHECK: [[TCI]] = !DIGlobalVariableExpression(var: [[TCIV:.*]], expr: !DIExpression())
+// CHECK: [[TCI]] = !DIGlobalVariableExpression(var: [[TCIV:.*]], expr: !DIExpression(DW_OP_LLVM_arg0))
 // CHECK: [[TCIV]] = distinct !DIGlobalVariable(name: "tci",
 // CHECK-SAME:                                  type: ![[TCNESTED:[0-9]+]]
 // CHECK: ![[TCNESTED]] ={{.*}}!DICompositeType(tag: DW_TAG_structure_type, name: "nested",
 // CHECK-SAME:             scope: ![[TC:[0-9]+]],
 
 // CHECK: ![[TC]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "TC<unsigned int, 2, &glb, &foo::e, &foo::f, &foo::g, 1, 2, 3>"
 // CHECK-SAME:                              templateParams: [[TCARGS:![0-9]*]]
 TC

 // CHECK: [[TCARG7_VALS]] = !{[[TCARG7_1:![0-9]*]], [[TCARG7_2:![0-9]*]], [[TCARG7_3:![0-9]*]]}
 // CHECK: [[TCARG7_1]] = !DITemplateValueParameter(type: [[INT]], value: i32 1)
   1,
 // CHECK: [[TCARG7_2]] = !DITemplateValueParameter(type: [[INT]], value: i32 2)
   2,
 // CHECK: [[TCARG7_3]] = !DITemplateValueParameter(type: [[INT]], value: i32 3)
   3>::nested tci;
 
-// CHECK: [[TCN]] = !DIGlobalVariableExpression(var: [[TCNV:.*]], expr: !DIExpression())
+// CHECK: [[TCN]] = !DIGlobalVariableExpression(var: [[TCNV:.*]], expr: !DIExpression(DW_OP_LLVM_arg0))
 // CHECK: [[TCNV]] = distinct !DIGlobalVariable(name: "tcn"
 // CHECK-SAME:                                  type: ![[TCNT:[0-9]+]]
 TC
 // CHECK: ![[TCNT]] ={{.*}}!DICompositeType(tag: DW_TAG_structure_type, name: "TC<int, -3, nullptr, nullptr, nullptr, nullptr>"
 // CHECK-SAME:             templateParams: [[TCNARGS:![0-9]*]]
 // CHECK: [[TCNARGS]] = !{[[TCNARG1:![0-9]*]], [[TCNARG2:![0-9]*]], [[TCNARG3:![0-9]*]], [[TCNARG4:![0-9]*]], [[TCNARG5:![0-9]*]], [[TCNARG6:![0-9]*]], [[TCNARG7:![0-9]*]]}
 // CHECK: [[TCNARG1]] = !DITemplateTypeParameter(name: "T", type: [[INT]])
 <int,

 template<typename>
 struct tmpl_impl {
 };
 
 template <template <typename> class tmpl, int &lvr, int &&rvr>
 struct NN {
 };
 
-// CHECK: [[NN]] = !DIGlobalVariableExpression(var: [[NNV:.*]], expr: !DIExpression())
+// CHECK: [[NN]] = !DIGlobalVariableExpression(var: [[NNV:.*]], expr: !DIExpression(DW_OP_LLVM_arg0))
 // CHECK: [[NNV]] = distinct !DIGlobalVariable(name: "nn"
 // CHECK-SAME:                                 type: ![[NNT:[0-9]+]]
 
 // FIXME: these parameters should probably be rendered as 'glb' rather than
 // '&glb', since they're references, not pointers.
 // CHECK: ![[NNT]] ={{.*}}!DICompositeType(tag: DW_TAG_structure_type, name: "NN<tmpl_impl, &glb, &glb>",
 // CHECK-SAME:             templateParams: [[NNARGS:![0-9]*]]
 // CHECK-SAME:             identifier:

clang/test/CodeGenCXX/debug-info.cpp

 // RUN: %clang_cc1 -triple x86_64-none-linux-gnu -emit-llvm -debug-info-kind=limited %s -o - | FileCheck %s --check-prefix=CHECK --check-prefix=BOTH
 // RUN: %clang_cc1 -triple i686-pc-windows-msvc -emit-llvm -debug-info-kind=limited %s -o - | FileCheck %s --check-prefix=MSVC --check-prefix=BOTH
 
 // CHECK: @_ZN6pr96081xE = global [3 x i8]* null, align 8, !dbg [[X:![0-9]+]]
 
 // CHECK: define void @_ZN7pr147634funcENS_3fooE
-// CHECK: call void @llvm.dbg.declare({{.*}}, metadata ![[F:[0-9]+]], metadata !DIExpression())
+// CHECK: call void @llvm.dbg.declare({{.*}}, metadata ![[F:[0-9]+]], metadata !DIExpression(DW_OP_LLVM_arg0))
 
 // !llvm.dbg.cu pulls in globals and their types first.
 // CHECK-NOT: !DIGlobalVariable(name: "c"
-// CHECK: [[X]] = !DIGlobalVariableExpression(var: [[XV:!.*]], expr: !DIExpression())
+// CHECK: [[X]] = !DIGlobalVariableExpression(var: [[XV:!.*]], expr: !DIExpression(DW_OP_LLVM_arg0))
 // CHECK: [[XV]] = distinct !DIGlobalVariable(name: "x", linkageName: "_ZN6pr96081xE"
 // CHECK-SAME:                                type: [[INCARRAYPTR:![0-9]*]]
 // CHECK: [[INCARRAYPTR]] = !DIDerivedType(tag: DW_TAG_pointer_type, baseType: [[INCARRAY:![0-9]+]]
 // CHECK: [[INCARRAY]] = !DICompositeType(tag: DW_TAG_array_type
 // CHECK-NOT:                             line:
 // CHECK-NOT:                             size:
 // CHECK-NOT:                             align:
 // CHECK-NOT:                             offset:

clang/test/CodeGenCXX/inline-dllexport-member.cpp

 // RUN: %clang_cc1 -triple i686-windows-win32 -fms-extensions -debug-info-kind=limited -emit-llvm %s -o - \
 // RUN:    | FileCheck %s
 
 // CHECK: @"?ui@s@@2IB" = weak_odr dso_local dllexport constant i32 0, comdat, align 4, !dbg [[UI:![0-9]+]]
 
 struct __declspec(dllexport) s {
   static const unsigned int ui = 0;
 };
 
-// CHECK: [[UI]] = !DIGlobalVariableExpression(var: [[UIV:.*]], expr: !DIExpression())
+// CHECK: [[UI]] = !DIGlobalVariableExpression(var: [[UIV:.*]], expr: !DIExpression(DW_OP_LLVM_arg0))
 // CHECK: [[UIV]] = distinct !DIGlobalVariable(name: "ui", linkageName: "?ui@s@@2IB", scope: ![[SCOPE:[0-9]+]],
 // CHECK: ![[SCOPE]] = distinct !DICompileUnit(
 

clang/test/CodeGenOpenCL/amdgpu-debug-info-variable-expression.cl

 // RUN: %clang -cl-std=CL2.0 -emit-llvm -g -O0 -S -target amdgcn-amd-amdhsa -mcpu=fiji -o - %s | FileCheck %s
 // RUN: %clang -cl-std=CL2.0 -emit-llvm -g -O0 -S -target amdgcn-amd-amdhsa-opencl -mcpu=fiji -o - %s | FileCheck %s
 
 // CHECK-DAG: ![[FILEVAR0:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar0", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
-// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR0]], expr: !DIExpression())
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR0]], expr: !DIExpression(DW_OP_LLVM_arg0))
 global int *FileVar0;
 // CHECK-DAG: ![[FILEVAR1:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar1", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
-// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR1]], expr: !DIExpression())
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR1]], expr: !DIExpression(DW_OP_LLVM_arg0))
 constant int *FileVar1;
 // CHECK-DAG: ![[FILEVAR2:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar2", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
-// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR2]], expr: !DIExpression())
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR2]], expr: !DIExpression(DW_OP_LLVM_arg0))
 local int *FileVar2;
 // CHECK-DAG: ![[FILEVAR3:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar3", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
-// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR3]], expr: !DIExpression())
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR3]], expr: !DIExpression(DW_OP_LLVM_arg0))
 private int *FileVar3;
 // CHECK-DAG: ![[FILEVAR4:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar4", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
-// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR4]], expr: !DIExpression())
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR4]], expr: !DIExpression(DW_OP_LLVM_arg0))
 int *FileVar4;
 
 // CHECK-DAG: ![[FILEVAR5:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar5", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
-// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR5]], expr: !DIExpression())
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR5]], expr: !DIExpression(DW_OP_LLVM_arg0))
 global int *global FileVar5;
 // CHECK-DAG: ![[FILEVAR6:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar6", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
-// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR6]], expr: !DIExpression())
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR6]], expr: !DIExpression(DW_OP_LLVM_arg0))
 constant int *global FileVar6;
 // CHECK-DAG: ![[FILEVAR7:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar7", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
-// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR7]], expr: !DIExpression())
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR7]], expr: !DIExpression(DW_OP_LLVM_arg0))
 local int *global FileVar7;
 // CHECK-DAG: ![[FILEVAR8:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar8", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
-// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR8]], expr: !DIExpression())
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR8]], expr: !DIExpression(DW_OP_LLVM_arg0))
 private int *global FileVar8;
 // CHECK-DAG: ![[FILEVAR9:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar9", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
-// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR9]], expr: !DIExpression())
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR9]], expr: !DIExpression(DW_OP_LLVM_arg0))
 int *global FileVar9;
 
 // CHECK-DAG: ![[FILEVAR10:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar10", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
-// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR10]], expr: !DIExpression())
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR10]], expr: !DIExpression(DW_OP_LLVM_arg0))
 global int *constant FileVar10 = 0;
 // CHECK-DAG: ![[FILEVAR11:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar11", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
-// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR11]], expr: !DIExpression())
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR11]], expr: !DIExpression(DW_OP_LLVM_arg0))
 constant int *constant FileVar11 = 0;
 // CHECK-DAG: ![[FILEVAR12:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar12", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
-// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR12]], expr: !DIExpression())
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR12]], expr: !DIExpression(DW_OP_LLVM_arg0))
 local int *constant FileVar12 = 0;
 // CHECK-DAG: ![[FILEVAR13:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar13", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
-// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR13]], expr: !DIExpression())
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR13]], expr: !DIExpression(DW_OP_LLVM_arg0))
 private int *constant FileVar13 = 0;
 // CHECK-DAG: ![[FILEVAR14:[0-9]+]] = distinct !DIGlobalVariable(name: "FileVar14", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: false, isDefinition: true)
-// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR14]], expr: !DIExpression())
+// CHECK-DAG: !DIGlobalVariableExpression(var: ![[FILEVAR14]], expr: !DIExpression(DW_OP_LLVM_arg0))
 int *constant FileVar14 = 0;
 
 kernel void kernel1(
     // CHECK-DAG: ![[KERNELARG0:[0-9]+]] = !DILocalVariable(name: "KernelArg0", arg: {{[0-9]+}}, scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}})
     // CHECK-DAG: call void @llvm.dbg.declare(metadata i32 addrspace(1)* addrspace(5)* {{.*}}, metadata ![[KERNELARG0]], metadata !DIExpression(DW_OP_constu, 1, DW_OP_swap, DW_OP_xderef)), !dbg !{{[0-9]+}}
     global int *KernelArg0,
     // CHECK-DAG: ![[KERNELARG1:[0-9]+]] = !DILocalVariable(name: "KernelArg1", arg: {{[0-9]+}}, scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}})
     // CHECK-DAG: call void @llvm.dbg.declare(metadata i32 addrspace(4)* addrspace(5)* {{.*}}, metadata ![[KERNELARG1]], metadata !DIExpression(DW_OP_constu, 1, DW_OP_swap, DW_OP_xderef)), !dbg !{{[0-9]+}}
kernel void kernel1(
   // CHECK-DAG: ![[FUNCVAR3:[0-9]+]] = !DILocalVariable(name: "FuncVar3", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}})
   // CHECK-DAG: call void @llvm.dbg.declare(metadata i32 addrspace(5)* addrspace(5)* {{.*}}, metadata ![[FUNCVAR3]], metadata !DIExpression(DW_OP_constu, 1, DW_OP_swap, DW_OP_xderef)), !dbg !{{[0-9]+}}
   private int *FuncVar3 = Tmp0;
   // CHECK-DAG: ![[FUNCVAR4:[0-9]+]] = !DILocalVariable(name: "FuncVar4", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}})
   // CHECK-DAG: call void @llvm.dbg.declare(metadata i32* addrspace(5)* {{.*}}, metadata ![[FUNCVAR4]], metadata !DIExpression(DW_OP_constu, 1, DW_OP_swap, DW_OP_xderef)), !dbg !{{[0-9]+}}
   int *FuncVar4 = Tmp1;
 
   // CHECK-DAG: ![[FUNCVAR5:[0-9]+]] = distinct !DIGlobalVariable(name: "FuncVar5", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: true, isDefinition: true)
-  // CHECK-DAG: !DIGlobalVariableExpression(var: ![[FUNCVAR5]], expr: !DIExpression())
+  // CHECK-DAG: !DIGlobalVariableExpression(var: ![[FUNCVAR5]], expr: !DIExpression(DW_OP_LLVM_arg0))
   global int *constant FuncVar5 = 0;
   // CHECK-DAG: ![[FUNCVAR6:[0-9]+]] = distinct !DIGlobalVariable(name: "FuncVar6", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: true, isDefinition: true)
-  // CHECK-DAG: !DIGlobalVariableExpression(var: ![[FUNCVAR6]], expr: !DIExpression())
+  // CHECK-DAG: !DIGlobalVariableExpression(var: ![[FUNCVAR6]], expr: !DIExpression(DW_OP_LLVM_arg0))
   constant int *constant FuncVar6 = 0;
   // CHECK-DAG: ![[FUNCVAR7:[0-9]+]] = distinct !DIGlobalVariable(name: "FuncVar7", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: true, isDefinition: true)
-  // CHECK-DAG: !DIGlobalVariableExpression(var: ![[FUNCVAR7]], expr: !DIExpression())
+  // CHECK-DAG: !DIGlobalVariableExpression(var: ![[FUNCVAR7]], expr: !DIExpression(DW_OP_LLVM_arg0))
   local int *constant FuncVar7 = 0;
   // CHECK-DAG: ![[FUNCVAR8:[0-9]+]] = distinct !DIGlobalVariable(name: "FuncVar8", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: true, isDefinition: true)
-  // CHECK-DAG: !DIGlobalVariableExpression(var: ![[FUNCVAR8]], expr: !DIExpression())
+  // CHECK-DAG: !DIGlobalVariableExpression(var: ![[FUNCVAR8]], expr: !DIExpression(DW_OP_LLVM_arg0))
   private int *constant FuncVar8 = 0;
   // CHECK-DAG: ![[FUNCVAR9:[0-9]+]] = distinct !DIGlobalVariable(name: "FuncVar9", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: true, isDefinition: true)
-  // CHECK-DAG: !DIGlobalVariableExpression(var: ![[FUNCVAR9]], expr: !DIExpression())
+  // CHECK-DAG: !DIGlobalVariableExpression(var: ![[FUNCVAR9]], expr: !DIExpression(DW_OP_LLVM_arg0))
   int *constant FuncVar9 = 0;
 
   // CHECK-DAG: ![[FUNCVAR10:[0-9]+]] = distinct !DIGlobalVariable(name: "FuncVar10", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: true, isDefinition: true)
   // CHECK-DAG: !DIGlobalVariableExpression(var: ![[FUNCVAR10]], expr: !DIExpression(DW_OP_constu, 2, DW_OP_swap, DW_OP_xderef))
   global int *local FuncVar10; FuncVar10 = KernelArg0;
   // CHECK-DAG: ![[FUNCVAR11:[0-9]+]] = distinct !DIGlobalVariable(name: "FuncVar11", scope: !{{[0-9]+}}, file: !{{[0-9]+}}, line: {{[0-9]+}}, type: !{{[0-9]+}}, isLocal: true, isDefinition: true)
   // CHECK-DAG: !DIGlobalVariableExpression(var: ![[FUNCVAR11]], expr: !DIExpression(DW_OP_constu, 2, DW_OP_swap, DW_OP_xderef))
   constant int *local FuncVar11; FuncVar11 = KernelArg1;

clang/test/OpenMP/nvptx_target_firstprivate_codegen.cpp

#pragma omp target firstprivate(a, e) map(tofrom \
     b[a] += e.X;
   }
 
   // TCHECK:  define {{.*}}void @__omp_offloading_{{.+}}([10 x float] addrspace(1)* noalias [[B_IN:%.+]], i{{[0-9]+}} [[A_IN:%.+]], [[TTII]]* noalias [[E_IN:%.+]])
   // TCHECK-NOT: alloca [[TTII]],
   // TCHECK:  [[A_ADDR:%.+]] = alloca i{{[0-9]+}},
   // TCHECK-NOT: alloca [[TTII]],
   // TCHECK-NOT: alloca i{{[0-9]+}},
-  // TCHECK-64:  call void @llvm.dbg.declare(metadata [10 x float] addrspace(1)** %{{.+}}, metadata !{{[0-9]+}}, metadata !DIExpression())
+  // TCHECK-64:  call void @llvm.dbg.declare(metadata [10 x float] addrspace(1)** %{{.+}}, metadata !{{[0-9]+}}, metadata !DIExpression(DW_OP_LLVM_arg0))
   // TCHECK:  store i{{[0-9]+}} [[A_IN]], i{{[0-9]+}}* [[A_ADDR]],
   // TCHECK:  ret void
 
 #pragma omp target firstprivate(aa, b, c, d)
   {
     aa += 1;
     b[2] = 1.0;
     c[1][2] = 1.0;

llvm/docs/LangRef.rst

- ``DW_OP_LLVM_entry_value, N`` can only appear at the beginning of a
   register location descriptions. The operation is also introduced by the
   ``AsmPrinter`` pass when a call site parameter value
   (``DW_AT_call_site_parameter_value``) is represented as entry value of the
   parameter.
 - ``DW_OP_breg`` (or ``DW_OP_bregx``) represents a content on the provided
   signed offset of the specified register. The opcode is only generated by the
   ``AsmPrinter`` pass to describe call site parameter value which requires an
   expression over two registers.
+- ``DW_OP_LLVM_argN`` represents argument number N of the containing LLVM
+  intrinsic. Where N can be any value from 0 to 7. For example in intrinsic
+  ``call @llvm.dbg.someintrinsic(DILocalVariable("x"), DILocalVariable("y"),
+  metadata !DIExpression(DW_OP_LLVM_arg0, DW_OP_LLVM_arg1, DW_OP_plus))``
+  ``DW_OP_LLVM_arg0`` represents ``DILocalVariable("x")`` and
+  ``DW_OP_LLVM_arg1`` represents ``DILocalVariable("y")``.
 
 DWARF specifies three kinds of simple location descriptions: Register, memory,
 and implicit location descriptions.  Note that a location description is
 defined over certain ranges of a program, i.e the location of a variable may
 change over the course of the program. Register and memory location
 descriptions describe the *concrete location* of a source variable (in the
 sense that a debugger might modify its value), whereas *implicit locations*
 describe merely the actual *value* of a source variable which might not exist

llvm/include/llvm/BinaryFormat/Dwarf.h

 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR) DW_OP_##NAME = ID,
 #include "llvm/BinaryFormat/Dwarf.def"
   DW_OP_lo_user = 0xe0,
   DW_OP_hi_user = 0xff,
   DW_OP_LLVM_fragment = 0x1000,    ///< Only used in LLVM metadata.
   DW_OP_LLVM_convert = 0x1001,     ///< Only used in LLVM metadata.
   DW_OP_LLVM_tag_offset = 0x1002,  ///< Only used in LLVM metadata.
   DW_OP_LLVM_entry_value = 0x1003, ///< Only used in LLVM metadata.
+  DW_OP_LLVM_arg0 = 0x1004,        ///< Only used in LLVM metadata.
+  DW_OP_LLVM_arg1 = 0x1005,        ///< Only used in LLVM metadata.
+  DW_OP_LLVM_arg2 = 0x1006,        ///< Only used in LLVM metadata.
+  DW_OP_LLVM_arg3 = 0x1007,        ///< Only used in LLVM metadata.
+  DW_OP_LLVM_arg4 = 0x1008,        ///< Only used in LLVM metadata.
+  DW_OP_LLVM_arg5 = 0x1009,        ///< Only used in LLVM metadata.
+  DW_OP_LLVM_arg6 = 0x100a,        ///< Only used in LLVM metadata.
+  DW_OP_LLVM_arg7 = 0x100b,        ///< Only used in LLVM metadata.
 };
 
 enum TypeKind : uint8_t {
 #define HANDLE_DW_ATE(ID, NAME, VERSION, VENDOR) DW_ATE_##NAME = ID,
 #include "llvm/BinaryFormat/Dwarf.def"
   DW_ATE_lo_user = 0x80,
   DW_ATE_hi_user = 0xff
 };

llvm/include/llvm/IR/DebugInfoMetadata.h

public:
   bool isValid() const;
 
   static bool classof(const Metadata *MD) {
     return MD->getMetadataID() == DIExpressionKind;
   }
 
   /// Return whether the first element a DW_OP_deref.
   bool startsWithDeref() const {
-    return getNumElements() > 0 && getElement(0) == dwarf::DW_OP_deref;
+    return (getNumElements() > 0 && getElement(0) == dwarf::DW_OP_deref) ||
+           (getNumElements() > 1 && getElement(0) == dwarf::DW_OP_LLVM_arg0 &&
+            getElement(1) == dwarf::DW_OP_deref);
   }
 
   /// Holds the characteristics of one fragment of a larger variable.
   struct FragmentInfo {
     uint64_t SizeInBits;
     uint64_t OffsetInBits;
   };
 

llvm/lib/BinaryFormat/Dwarf.cpp

#include "llvm/BinaryFormat/Dwarf.def"
   case DW_OP_LLVM_convert:
     return "DW_OP_LLVM_convert";
   case DW_OP_LLVM_fragment:
     return "DW_OP_LLVM_fragment";
   case DW_OP_LLVM_tag_offset:
     return "DW_OP_LLVM_tag_offset";
   case DW_OP_LLVM_entry_value:
     return "DW_OP_LLVM_entry_value";
+  case DW_OP_LLVM_arg0:
+    return "DW_OP_LLVM_arg0";
+  case DW_OP_LLVM_arg1:
+    return "DW_OP_LLVM_arg1";
+  case DW_OP_LLVM_arg2:
+    return "DW_OP_LLVM_arg2";
+  case DW_OP_LLVM_arg3:
+    return "DW_OP_LLVM_arg3";
+  case DW_OP_LLVM_arg4:
+    return "DW_OP_LLVM_arg4";
+  case DW_OP_LLVM_arg5:
+    return "DW_OP_LLVM_arg5";
+  case DW_OP_LLVM_arg6:
+    return "DW_OP_LLVM_arg6";
+  case DW_OP_LLVM_arg7:
+    return "DW_OP_LLVM_arg7";
   }
 }
 
 unsigned llvm::dwarf::getOperationEncoding(StringRef OperationEncodingString) {
   return StringSwitch<unsigned>(OperationEncodingString)
 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR)                                \
   .Case("DW_OP_" #NAME, DW_OP_##NAME)
 #include "llvm/BinaryFormat/Dwarf.def"
       .Case("DW_OP_LLVM_convert", DW_OP_LLVM_convert)
       .Case("DW_OP_LLVM_fragment", DW_OP_LLVM_fragment)
       .Case("DW_OP_LLVM_tag_offset", DW_OP_LLVM_tag_offset)
       .Case("DW_OP_LLVM_entry_value", DW_OP_LLVM_entry_value)
+      .Case("DW_OP_LLVM_arg0", DW_OP_LLVM_arg0)
+      .Case("DW_OP_LLVM_arg1", DW_OP_LLVM_arg1)
+      .Case("DW_OP_LLVM_arg2", DW_OP_LLVM_arg2)
+      .Case("DW_OP_LLVM_arg3", DW_OP_LLVM_arg3)
+      .Case("DW_OP_LLVM_arg4", DW_OP_LLVM_arg4)
+      .Case("DW_OP_LLVM_arg5", DW_OP_LLVM_arg5)
+      .Case("DW_OP_LLVM_arg6", DW_OP_LLVM_arg6)
+      .Case("DW_OP_LLVM_arg7", DW_OP_LLVM_arg7)
       .Default(0);
 }
 
 unsigned llvm::dwarf::OperationVersion(dwarf::LocationAtom Op) {
   switch (Op) {
   default:
     return 0;
 #define HANDLE_DW_OP(ID, NAME, VERSION, VENDOR)                                \

llvm/lib/Bitcode/Reader/MetadataLoader.cpp

void upgradeCUVariables() {
     // Upgrade list of variables attached to the CUs.
     if (NamedMDNode *CUNodes = TheModule.getNamedMetadata("llvm.dbg.cu"))
       for (unsigned I = 0, E = CUNodes->getNumOperands(); I != E; ++I) {
         auto *CU = cast<DICompileUnit>(CUNodes->getOperand(I));
         if (auto *GVs = dyn_cast_or_null<MDTuple>(CU->getRawGlobalVariables()))
           for (unsigned I = 0; I < GVs->getNumOperands(); I++)
             if (auto *GV =
                     dyn_cast_or_null<DIGlobalVariable>(GVs->getOperand(I))) {
-              auto *DGVE = DIGlobalVariableExpression::getDistinct(
-                  Context, GV, DIExpression::get(Context, {}));
+              auto *Expr =
+                  DIExpression::get(Context, {llvm::dwarf::DW_OP_LLVM_arg0});
+              auto *DGVE =
+                  DIGlobalVariableExpression::getDistinct(Context, GV, Expr);
               GVs->replaceOperandWith(I, DGVE);
             }
       }
 
     // Upgrade variables attached to globals.
     for (auto &GV : TheModule.globals()) {
       SmallVector<MDNode *, 1> MDs;
       GV.getMetadata(LLVMContext::MD_dbg, MDs);
void upgradeDeclareExpressions(Function &F) {
 
     for (auto &BB : F)
       for (auto &I : BB)
         if (auto *DDI = dyn_cast<DbgDeclareInst>(&I))
           if (auto *DIExpr = DDI->getExpression())
             if (DIExpr->startsWithDeref() &&
                 dyn_cast_or_null<Argument>(DDI->getAddress())) {
               SmallVector<uint64_t, 8> Ops;
-              Ops.append(std::next(DIExpr->elements_begin()),
+              Ops.append(std::next(DIExpr->elements_begin(), 2),
                          DIExpr->elements_end());
               auto *E = DIExpression::get(Context, Ops);
               DDI->setOperand(2, MetadataAsValue::get(Context, E));
             }
   }
 
   /// Upgrade the expression from previous versions.
   Error upgradeDIExpression(uint64_t FromVersion,
case 2: {
         }
 
         // Continue with remaining elements.
         SubExpr = SubExpr.slice(HistoricSize);
       }
       Expr = MutableArrayRef<uint64_t>(Buffer);
       LLVM_FALLTHROUGH;
     }
-    case 3:
+    case 3: {
+      if (Expr.size() == 0) {
+        Buffer.push_back(dwarf::DW_OP_LLVM_arg0);
+      } else if (Expr[0] == dwarf::DW_OP_deref) {
+        Buffer.insert(Buffer.begin(), dwarf::DW_OP_LLVM_arg0);
+      } else if (Expr.size() >= 3) {
+        switch (Expr[2]) {
+        case dwarf::DW_OP_mul:
+        case dwarf::DW_OP_div:
+        case dwarf::DW_OP_mod:
+        case dwarf::DW_OP_or:
+        case dwarf::DW_OP_and:
+        case dwarf::DW_OP_xor:
+        case dwarf::DW_OP_shl:
+        case dwarf::DW_OP_shr:
+        case dwarf::DW_OP_shra:
+          Buffer.insert(Buffer.begin(), dwarf::DW_OP_LLVM_arg0);
+          break;
+        }
+      }
+      Expr = MutableArrayRef<uint64_t>(Buffer);
+      LLVM_FALLTHROUGH;
+    }
+    case 4:
       // Up-to-date!
       break;
     }
 
     return Error::success();
   }
 
   void upgradeDebugInfo() {
if (Version == 2) {
           (Context, getMDOrNull(Record[1]), getMDString(Record[2]),
            getMDString(Record[3]), getMDOrNull(Record[4]), Record[5],
            getDITypeRefOrNull(Record[6]), Record[7], Record[8],
            getMDOrNull(Record[10]), nullptr, AlignInBits));
 
       DIGlobalVariableExpression *DGVE = nullptr;
       if (Attach || Expr)
         DGVE = DIGlobalVariableExpression::getDistinct(
-            Context, DGV, Expr ? Expr : DIExpression::get(Context, {}));
+            Context, DGV,
+            Expr ? Expr
+                 : DIExpression::get(Context, {llvm::dwarf::DW_OP_LLVM_arg0}));
       if (Attach)
         Attach->addDebugInfo(DGVE);
 
       auto *MDNode = Expr ? cast<Metadata>(DGVE) : cast<Metadata>(DGV);
       MetadataList.assignValue(MDNode, NextMetadataNo);
       NextMetadataNo++;
     } else
       return error("Invalid record");

llvm/lib/Bitcode/Writer/BitcodeWriter.cpp

void ModuleBitcodeWriter::writeDILabel(
   Stream.EmitRecord(bitc::METADATA_LABEL, Record, Abbrev);
   Record.clear();
 }
 
 void ModuleBitcodeWriter::writeDIExpression(const DIExpression *N,
                                             SmallVectorImpl<uint64_t> &Record,
                                             unsigned Abbrev) {
   Record.reserve(N->getElements().size() + 1);
-  const uint64_t Version = 3 << 1;
+  const uint64_t Version = 4 << 1;
   Record.push_back((uint64_t)N->isDistinct() | Version);
   Record.append(N->elements_begin(), N->elements_end());
 
   Stream.EmitRecord(bitc::METADATA_EXPRESSION, Record, Abbrev);
   Record.clear();
 }
 
 void ModuleBitcodeWriter::writeDIGlobalVariableExpression(

llvm/lib/CodeGen/AsmPrinter/DwarfExpression.cpp

while (ExprCursor) {
     uint64_t OpNum = Op->getOp();
 
     if (OpNum >= dwarf::DW_OP_reg0 && OpNum <= dwarf::DW_OP_reg31) {
       emitOp(OpNum);
       continue;
     } else if (OpNum >= dwarf::DW_OP_breg0 && OpNum <= dwarf::DW_OP_breg31) {
       addBReg(OpNum - dwarf::DW_OP_breg0, Op->getArg(0));
       continue;
-    }
+    } else if (OpNum >= dwarf::DW_OP_LLVM_arg0 &&
+               OpNum <= dwarf::DW_OP_LLVM_arg7)
+      continue;
 
     switch (OpNum) {
     case dwarf::DW_OP_LLVM_fragment: {
       unsigned SizeInBits = Op->getArg(1);
       unsigned FragmentOffset = Op->getArg(0);
       // The fragment offset must have already been adjusted by emitting an
       // empty DW_OP_piece / DW_OP_bit_piece before we emitted the base
       // location.

llvm/lib/IR/DIBuilder.cpp

DIGlobalVariableExpression *DIBuilder::createGlobalVariableExpression(
     bool isDefined, DIExpression *Expr,
     MDNode *Decl, MDTuple *TemplateParams, uint32_t AlignInBits) {
   checkGlobalVariableScope(Context);
 
   auto *GV = DIGlobalVariable::getDistinct(
       VMContext, cast_or_null<DIScope>(Context), Name, LinkageName, F,
       LineNumber, Ty, IsLocalToUnit, isDefined, cast_or_null<DIDerivedType>(Decl),
       TemplateParams, AlignInBits);
-  if (!Expr)
+  if (!Expr) {
     Expr = createExpression();
+    Expr = DIExpression::append(Expr, llvm::dwarf::DW_OP_LLVM_arg0);
+  }
   auto *N = DIGlobalVariableExpression::get(VMContext, GV, Expr);
   AllGVs.push_back(N);
   return N;
 }
 
 DIGlobalVariable *DIBuilder::createTempGlobalVariableFwdDecl(
     DIScope *Context, StringRef Name, StringRef LinkageName, DIFile *F,
     unsigned LineNumber, DIType *Ty, bool IsLocalToUnit, MDNode *Decl,

llvm/lib/IR/DebugInfoMetadata.cpp

 bool DIExpression::isValid() const {
   for (auto I = expr_op_begin(), E = expr_op_end(); I != E; ++I) {
     // Check that there's space for the operand.
     if (I->get() + I->getSize() > E->get())
       return false;
 
     uint64_t Op = I->getOp();
     if ((Op >= dwarf::DW_OP_reg0 && Op <= dwarf::DW_OP_reg31) ||
-        (Op >= dwarf::DW_OP_breg0 && Op <= dwarf::DW_OP_breg31))
+        (Op >= dwarf::DW_OP_breg0 && Op <= dwarf::DW_OP_breg31) ||
+        (Op >= dwarf::DW_OP_LLVM_arg0 && Op <= dwarf::DW_OP_LLVM_arg7))
       return true;
 
     // Check that the operand is valid.
     switch (Op) {
     default:
       return false;
     case dwarf::DW_OP_LLVM_fragment:
       // A fragment operator must appear at the end.
void DIExpression::appendOffset(SmallVectorImpl<uint64_t> &Ops,
   } else if (Offset < 0) {
     Ops.push_back(dwarf::DW_OP_constu);
     Ops.push_back(-Offset);
     Ops.push_back(dwarf::DW_OP_minus);
   }
 }
 
 bool DIExpression::extractIfOffset(int64_t &Offset) const {
-  if (getNumElements() == 0) {
+  unsigned NumElements = getNumElements();
+  unsigned Index = 0;
+
+  if (NumElements > 0 && Elements[0] == dwarf::DW_OP_LLVM_arg0) {
+    Index = 1;
+    NumElements --;
+  }
+
+  if (NumElements == 0) {
     Offset = 0;
     return true;
   }
 
-  if (getNumElements() == 2 && Elements[0] == dwarf::DW_OP_plus_uconst) {
-    Offset = Elements[1];
+  if (NumElements == 2 && Elements[Index] == dwarf::DW_OP_plus_uconst) {
+    Offset = Elements[Index + 1];
     return true;
   }
 
-  if (getNumElements() == 3 && Elements[0] == dwarf::DW_OP_constu) {
-    if (Elements[2] == dwarf::DW_OP_plus) {
-      Offset = Elements[1];
+  if (NumElements == 3 && Elements[Index] == dwarf::DW_OP_constu) {
+    if (Elements[Index + 2] == dwarf::DW_OP_plus) {
+      Offset = Elements[Index + 1];
       return true;
     }
-    if (Elements[2] == dwarf::DW_OP_minus) {
-      Offset = -Elements[1];
+    if (Elements[Index + 2] == dwarf::DW_OP_minus) {
+      Offset = -Elements[Index + 1];
       return true;
     }
   }
 
   return false;
 }
 
 const DIExpression *DIExpression::extractAddressClass(const DIExpression *Expr,

 }
 
 DIExpression *DIExpression::prependOpcodes(const DIExpression *Expr,
                                            SmallVectorImpl<uint64_t> &Ops,
                                            bool StackValue,
                                            bool EntryValue) {
   assert(Expr && "Can't prepend ops to this expression");
 
+  expr_op_iterator Itr = Expr->expr_op_begin();
+  expr_op_iterator EndItr = Expr->expr_op_end();
   if (EntryValue) {
     Ops.push_back(dwarf::DW_OP_LLVM_entry_value);
     // Add size info needed for entry value expression.
     // Add plus one for target register operand.
     Ops.push_back(Expr->getNumElements() + 1);
   }
 
   // If there are no ops to prepend, do not even add the DW_OP_stack_value.
   if (Ops.empty())
     StackValue = false;
-  for (auto Op : Expr->expr_ops()) {
+  else if (Itr != EndItr && Itr->getOp() == dwarf::DW_OP_LLVM_arg0)
+    Itr++;
+    
+  for (; Itr != EndItr; Itr++) {
     // A DW_OP_stack_value comes at the end, but before a DW_OP_LLVM_fragment.
     if (StackValue) {
-      if (Op.getOp() == dwarf::DW_OP_stack_value)
+      if (Itr->getOp() == dwarf::DW_OP_stack_value)
         StackValue = false;
-      else if (Op.getOp() == dwarf::DW_OP_LLVM_fragment) {
+      else if (Itr->getOp() == dwarf::DW_OP_LLVM_fragment) {
         Ops.push_back(dwarf::DW_OP_stack_value);
         StackValue = false;
       }
     }
-    Op.appendToVector(Ops);
+    Itr->appendToVector(Ops);
   }
   if (StackValue)
     Ops.push_back(dwarf::DW_OP_stack_value);
   return DIExpression::get(Expr->getContext(), Ops);
 }
 
 DIExpression *DIExpression::append(const DIExpression *Expr,
                                    ArrayRef<uint64_t> Ops) {
if (NeedsStackValue)
     NewOps.push_back(dwarf::DW_OP_stack_value);
   return DIExpression::append(Expr, NewOps);
 }
 
 Optional<DIExpression *> DIExpression::createFragmentExpression(
     const DIExpression *Expr, unsigned OffsetInBits, unsigned SizeInBits) {
   SmallVector<uint64_t, 8> Ops;
   // Copy over the expression, but leave off any trailing DW_OP_LLVM_fragment.
-  if (Expr) {
+  if (Expr && !(Expr->getNumElements() == 1 &&
+                Expr->getElement(0) == dwarf::DW_OP_LLVM_arg0)) {
+
     for (auto Op : Expr->expr_ops()) {
       switch (Op.getOp()) {
       default: break;
       case dwarf::DW_OP_shr:
       case dwarf::DW_OP_shra:
       case dwarf::DW_OP_shl:
       case dwarf::DW_OP_plus:
       case dwarf::DW_OP_plus_uconst:

llvm/lib/Transforms/Utils/Local.cpp

while (!WorkList.empty()) {
         } else if (LoadInst *LI = dyn_cast<LoadInst>(U)) {
           ConvertDebugDeclareToDebugValue(DDI, LI, DIB);
         } else if (CallInst *CI = dyn_cast<CallInst>(U)) {
           // This is a call by-value or some other instruction that takes a
           // pointer to the variable. Insert a *value* intrinsic that describes
           // the variable by dereferencing the alloca.
           if (!CI->isLifetimeStartOrEnd()) {
             DebugLoc NewLoc = getDebugValueLoc(DDI, nullptr);
-            auto *DerefExpr =
-                DIExpression::append(DDI->getExpression(), dwarf::DW_OP_deref);
+            DIExpression *DerefExpr = DDI->getExpression();
+
+            if (DDI->getExpression()->getNumElements() == 0)
+              DerefExpr = DIExpression::append(DerefExpr,
+                                               dwarf::DW_OP_LLVM_arg0);
+
+            DerefExpr = DIExpression::append(DerefExpr, dwarf::DW_OP_deref);
             DIB.insertDbgValueIntrinsic(AI, DDI->getVariable(), DerefExpr,
                                         NewLoc, CI);
           }
         } else if (BitCastInst *BI = dyn_cast<BitCastInst>(U)) {
           if (BI->getType()->isPointerTy())
             WorkList.push_back(BI);
         }
       }
static void replaceOneDbgValueForAlloca(DbgValueInst *DVI, Value *NewAddress,
   DebugLoc Loc = DVI->getDebugLoc();
   auto *DIVar = DVI->getVariable();
   auto *DIExpr = DVI->getExpression();
   assert(DIVar && "Missing variable");
 
   // This is an alloca-based llvm.dbg.value. The first thing it should do with
   // the alloca pointer is dereference it. Otherwise we don't know how to handle
   // it and give up.
-  if (!DIExpr || DIExpr->getNumElements() < 1 ||
-      DIExpr->getElement(0) != dwarf::DW_OP_deref)
+
+  if (!DIExpr || (DIExpr->getNumElements() == 0) ||
+      !(DIExpr->getElement(0) == dwarf::DW_OP_deref ||
+        (DIExpr->getNumElements() > 1 &&
+         DIExpr->getElement(0) == dwarf::DW_OP_LLVM_arg0 &&
+         DIExpr->getElement(1) == dwarf::DW_OP_deref)))
     return;
 
   // Insert the offset before the first deref.
   // We could just change the offset argument of dbg.value, but it's unsigned...
-  if (Offset)
+  if (Offset) {
+    if (DIExpr->getElement(0) == dwarf::DW_OP_LLVM_arg0) {
+      ArrayRef<uint64_t> NewElem = DIExpr->getElements().drop_front();
+      SmallVector<uint64_t, 8> Ops;
+      Ops.append(NewElem.begin(), NewElem.end());
+      DIExpr = DIExpression::get(DIExpr->getContext(), Ops);
+    }
     DIExpr = DIExpression::prepend(DIExpr, 0, Offset);
+  }
 
   Builder.insertDbgValueIntrinsic(NewAddress, DIVar, DIExpr, Loc, DVI);
   DVI->eraseFromParent();
 }
 
 void llvm::replaceDbgValueForAlloca(AllocaInst *AI, Value *NewAllocaAddress,
                                     DIBuilder &Builder, int Offset) {
   if (auto *L = LocalAsMetadata::getIfExists(AI))
if (auto *GEP = dyn_cast<GetElementPtrInst>(&I)) {
 
     uint64_t Val = ConstInt->getSExtValue();
     switch (BI->getOpcode()) {
     case Instruction::Add:
       return applyOffset(Val);
     case Instruction::Sub:
       return applyOffset(-int64_t(Val));
     case Instruction::Mul:
-      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_mul});
+      return applyOps(
+          {dwarf::DW_OP_LLVM_arg0, dwarf::DW_OP_constu, Val, dwarf::DW_OP_mul});
     case Instruction::SDiv:
-      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_div});
+      return applyOps(
+          {dwarf::DW_OP_LLVM_arg0, dwarf::DW_OP_constu, Val, dwarf::DW_OP_div});
     case Instruction::SRem:
-      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_mod});
+      return applyOps(
+          {dwarf::DW_OP_LLVM_arg0, dwarf::DW_OP_constu, Val, dwarf::DW_OP_mod});
     case Instruction::Or:
-      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_or});
+      return applyOps(
+          {dwarf::DW_OP_LLVM_arg0, dwarf::DW_OP_constu, Val, dwarf::DW_OP_or});
     case Instruction::And:
-      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_and});
+      return applyOps(
+          {dwarf::DW_OP_LLVM_arg0, dwarf::DW_OP_constu, Val, dwarf::DW_OP_and});
     case Instruction::Xor:
-      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_xor});
+      return applyOps(
+          {dwarf::DW_OP_LLVM_arg0, dwarf::DW_OP_constu, Val, dwarf::DW_OP_xor});
     case Instruction::Shl:
-      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_shl});
+      return applyOps(
+          {dwarf::DW_OP_LLVM_arg0, dwarf::DW_OP_constu, Val, dwarf::DW_OP_shl});
     case Instruction::LShr:
-      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_shr});
+      return applyOps(
+          {dwarf::DW_OP_LLVM_arg0, dwarf::DW_OP_constu, Val, dwarf::DW_OP_shr});
     case Instruction::AShr:
-      return applyOps({dwarf::DW_OP_constu, Val, dwarf::DW_OP_shra});
+      return applyOps({dwarf::DW_OP_LLVM_arg0, dwarf::DW_OP_constu, Val,
+                       dwarf::DW_OP_shra});
     default:
       // TODO: Salvage constants from each kind of binop we know about.
       return nullptr;
     }
     // *Not* to do: we should not attempt to salvage load instructions,
     // because the validity and lifetime of a dbg.value containing
     // DW_OP_deref becomes difficult to analyze. See PR40628 for examples.
   }

llvm/test/Bitcode/DIExpression-deref.ll

 ; DW_OP_deref should be moved to the back of the expression.
 ;
 ; CHECK: !DIExpression(DW_OP_plus_uconst, 0, DW_OP_deref, DW_OP_LLVM_fragment, 8, 8)
 !6 = !DIExpression(DW_OP_deref, DW_OP_plus, 0, DW_OP_LLVM_fragment, 8, 8)
 ; CHECK: !DIExpression(DW_OP_plus_uconst, 0, DW_OP_deref)
 !7 = !DIExpression(DW_OP_deref, DW_OP_plus, 0)
 ; CHECK: !DIExpression(DW_OP_plus_uconst, 1, DW_OP_deref)
 !8 = !DIExpression(DW_OP_plus, 1, DW_OP_deref)
-; CHECK: !DIExpression(DW_OP_deref)
+; CHECK: !DIExpression(DW_OP_LLVM_arg0, DW_OP_deref)
 !9 = !DIExpression(DW_OP_deref)
 !10 = !DIGlobalVariableExpression(var: !0, expr: !6)
 !11 = !DIGlobalVariableExpression(var: !0, expr: !7)
 !12 = !DIGlobalVariableExpression(var: !0, expr: !8)
 !13 = !DIGlobalVariableExpression(var: !0, expr: !9)
 !20 = !{i32 2, !"Dwarf Version", i32 4}
 !21 = !{i32 2, !"Debug Info Version", i32 3}

llvm/test/Bitcode/DIGlobalVariableExpression2.ll

 ; RUN: llvm-dis -o - %s.bc | FileCheck %s
 
 ; CHECK: @g = common global i32 0, align 4, !dbg ![[G:[0-9]+]]
-; CHECK-DAG: ![[G]] = distinct !DIGlobalVariableExpression(var: ![[GVAR:[0-9]+]], expr: !DIExpression())
+; CHECK-DAG: ![[G]] = distinct !DIGlobalVariableExpression(var: ![[GVAR:[0-9]+]], expr: !DIExpression(DW_OP_LLVM_arg0))
 ; CHECK-DAG: distinct !DICompileUnit({{.*}}, globals: ![[GLOBS:[0-9]+]]
 ; CHECK-DAG: ![[GLOBS]] = !{![[GEXPR:[0-9]+]]}
-; CHECK-DAG: ![[GEXPR]] = distinct !DIGlobalVariableExpression(var: ![[GVAR]], expr: !DIExpression())
+; CHECK-DAG: ![[GEXPR]] = distinct !DIGlobalVariableExpression(var: ![[GVAR]], expr: !DIExpression(DW_OP_LLVM_arg0))
 ; CHECK-DAG: ![[GVAR]] = !DIGlobalVariable(name: "g",
 
 ; Test the bitcode upgrade for DIGlobalVariable -> DIGlobalVariableExpression.
 
 ; ModuleID = 'a.c'
 target datalayout = "e-m:o-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-apple-macosx10.12.0"
 

llvm/test/Bitcode/upgrade-dbg-value.ll

 ; Test upgrade of dbg.dvalue intrinsics with offsets.
 ;
 ; RUN: llvm-dis < %s.bc | FileCheck %s
 ; RUN: verify-uselistorder < %s.bc
 
 define void @f() !dbg !3 {
 entry:
   ; CHECK-NOT: call void @llvm.dbg.value
-  ; CHECK: call void @llvm.dbg.value(metadata i32 42, metadata !8, metadata !DIExpression())
+  ; CHECK: call void @llvm.dbg.value(metadata i32 42, metadata !8, metadata !DIExpression(DW_OP_LLVM_arg0))
   call void @llvm.dbg.value(metadata i32 42, i64 0, metadata !8, metadata !9), !dbg !10
   ; CHECK-NOT: call void @llvm.dbg.value
   call void @llvm.dbg.value(metadata i32 0, i64 1, metadata !8, metadata !9), !dbg !10
   ret void
 }
 
 ; CHECK: declare void @llvm.dbg.value(metadata, metadata, metadata)
 declare void @llvm.dbg.value(metadata, i64, metadata, metadata)

llvm/test/DebugInfo/Generic/dbg-value-lower-linenos.ll

 ; In the following, the dbg.value created for the store should get the stores
 ; line number, the other dbg.values should be unknown.
 ; CHECK-LABEL: define void @bar
 ;
 ; CHECK:      dbg.value(metadata i32 %map, metadata ![[MAPVAR:[0-9]+]],{{.*}}),
 ; CHECK-SAME:           !dbg ![[UNKNOWN2:[0-9]+]]
 ; CHECK-NEXT: store
 ; CHECK-NEXT: dbg.value(metadata i32* %map.addr, metadata ![[MAPVAR]],
-; CHECK-SAME:           metadata !DIExpression(DW_OP_deref)),
+; CHECK-SAME:           metadata !DIExpression(DW_OP_LLVM_arg0, DW_OP_deref)),
 ; CHECK-SAME:           !dbg ![[UNKNOWN2]]
 ; CHECK-NEXT: call
 ; CHECK-NEXT: load
 ; CHECK-NEXT: dbg.value(metadata i32 %{{[0-9]+}}, metadata ![[MAPVAR]],
 ; CHECK-SAME:           !dbg ![[UNKNOWN2]]
 
 define void @bar(i32 %map) !dbg !20 {
 entry:

llvm/test/Transforms/BDCE/basic.ll

 ; CHECK: ret i16
 }
 
 ; DEBUGIFY-LABEL: @tar9
 define signext i16 @tar9(i32 signext %x) #0 {
 entry:
   %call = tail call signext i32 @foo(i32 signext 5) #0
   %and = and i32 %call, 33554432
-; DEBUGIFY: call void @llvm.dbg.value(metadata i32 %call, metadata {{.*}}, metadata !DIExpression(DW_OP_constu, 33554432, DW_OP_and, DW_OP_stack_value))
+; DEBUGIFY: call void @llvm.dbg.value(metadata i32 %call, metadata {{.*}}, metadata !DIExpression(DW_OP_LLVM_arg0, DW_OP_constu, 33554432, DW_OP_and, DW_OP_stack_value))
   %cast = trunc i32 %call to i16
   ret i16 %cast
 }
 
 attributes #0 = { nounwind readnone }
 attributes #1 = { nounwind }
 

llvm/test/Transforms/InstCombine/debuginfo-variables.ll

 ; CHECK-NEXT:  ret i32 [[sel]]
   %sel = select i1 %cond, i16 3, i16 5
   %cast = zext i16 %sel to i32
   ret i32 %cast
 }
 
 define void @test_or(i64 %A) {
 ; CHECK-LABEL: @test_or(
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 256, DW_OP_or, DW_OP_stack_value))
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_LLVM_arg0, DW_OP_constu, 256, DW_OP_or, DW_OP_stack_value))
   %1 = or i64 %A, 256
   ret void
 }
 
 define void @test_xor(i32 %A) {
 ; CHECK-LABEL: @test_xor(
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i32 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 1, DW_OP_xor, DW_OP_stack_value))
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i32 %A, {{.*}}, metadata !DIExpression(DW_OP_LLVM_arg0, DW_OP_constu, 1, DW_OP_xor, DW_OP_stack_value))
   %1 = xor i32 %A, 1
   ret void
 }
 
 define void @test_sub_neg(i64 %A) {
 ; CHECK-LABEL: @test_sub_neg(
 ; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_plus_uconst, 1, DW_OP_stack_value))
   %1 = sub i64 %A, -1
   ret void
 }
 
 define void @test_sub_pos(i64 %A) {
 ; CHECK-LABEL: @test_sub_pos(
 ; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 1, DW_OP_minus, DW_OP_stack_value))
   %1 = sub i64 %A, 1
   ret void
 }
 
 define void @test_shl(i64 %A) {
 ; CHECK-LABEL: @test_shl(
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 7, DW_OP_shl, DW_OP_stack_value))
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_LLVM_arg0, DW_OP_constu, 7, DW_OP_shl, DW_OP_stack_value))
   %1 = shl i64 %A, 7
   ret void
 }
 
 define void @test_lshr(i64 %A) {
 ; CHECK-LABEL: @test_lshr(
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 7, DW_OP_shr, DW_OP_stack_value))
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_LLVM_arg0, DW_OP_constu, 7, DW_OP_shr, DW_OP_stack_value))
   %1 = lshr i64 %A, 7
   ret void
 }
 
 define void @test_ashr(i64 %A) {
 ; CHECK-LABEL: @test_ashr(
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 7, DW_OP_shra, DW_OP_stack_value))
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_LLVM_arg0, DW_OP_constu, 7, DW_OP_shra, DW_OP_stack_value))
   %1 = ashr i64 %A, 7
   ret void
 }
 
 define void @test_mul(i64 %A) {
 ; CHECK-LABEL: @test_mul(
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 7, DW_OP_mul, DW_OP_stack_value))
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_LLVM_arg0, DW_OP_constu, 7, DW_OP_mul, DW_OP_stack_value))
   %1 = mul i64 %A, 7
   ret void
 }
 
 define void @test_sdiv(i64 %A) {
 ; CHECK-LABEL: @test_sdiv(
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 7, DW_OP_div, DW_OP_stack_value))
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_LLVM_arg0, DW_OP_constu, 7, DW_OP_div, DW_OP_stack_value))
   %1 = sdiv i64 %A, 7
   ret void
 }
 
 define void @test_srem(i64 %A) {
 ; CHECK-LABEL: @test_srem(
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 7, DW_OP_mod, DW_OP_stack_value))
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_LLVM_arg0, DW_OP_constu, 7, DW_OP_mod, DW_OP_stack_value))
   %1 = srem i64 %A, 7
   ret void
 }
 
 define void @test_ptrtoint(i64* %P) {
 ; CHECK-LABEL: @test_ptrtoint
 ; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64* %P, {{.*}}, metadata !DIExpression())
   %1 = ptrtoint i64* %P to i64
   ret void
 }
 
 define void @test_and(i64 %A) {
 ; CHECK-LABEL: @test_and(
-; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_constu, 256, DW_OP_and, DW_OP_stack_value))
+; CHECK-NEXT:  call void @llvm.dbg.value(metadata i64 %A, {{.*}}, metadata !DIExpression(DW_OP_LLVM_arg0, DW_OP_constu, 256, DW_OP_and, DW_OP_stack_value))
   %1 = and i64 %A, 256
   ret void
 }

llvm/test/Transforms/InstCombine/lower-dbg-declare.ll

 ; CHECK: dbg.value(metadata i32 %1, metadata [[METADATA_IDX1]], metadata !DIExpression())
 ; CHECK-NEXT: call zeroext i1 @_ZL5emptyi
   %1 = load i32, i32* %d1, align 4, !dbg !22
   %call = call zeroext i1 @_ZL5emptyi(i32 %1), !dbg !22
   %lnot = xor i1 %call, true, !dbg !22
   br i1 %lnot, label %while.body, label %while.end, !dbg !22
 
 while.body:                                       ; preds = %while.cond
-; CHECK: dbg.value(metadata i32* %d1, metadata [[METADATA_IDX1]], metadata !DIExpression(DW_OP_deref))
+; CHECK: dbg.value(metadata i32* %d1, metadata [[METADATA_IDX1]], metadata !DIExpression(DW_OP_LLVM_arg0, DW_OP_deref))
 ; CHECK-NEXT: call void @_ZL6escapeRi
   call void @_ZL6escapeRi(i32* dereferenceable(4) %d1), !dbg !23
   br label %while.cond, !dbg !22, !llvm.loop !24
 
 while.end:                                        ; preds = %while.cond
   %2 = bitcast i32* %d1 to i8*, !dbg !25
   call void @llvm.lifetime.end.p0i8(i64 4, i8* %2) #4, !dbg !25
   ret i32 0, !dbg !26

llvm/test/Transforms/Util/dbg-call-bitcast.ll

 ; RUN: opt -instcombine -S %s | FileCheck %s
 
 define dso_local void @_Z1fv() {
   %1 = alloca i32, align 4
   %2 = bitcast i32* %1 to i8*
   call void @llvm.lifetime.start.p0i8(i64 4, i8* nonnull %2)
   call void @llvm.dbg.declare(metadata i32* %1, metadata !16, metadata !DIExpression()), !dbg !19
 ; CHECK: %[[A:.*]] = alloca i32, align 4
-; CHECK: call void @llvm.dbg.value(metadata i32* %[[A]], {{.*}}, metadata !DIExpression(DW_OP_deref)
+; CHECK: call void @llvm.dbg.value(metadata i32* %[[A]], {{.*}}, metadata !DIExpression(DW_OP_LLVM_arg0, DW_OP_deref)
 ; CHECK: call void @_Z1gPv
   call void @_Z1gPv(i8* nonnull %2)
   %3 = bitcast i32* %1 to i8*
-; CHECK: call void @llvm.dbg.value(metadata i32* %[[A]], {{.*}}, metadata !DIExpression(DW_OP_deref)
+; CHECK: call void @llvm.dbg.value(metadata i32* %[[A]], {{.*}}, metadata !DIExpression(DW_OP_LLVM_arg0, DW_OP_deref)
 ; CHECK: call void @_Z1gPv
   call void @_Z1gPv(i8* nonnull %3)
   call void @llvm.lifetime.end.p0i8(i64 4, i8* nonnull %2)
   ret void, !dbg !21
 }
 
 declare void @llvm.lifetime.start.p0i8(i64 immarg, i8* nocapture)
 declare void @llvm.dbg.declare(metadata, metadata, metadata)