thr3ads.net - llvm dev - [llvm-dev] CloneFunctionInto produces invalid debug info [Jun 2017]

If this information is useful, please help other people find it:
Share via:

Matthias Bernad via llvm-dev

2017-Jun-15 15:31 UTC

[llvm-dev] CloneFunctionInto produces invalid debug info

Hi!

We are currently working on a science project and implemented a
FunctionPass that clones a function (more precisely a constructor of a
struct/class) and adds a parameter.

First, we create a new function with a new function type, which includes
the newly added parameter:

Function *NF = Function::Create(NewFTy, F.getLinkage(), F.getName() +
"Cloned", F.getParent());


and after setting up the ValueToValueMapTy, we use the CloneFunctionInto
method to clone the function body

CloneFunctionInto(NF, &F, Map, true, Returns, "Cloned");


The code seems to work as intended, but when we try to emit debug symbols
(clang -g flag) the pass fails with following message:

"All DICompileUnits must be listed in llvm.dbg.cu"


Nevertheless, we can dump the Module and therefore can print out the
annotated IR.

This is what the function to be cloned looks like:

; Function Attrs: noinline nounwind uwtable
define linkonce_odr void @_ZN12MyFunnyClassC2Ev(%struct.MyFunnyClass*
%this) unnamed_addr #4 comdat align 2 !dbg !46 {
entry:
  %this.addr = alloca %struct.MyFunnyClass*, align 8
  store %struct.MyFunnyClass* %this, %struct.MyFunnyClass** %this.addr,
align 8
  call void @llvm.dbg.declare(metadata %struct.MyFunnyClass** %this.addr,
metadata !49, metadata !31), !dbg !50

... rest of function code

}

!46 = distinct !DISubprogram(name: "MyFunnyClass", linkageName:
"_ZN12MyFunnyClassC2Ev", scope: !15, file: !1, line: 1, type: !25,
isLocal:
false, isDefinition: true, scopeLine: 1, flags: DIFlagArtificial |
DIFlagPrototyped, isOptimized: false, unit: !0, declaration: !47,
variables: !2)


and the cloned function:

; Function Attrs: noinline nounwind uwtable
define linkonce_odr void @_ZN12MyFunnyClassC2EvCloned(%struct.MyFunnyClass*
%this, { [6 x i8*] }* %newparam) unnamed_addr #4 align 2 !dbg !73 {
entry:
  %this.addr = alloca %struct.MyFunnyClass*, align 8
  store %struct.MyFunnyClass* %this, %struct.MyFunnyClass** %this.addr,
align 8
  call void @llvm.dbg.declare(metadata %struct.MyFunnyClass** %this.addr,
metadata !89, metadata !31), !dbg !91

... rest of function code

}

!73 = distinct !DISubprogram(name: "MyFunnyClass", linkageName:
"_ZN12MyFunnyClassC2Ev", scope: !74, file: !1, line: 1, type: !81,
isLocal:
false, isDefinition: true, scopeLine: 1, flags: DIFlagArtificial |
DIFlagPrototyped, isOptimized: false, unit: !87, declaration: !88,
variables: !2)

So the cloned function gets annotated with debug symbols as expected. We
noticed that the linkageName of the cloned function is the same as the
original one's. Could that cause the error mentioned above? If so, how can
we fix that error?

Best regards and thanks in advance,
Matthias
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20170615/a724dc14/attachment.html>

Sergei Larin via llvm-dev

2017-Jun-15 16:25 UTC

head link

[llvm-dev] CloneFunctionInto produces invalid debug info

We are seeing the same. Cloning is failing to add newly created  DICompileUnit
to llvm.dbg.cu in the module resulting in verifier assert.

 

Sergei

 

From: llvm-dev [mailto:llvm-dev-bounces at lists.llvm.org] On Behalf Of Matthias
Bernad via llvm-dev
Sent: Thursday, June 15, 2017 10:32 AM
To: llvm-dev at lists.llvm.org
Subject: [llvm-dev] CloneFunctionInto produces invalid debug info

 

Hi!

 

We are currently working on a science project and implemented a FunctionPass
that clones a function (more precisely a constructor of a struct/class) and adds
a parameter.

 

First, we create a new function with a new function type, which includes the
newly added parameter:

 

Function *NF = Function::Create(NewFTy, F.getLinkage(), F.getName() +
"Cloned", F.getParent());

 

and after setting up the ValueToValueMapTy, we use the CloneFunctionInto method
to clone the function body

 

CloneFunctionInto(NF, &F, Map, true, Returns, "Cloned");

 

The code seems to work as intended, but when we try to emit debug symbols (clang
-g flag) the pass fails with following message:

"All DICompileUnits must be listed in llvm.dbg.cu
<http://llvm.dbg.cu> "

 

Nevertheless, we can dump the Module and therefore can print out the annotated
IR.

 

This is what the function to be cloned looks like:

 

; Function Attrs: noinline nounwind uwtable

define linkonce_odr void @_ZN12MyFunnyClassC2Ev(%struct.MyFunnyClass* %this)
unnamed_addr #4 comdat align 2 !dbg !46 {

entry:

  %this.addr = alloca %struct.MyFunnyClass*, align 8

  store %struct.MyFunnyClass* %this, %struct.MyFunnyClass** %this.addr, align 8

  call void @llvm.dbg.declare(metadata %struct.MyFunnyClass** %this.addr,
metadata !49, metadata !31), !dbg !50

... rest of function code

}

 

!46 = distinct !DISubprogram(name: "MyFunnyClass", linkageName:
"_ZN12MyFunnyClassC2Ev", scope: !15, file: !1, line: 1, type: !25,
isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagArtificial |
DIFlagPrototyped, isOptimized: false, unit: !0, declaration: !47, variables: !2)

 

and the cloned function:

 

; Function Attrs: noinline nounwind uwtable

define linkonce_odr void @_ZN12MyFunnyClassC2EvCloned(%struct.MyFunnyClass*
%this, { [6 x i8*] }* %newparam) unnamed_addr #4 align 2 !dbg !73 {

entry:

  %this.addr = alloca %struct.MyFunnyClass*, align 8

  store %struct.MyFunnyClass* %this, %struct.MyFunnyClass** %this.addr, align 8

  call void @llvm.dbg.declare(metadata %struct.MyFunnyClass** %this.addr,
metadata !89, metadata !31), !dbg !91

... rest of function code

}

 

!73 = distinct !DISubprogram(name: "MyFunnyClass", linkageName:
"_ZN12MyFunnyClassC2Ev", scope: !74, file: !1, line: 1, type: !81,
isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagArtificial |
DIFlagPrototyped, isOptimized: false, unit: !87, declaration: !88, variables:
!2)

 

So the cloned function gets annotated with debug symbols as expected. We noticed
that the linkageName of the cloned function is the same as the original
one's. Could that cause the error mentioned above? If so, how can we fix
that error?

 

Best regards and thanks in advance,

Matthias

-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20170615/1d40c5e8/attachment.html>

David Blaikie via llvm-dev

2017-Jun-15 18:21 UTC

head link

[llvm-dev] CloneFunctionInto produces invalid debug info

+Adrian

On Thu, Jun 15, 2017 at 9:25 AM Sergei Larin via llvm-dev <
llvm-dev at lists.llvm.org> wrote:
> We are seeing the same. Cloning is failing to add newly created
> DICompileUnit to llvm.dbg.cu in the module resulting in verifier assert.
>
>
>
> Sergei
>
>
>
> *From:* llvm-dev [mailto:llvm-dev-bounces at lists.llvm.org] *On Behalf Of
*Matthias
> Bernad via llvm-dev
> *Sent:* Thursday, June 15, 2017 10:32 AM
> *To:* llvm-dev at lists.llvm.org
> *Subject:* [llvm-dev] CloneFunctionInto produces invalid debug info
>
>
>
> Hi!
>
>
>
> We are currently working on a science project and implemented a
> FunctionPass that clones a function (more precisely a constructor of a
> struct/class) and adds a parameter.
>
>
>
> First, we create a new function with a new function type, which includes
> the newly added parameter:
>
>
>
> Function *NF = Function::Create(NewFTy, F.getLinkage(), F.getName() +
> "Cloned", F.getParent());
>
>
>
> and after setting up the ValueToValueMapTy, we use the CloneFunctionInto
> method to clone the function body
>
>
>
> CloneFunctionInto(NF, &F, Map, true, Returns, "Cloned");
>
>
>
> The code seems to work as intended, but when we try to emit debug symbols
> (clang -g flag) the pass fails with following message:
>
> "All DICompileUnits must be listed in llvm.dbg.cu"
>
>
>
> Nevertheless, we can dump the Module and therefore can print out the
> annotated IR.
>
>
>
> This is what the function to be cloned looks like:
>
>
>
> ; Function Attrs: noinline nounwind uwtable
>
> define linkonce_odr void @_ZN12MyFunnyClassC2Ev(%struct.MyFunnyClass*
> %this) unnamed_addr #4 comdat align 2 !dbg !46 {
>
> entry:
>
>   %this.addr = alloca %struct.MyFunnyClass*, align 8
>
>   store %struct.MyFunnyClass* %this, %struct.MyFunnyClass** %this.addr,
> align 8
>
>   call void @llvm.dbg.declare(metadata %struct.MyFunnyClass** %this.addr,
> metadata !49, metadata !31), !dbg !50
>
> ... rest of function code
>
> }
>
>
>
> !46 = distinct !DISubprogram(name: "MyFunnyClass", linkageName:
> "_ZN12MyFunnyClassC2Ev", scope: !15, file: !1, line: 1, type:
!25, isLocal:
> false, isDefinition: true, scopeLine: 1, flags: DIFlagArtificial |
> DIFlagPrototyped, isOptimized: false, unit: !0, declaration: !47,
> variables: !2)
>
>
>
> and the cloned function:
>
>
>
> ; Function Attrs: noinline nounwind uwtable
>
> define linkonce_odr void
> @_ZN12MyFunnyClassC2EvCloned(%struct.MyFunnyClass* %this, { [6 x i8*] }*
> %newparam) unnamed_addr #4 align 2 !dbg !73 {
>
> entry:
>
>   %this.addr = alloca %struct.MyFunnyClass*, align 8
>
>   store %struct.MyFunnyClass* %this, %struct.MyFunnyClass** %this.addr,
> align 8
>
>   call void @llvm.dbg.declare(metadata %struct.MyFunnyClass** %this.addr,
> metadata !89, metadata !31), !dbg !91
>
> ... rest of function code
>
> }
>
>
>
> !73 = distinct !DISubprogram(name: "MyFunnyClass", linkageName:
> "_ZN12MyFunnyClassC2Ev", scope: !74, file: !1, line: 1, type:
!81, isLocal:
> false, isDefinition: true, scopeLine: 1, flags: DIFlagArtificial |
> DIFlagPrototyped, isOptimized: false, unit: !87, declaration: !88,
> variables: !2)
>
>
>
> So the cloned function gets annotated with debug symbols as expected. We
> noticed that the linkageName of the cloned function is the same as the
> original one's. Could that cause the error mentioned above? If so, how
can
> we fix that error?
>
>
>
> Best regards and thanks in advance,
>
> Matthias
> _______________________________________________
> LLVM Developers mailing list
> llvm-dev at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-dev
>-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20170615/4d34091f/attachment.html>

Adrian Prantl via llvm-dev

2017-Jun-15 18:23 UTC

head link

[llvm-dev] CloneFunctionInto produces invalid debug info

If you are doing this work based off LLVM trunk, could you send me your patch to
reproduce the problem?

-- adrian> On Jun 15, 2017, at 8:31 AM, Matthias Bernad via llvm-dev <llvm-dev at
lists.llvm.org> wrote:
> 
> Hi!
> 
> We are currently working on a science project and implemented a
FunctionPass that clones a function (more precisely a constructor of a
struct/class) and adds a parameter.
> 
> First, we create a new function with a new function type, which includes
the newly added parameter:
> 
> Function *NF = Function::Create(NewFTy, F.getLinkage(), F.getName() +
"Cloned", F.getParent());
> 
> and after setting up the ValueToValueMapTy, we use the CloneFunctionInto
method to clone the function body
> 
> CloneFunctionInto(NF, &F, Map, true, Returns, "Cloned");
> 
> The code seems to work as intended, but when we try to emit debug symbols
(clang -g flag) the pass fails with following message:
> 
> "All DICompileUnits must be listed in llvm.dbg.cu
<http://llvm.dbg.cu/>"
> 
> Nevertheless, we can dump the Module and therefore can print out the
annotated IR.
> 
> This is what the function to be cloned looks like:
> 
> ; Function Attrs: noinline nounwind uwtable
> define linkonce_odr void @_ZN12MyFunnyClassC2Ev(%struct.MyFunnyClass*
%this) unnamed_addr #4 comdat align 2 !dbg !46 {
> entry:
>   %this.addr = alloca %struct.MyFunnyClass*, align 8
>   store %struct.MyFunnyClass* %this, %struct.MyFunnyClass** %this.addr,
align 8
>   call void @llvm.dbg.declare(metadata %struct.MyFunnyClass** %this.addr,
metadata !49, metadata !31), !dbg !50
> ... rest of function code
> }
> 
> !46 = distinct !DISubprogram(name: "MyFunnyClass", linkageName:
"_ZN12MyFunnyClassC2Ev", scope: !15, file: !1, line: 1, type: !25,
isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagArtificial |
DIFlagPrototyped, isOptimized: false, unit: !0, declaration: !47, variables: !2)
> 
> and the cloned function:
> 
> ; Function Attrs: noinline nounwind uwtable
> define linkonce_odr void @_ZN12MyFunnyClassC2EvCloned(%struct.MyFunnyClass*
%this, { [6 x i8*] }* %newparam) unnamed_addr #4 align 2 !dbg !73 {
> entry:
>   %this.addr = alloca %struct.MyFunnyClass*, align 8
>   store %struct.MyFunnyClass* %this, %struct.MyFunnyClass** %this.addr,
align 8
>   call void @llvm.dbg.declare(metadata %struct.MyFunnyClass** %this.addr,
metadata !89, metadata !31), !dbg !91
> ... rest of function code
> }
> 
> !73 = distinct !DISubprogram(name: "MyFunnyClass", linkageName:
"_ZN12MyFunnyClassC2Ev", scope: !74, file: !1, line: 1, type: !81,
isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagArtificial |
DIFlagPrototyped, isOptimized: false, unit: !87, declaration: !88, variables:
!2)
> 
> So the cloned function gets annotated with debug symbols as expected. We
noticed that the linkageName of the cloned function is the same as the original
one's. Could that cause the error mentioned above? If so, how can we fix
that error?
> 
> Best regards and thanks in advance,
> Matthias
> _______________________________________________
> LLVM Developers mailing list
> llvm-dev at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-dev
-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20170615/9315761d/attachment.html>

Keno Fischer via llvm-dev

2017-Jun-15 18:25 UTC

head link

[llvm-dev] CloneFunctionInto produces invalid debug info

This all looks very similar to a bug in the cloning stuff I fixed recently,
so would be indeed good to know if this is still happening on master.

On Thu, Jun 15, 2017 at 2:23 PM, Adrian Prantl via llvm-dev <
llvm-dev at lists.llvm.org> wrote:
> If you are doing this work based off LLVM trunk, could you send me your
> patch to reproduce the problem?
>
> -- adrian
>
> On Jun 15, 2017, at 8:31 AM, Matthias Bernad via llvm-dev <
> llvm-dev at lists.llvm.org> wrote:
>
> Hi!
>
> We are currently working on a science project and implemented a
> FunctionPass that clones a function (more precisely a constructor of a
> struct/class) and adds a parameter.
>
> First, we create a new function with a new function type, which includes
> the newly added parameter:
>
> Function *NF = Function::Create(NewFTy, F.getLinkage(), F.getName() +
> "Cloned", F.getParent());
>
>
> and after setting up the ValueToValueMapTy, we use the CloneFunctionInto
> method to clone the function body
>
> CloneFunctionInto(NF, &F, Map, true, Returns, "Cloned");
>
>
> The code seems to work as intended, but when we try to emit debug symbols
> (clang -g flag) the pass fails with following message:
>
> "All DICompileUnits must be listed in llvm.dbg.cu"
>
>
> Nevertheless, we can dump the Module and therefore can print out the
> annotated IR.
>
> This is what the function to be cloned looks like:
>
> ; Function Attrs: noinline nounwind uwtable
> define linkonce_odr void @_ZN12MyFunnyClassC2Ev(%struct.MyFunnyClass*
> %this) unnamed_addr #4 comdat align 2 !dbg !46 {
> entry:
>   %this.addr = alloca %struct.MyFunnyClass*, align 8
>   store %struct.MyFunnyClass* %this, %struct.MyFunnyClass** %this.addr,
> align 8
>   call void @llvm.dbg.declare(metadata %struct.MyFunnyClass** %this.addr,
> metadata !49, metadata !31), !dbg !50
>
> ... rest of function code
>
> }
>
> !46 = distinct !DISubprogram(name: "MyFunnyClass", linkageName:
> "_ZN12MyFunnyClassC2Ev", scope: !15, file: !1, line: 1, type:
!25, isLocal:
> false, isDefinition: true, scopeLine: 1, flags: DIFlagArtificial |
> DIFlagPrototyped, isOptimized: false, unit: !0, declaration: !47,
> variables: !2)
>
>
> and the cloned function:
>
> ; Function Attrs: noinline nounwind uwtable
> define linkonce_odr void @_ZN12MyFunnyClassC2EvCloned(%struct.MyFunnyClass*
> %this, { [6 x i8*] }* %newparam) unnamed_addr #4 align 2 !dbg !73 {
> entry:
>   %this.addr = alloca %struct.MyFunnyClass*, align 8
>   store %struct.MyFunnyClass* %this, %struct.MyFunnyClass** %this.addr,
> align 8
>   call void @llvm.dbg.declare(metadata %struct.MyFunnyClass** %this.addr,
> metadata !89, metadata !31), !dbg !91
>
> ... rest of function code
>
> }
>
> !73 = distinct !DISubprogram(name: "MyFunnyClass", linkageName:
> "_ZN12MyFunnyClassC2Ev", scope: !74, file: !1, line: 1, type:
!81, isLocal:
> false, isDefinition: true, scopeLine: 1, flags: DIFlagArtificial |
> DIFlagPrototyped, isOptimized: false, unit: !87, declaration: !88,
> variables: !2)
>
> So the cloned function gets annotated with debug symbols as expected. We
> noticed that the linkageName of the cloned function is the same as the
> original one's. Could that cause the error mentioned above? If so, how
can
> we fix that error?
>
> Best regards and thanks in advance,
> Matthias
> _______________________________________________
> LLVM Developers mailing list
> llvm-dev at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-dev
>
>
>
> _______________________________________________
> LLVM Developers mailing list
> llvm-dev at lists.llvm.org
> http://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-dev
>
>-------------- next part --------------
An HTML attachment was scrubbed...
URL:
<http://lists.llvm.org/pipermail/llvm-dev/attachments/20170615/9dceaa14/attachment.html>

llvm dev - Jun 2017 - CloneFunctionInto produces invalid debug info

[llvm-dev] CloneFunctionInto produces invalid debug info

[llvm-dev] CloneFunctionInto produces invalid debug info

[llvm-dev] CloneFunctionInto produces invalid debug info

[llvm-dev] CloneFunctionInto produces invalid debug info

[llvm-dev] CloneFunctionInto produces invalid debug info