<table border="1" cellspacing="0" cellpadding="8">
<tr>
<th>Issue</th>
<td>
<a href=https://github.com/llvm/llvm-project/issues/57040>57040</a>
</td>
</tr>
<tr>
<th>Summary</th>
<td>
[llvm-debuginfo-analyzer] Weird output of `--compare`
</td>
</tr>
<tr>
<th>Labels</th>
<td>
new issue
</td>
</tr>
<tr>
<th>Assignees</th>
<td>
</td>
</tr>
<tr>
<th>Reporter</th>
<td>
aheejin
</td>
</tr>
</table>
<pre>
Hello. Thank you for making this tool available for LLVM!
I downloaded + applied all patches uploaded in Phabricator and tried to follow the user guide, and I have some questions. I'm following "Comparison Mode" section of `llvm-debuginfo-analyzer.rst`.
I built `test.cpp` with both g++ and clang++ instructed in the section. This is `test.cpp`, which is the same code in the instruction:
```cpp
using INTPTR = const int *;
int foo(INTPTR ParamPtr, unsigned ParamUnsigned, bool ParamBool) {
if (ParamBool) {
typedef int INTEGER;
const INTEGER CONSTANT = 7;
return CONSTANT;
}
return ParamUnsigned;
}
```
This is how I built the object files:
```
$ g++ -c -g -O0 test.cpp -o test-dwarf-gcc.o
$ clang++ -c -g -O0 test.cpp -o test-dwarf-clang.o
```
These are my clang++ and g++ versions:
```
$ g++ --version
g++ (Debian 11.3.0-3) 11.3.0
Copyright (C) 2021 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
$ clang++ --version
clang version 14.0.6
Target: x86_64-unknown-linux-gnu
Thread model: posix
```
---
This is the analyzer's output on each of the object files, separately:
```
$ llvm-debuginfo-analyzer --attribute=level --print=symbols,types test-dwarf-gcc.o
Logical View:
[000] {File} 'test-dwarf-gcc.o'
[001] {CompileUnit} 'test.cpp'
[002] 1 {TypeAlias} 'INTPTR' -> '* const int'
[002] 2 {Function} extern not_inlined 'foo' -> 'int'
[003] {Parameter} 'ParamBool' -> 'bool'
[003] {Parameter} 'ParamPtr' -> 'INTPTR'
[003] {Parameter} 'ParamUnsigned' -> 'unsigned int'
[003] {Block}
[004] 4 {TypeAlias} 'INTEGER' -> 'int'
[004] 5 {Variable} 'CONSTANT' -> 'const INTEGER'
$ llvm-debuginfo-analyzer --attribute=level --print=symbols,types test-dwarf-clang.o
Logical View:
[000] {File} 'test-dwarf-clang.o'
[001] {CompileUnit} 'test.cpp'
[002] 1 {TypeAlias} 'INTPTR' -> '* const int'
[002] 2 {Function} extern not_inlined 'foo' -> 'int'
[003] {Block}
[004] 5 {Variable} 'CONSTANT' -> 'const INTEGER'
[003] 2 {Parameter} 'ParamBool' -> 'bool'
[003] 2 {Parameter} 'ParamPtr' -> 'INTPTR'
[003] 2 {Parameter} 'ParamUnsigned' -> 'unsigned int'
[003] 4 {TypeAlias} 'INTEGER' -> 'int'
```
It looks gcc lacks debug info compared to clang. So the output here is little different from what the instruction expects, but I think that's fine and this is not what I'd like to ask about.
---
Then I ran the comparison mode as instructed in "Logical View" section:
```
$ llvm-debuginfo-analyzer --attribute=level --compare=types --report=view --print=symbols,types test-dwarf-clang.o test-dwarf-gcc.o
Reference: 'test-dwarf-clang.o'
Target: 'test-dwarf-gcc.o'
Logical View:
[000] {File} 'test-dwarf-clang.o'
[001] {CompileUnit} 'test.cpp'
-[002] 1 {TypeAlias} 'INTPTR' -> '* const int'
-[002] 2 {Function} extern not_inlined 'foo' -> 'int'
[003] {Block}
[004] 5 {Variable} 'CONSTANT' -> 'const INTEGER'
[003] 2 {Parameter} 'ParamBool' -> 'bool'
[003] 2 {Parameter} 'ParamPtr' -> 'INTPTR'
[003] 2 {Parameter} 'ParamUnsigned' -> 'unsigned int'
-[003] 4 {TypeAlias} 'INTEGER' -> 'int'
+[002] 2 {Function} extern not_inlined 'foo' -> 'int'
[003] {Parameter} 'ParamBool' -> 'bool'
[003] {Parameter} 'ParamPtr' -> 'INTPTR'
[003] {Parameter} 'ParamUnsigned' -> 'unsigned int'
[003] {Block}
+[004] 4 {TypeAlias} 'INTEGER' -> 'int'
[004] 5 {Variable} 'CONSTANT' -> 'const INTEGER'
+[002] 1 {TypeAlias} 'INTPTR' -> '* const int'
```
This looks weird. Both files have `[002] 2 {Function} extern not_inlined 'foo' -> 'int'` line but somehow it is prepended with `-` in one line and `+` with another. Also `test-dwarf-clang.o` has more debug info on `{Parameter}` lines, but they are not listed as differences, i.e., not prepended with `+` or `-`.
---
And then I ran the commands in "Logical Elements" section:
```
$ llvm-debuginfo-analyzer --attribute=level --compare=types --report=list --print=symbols,types,summary test-dwarf-clang.o test-dwarf-gcc.o
Reference: 'test-dwarf-clang.o'
Target: 'test-dwarf-gcc.o'
(1) Missing Scopes:
-[002] 2 {Function} extern not_inlined 'foo' -> 'int'
(2) Missing Types:
-[003] 4 {TypeAlias} 'INTEGER' -> 'int'
-[002] 1 {TypeAlias} 'INTPTR' -> '* const int'
(1) Added Scopes:
+[002] 2 {Function} extern not_inlined 'foo' -> 'int'
(2) Added Types:
+[002] 1 {TypeAlias} 'INTPTR' -> '* const int'
+[004] 4 {TypeAlias} 'INTEGER' -> 'int'
----------------------------------------
Element Expected Missing Added
----------------------------------------
Scopes 4 1 1
Symbols 0 0 0
Types 2 2 2
Lines 0 0 0
----------------------------------------
Total 6 3 3
```
It's very confusing here. As I noted, `[002] 2 {Function} extern not_inlined 'foo' -> 'int'` line is not different in the two files, but it is listed in both "Missing Scopes" and "Added Scopes" section. Also `[002] 1 {TypeAlias} 'INTPTR' -> '* const int'` line also occurs in the both files but listed in both "Missing Types" and "Added Types" section.
---
A few more unrelated misc. questions: I'd like to know how high/low the debug info coverage is and any gaps or missing debug info, and I tried `--attribute=coverage,gaps`, but not sure if I am doing it correctly.
```
llvm-debuginfo-analyzer --attribute=coverage,gaps --print=all test.o
```
I tried something like this but I couldn't find the relevant info. It's possible that I just don't know how to use the tool. Is this a correct way of getting this information?
Thank you!
cc @CarlosAlbertoEnciso
</pre>
<img width="1px" height="1px" alt="" src="http://email.email.llvm.org/o/eJztWltz6jgS_jXOS5ddxhAIDzyQ2wxVOUkq4ZytfZoStgw6ERYjyeGwv367ZRtjAgxJyO48DJVKhN361FJfvpaUiUpWg9-5lCqA8YxlL7BSOaRKw5y9iGwKdiYMWKUksFcmJJtI7l7f3f345kUtL7z2wmHxewSJWmZSsYQn4EWXwBYLKbDNpIQFs_GMG8gXpYDI4HHGJlrEzCIeyxKwmqStwgFQoSWOzSE3XMM0Fwn3oisnNYIZe-Vg1JzDnzk3VqjMBDDyot687EmKe1F0peYLpoVRGXxTBBCB4THJg0rB64ZSvs79hE_yqchS5bOMydV_uA60sfg2aE5ukgtpqZfFMYN4scAmLIWdwUThrynO2E0aVYwly6rvIjNW57EtpkxTKnWgBce1xZ8mJs1zORPxjF45eYYzjXECFUAFiSBeu9SPOrofAnFPckPLMLofP46fwGtfIwT2w844iWjotS8LMfqeKuVFF6XoI9Ns_mg16ZFnRkwzVN09_F5-ozcTcgn39BJbXtQHr1ciAghc3ehi31sAu1rwhKdOFxz15rebp7U-9L7QtHwDVw_3z-Ph_dhNotcQ1NzmOltLbLzzetdVsxRqTqGSXMutF3DT6pWFZuiNlQeQBdTkJxoRUiG5eWuC8mvUWTuFH4M_Bf8hhMrQ4CvX9pMl06k_jeNA1f02Hegv-zrhde_d0-CGA9Mc5qsGNjlr1X7l2lAoHTUfv5QuXlWP0ejXfCJYBq1W0A5Cv02mL9qF5JVarLSYzsgHL67obRRGLbjVnMOzSu2SlLxVeZYw597oaaMsDprWSEnalNJoSYwoXkSKynVc5KcYByL_R1dKRJkiMOA4wiPC_UOBiACaZXZFIJmywF955rp_u3m6-h09ang5uhuN_w346HY0vr95fobbhycYwuPwaTy6-n43xID5_vT48HzTSBdvjNhcMPeqWnFodYIw6JZzZHrKLdoAfl10_-h2_Dx7yTCt-lJk-S9_muXVWmjOEphjWpAkvVBG_DrgAr7v73JsWrUq7WECNaByu8gtoFacYQrCPPnG39EmhmNiZZbL1SFv2ZNecTGYxVw_yS1a71riokt8ttCYDvC7Wc0nStIwlCbMvihxv-_UFPlDwg_Bl7Um55dhGHrn11B_MP3covIY7eh4vTeQUa9hPAJoNQEcBBEKonzPhN1Acnl7jUB9o6pva7P3GKczlIKZsm-Rb7EBvte-oSeYl-ssvQcyaswpzwoaQET-y3JMc-jGf4gMvcWRcM-l9nqEN7jt7WmWyC5bckQsld1I5jXapPj-UThHMjXaej0-ilfzUw26ZrCjZ34pVfxS0wKJdirRzrbwDps6Nju05Gu08220H1itUIVVgq1pbQOtQY3bfvsVMddklxNFXQX6T9y9x_tO6C8NFaIm6mdD_xi494T-MXgfDP1OE_q90dykvJEFqdSLAeQUkCzGlgtEoEhE_6LNSLG_KdwfC56CXAvKrWoTKazFTVYi0hSfUHWu1Rx3BMxuF__oegukZcfIGNhYoeJuDbdwFmUdmafojcXOqqR7qnEcEu2WEhzqhZM-zLwAm6AejRrmTcmAtdEIsF5yesT15oqKEMTY2urgdquRKOrd1-lqhnJR8UmRt3xf84XSlNJeccx3ZbiDhcYTd8aIOdVah3NZXcGRU_1lsbEzmcIJsil8Jp36X5BP_a9KqPCOjApflVLhxDn1A3iHk-oHAI_Oqv5J0ypumf4vnvJpIx2D9y4jHQN4tJHeEyaVDU5W-X5Z3L3xltPUfntPgwqKX3KhkwAu6eTP7YqLQ0nqcHrX7YZAEo7j6diTTqOEJT5fIN3xjI5T3UEkSvokjeyrUF5W9O9OFS_X55UMR8VqI4ChNKo6fdziEpSdIaXPFRYlG1UMsj2BNV2xUnBdiCD6yh03Ub0hhaGKAMGqkiYuJEXAA_pLQm8nUiqsdDWrQ7XJ0NU42_XJHOdutkqRG8nnWFSZ_3U5QquwvxzBvyZHffXq71OYeNFFiw7ovgnjTpKfY7XYOO3cyeaf3hpVI0ebI49Xbwfe4pr3J6SdFc5nMkZj0YYJ-fLWku0httMuWjFyc8n25MjPzHY3P3yA7KtwPupTSJcxjOPduA0Qzhc_lbe4j1uFj2AXJtvgpg3ia200S-kijOvn4e5mGYCrJvRmDbbZLDcGlFE3pQ9iv2-WY2UxF258unWzvdE8QIajYov5yjFnoX-kxXUTbWKRVwwmYnTg4qpoDymegBDLHW29VS4vyOxS1WfVREgFW5ZMhELuxg4pYCu3ISc4uoyiRvzWVFFT5uniqZoMI2QVx7k21TwmdXlBs9ivfxHu2-qvn1baH2JQSHG_7Og-zzSXjEaaCxMH9SUrUUfz4ICuJtzl2ExMZ150W93aNs490EXY1BmLtGPZCqZsYYjZ56X6tXh9yVtcBhP3N6i2gkNBQinvS2l1yBNMTmcoKXZnc0gUYaPpY6U1roBcBTv9-TiO3xp4g8vpetttoHdfwVVTocqNzmem5epRMVmc2sQql0lGjEwnNq6SATQBf2XOpVMVQBltC4ULRlfw1h3iwM8c_ShRRd-1MdAwuSluxOjmHnubYjhWLQUs2YrudrAesOtbfhpJz4t7t_Zts_At_zNgfeMfx-B1wiumpTJDOeHaqpssFkad8UGr2w3Dfr_b650lg3bSb_fZmRVW8gEGzZ7FpkD6F9XU6wuotLB9VVJ1w7Ncy8HM2oXjtegWf6ZYK-aTAGXI9xC5_IOmUXRhhV_Rw3IKgtvzXtgJz2aDfrvHJ50O5_2wf9FK-3HY65130n4vPk-itNM7k2zCpSFdMXQyDAoHgW3U8UwMojCKwosWBn-nd94Nev2YJUln0o16ne75eRdXhc-ZkAHpESg9PdMDpxLO2OBLimFTv2TGbdTc0hA-y-1M6QGbcf5TZGdu6IFT_b_iS3I2">