c++ - avr-objdump 使用 g++ -flto 产生不正确的输出-6ren

c++ - avr-objdump 使用 g++ -flto 产生不正确的输出

转载作者：行者123 更新时间：2023-11-27 22:43:24

我正在使用具有 AVR Atmega2560 芯片的 Arduino Mega 2560。我正在使用 Windows 上的 Arduino IDE 1.8.4 对其进行编程，它附带 avr-objdump 2.26 和 avr-g++ 4.9.2。

我的程序或多或少可以正常工作，但在尝试检查生成的程序集时，objdump 似乎没有生成正确的输出。

执行

avr-objdump -D -S -m avr:6 "arduino_build_948544\sketch\mysketch.ino.cpp.o" > mysketch.asm

似乎成功了，但是对于一个简单的函数

void sleep_example() {
    SMCR = 1;
    __asm__("sleep");
}

反汇编看起来基本上是随机的:

Disassembly of section .gnu.lto__Z13sleep_examplev.af7e500a:

00000000 <.gnu.lto__Z13sleep_examplev.af7e500a>:
   0:   78 9c           mul r7, r8
   2:   63 66           ori r22, 0x63   ; 99
   4:   c0 04           cpc r12, r0
   6:   52 40           sbci    r21, 0x02   ; 2
   8:   fc 18           sub r15, r12
   a:   88 3d           cpi r24, 0xD8   ; 216
   c:   81 98           cbi 0x10, 1 ; 16
   e:   91 99           sbic    0x12, 1 ; 18
  10:   81 91           ld  r24, Z+
  12:   69 c2           rjmp    .+1234      ; 0x4e6 <__SREG__+0x4a7>
  14:   39 06           cpc r3, r25
  16:   86 46           sbci    r24, 0x66   ; 102
  18:   0e 26           eor r0, r30
  1a:   46 46           sbci    r20, 0x66   ; 102
  1c:   10 83           st  Z, r17
  1e:   81 91           ld  r24, Z+
  20:   a1 9e           mul r10, r17
  22:   89 b1           in  r24, 0x09   ; 9
  24:   9e f1           brts    .+102       ; 0x8c <__SREG__+0x4d>
  26:   25 d3           rcall   .+1610      ; 0x672 <__SREG__+0x633>
  28:   47 26           eor r4, r23
  2a:   c6 ef           ldi r28, 0xF6   ; 246
  2c:   73 17           cp  r23, r19
  2e:   9c 60           ori r25, 0x0C   ; 12
  30:   52 57           subi    r21, 0x72   ; 114
  32:   9d fe           .word   0xfe9d  ; ????
  34:   ba 99           sbic    0x17, 2 ; 23
  36:   bb a1           ldd r27, Y+35   ; 0x23
  38:   cb e0           ldi r28, 0x0B   ; 11
  3a:   27 13           cpse    r18, r23
  3c:   03 c3           rjmp    .+1542      ; 0x644 <__SREG__+0x605>
  3e:   67 26           eor r6, r23
  40:   88 21           and r24, r8
  42:   8c cb           rjmp    .-2280      ; 0xfffff75c <__SREG__+0xfffff71d>
  44:   19 d5           rcall   .+2610      ; 0xa78 <__SREG__+0xa39>
  46:   19 80           ldd r1, Y+1 ; 0x01
  48:   2a 3a           cpi r18, 0xAA   ; 170
  4a:   77 dc           rcall   .-1810      ; 0xfffff93a <__SREG__+0xfffff8fb>
  4c:   ee e0           ldi r30, 0x0E   ; 14
  4e:   63 63           ori r22, 0x33   ; 51
  50:   61 84           ldd r6, Z+9 ; 0x09
  52:   48 30           cpi r20, 0x08   ; 8
  54:   ae 60           ori r26, 0x0E   ; 14
  56:   64 63           ori r22, 0x34   ; 52
  58:   04 d2           rcall   .+1032      ; 0x462 <__SREG__+0x423>
  5a:   eb 85           ldd r30, Y+11   ; 0x0b
  5c:   0e 34           cpi r16, 0x4E   ; 78
  5e:   fc ff           .word   0xfffc  ; ????
  60:   cf bc           out 0x2f, r12   ; 47
  62:   eb e1           ldi r30, 0x1B   ; 27
  64:   3b 65           ori r19, 0x5B   ; 91
  66:   66 06           cpc r6, r22
  68:   86 27           eor r24, r22
  6a:   40 29           or  r20, r0
  6c:   90 d1           rcall   .+800       ; 0x38e <__SREG__+0x34f>
  6e:   4f 99           sbic    0x09, 7 ; 9
  70:   98 40           sbci    r25, 0x08   ; 8
  72:   34 f3           brlt    .-52        ; 0x40 <__SREG__+0x1>
  74:   2d c6           rjmp    .+3162      ; 0xcd0 <__SREG__+0xc91>
  76:   43 1f           adc r20, r19
  78:   36 7c           andi    r19, 0xC6   ; 198
  7a:   63 94           inc r6
  7c:   05 a9           ldd r16, Z+53   ; 0x35
  7e:   06 1a           sub r0, r22
  80:   31 67           ori r19, 0x71   ; 113
  82:   75 fb           bst r23, 5
  84:   19 de           rcall   .-974       ; 0xfffffcb8 <__SREG__+0xfffffc79>
  86:   17 4c           sbci    r17, 0xC7   ; 199
  88:   3f 99           sbic    0x07, 7 ; 7
  8a:   18 83           st  Y, r17
  8c:   41 26           eor r4, r17
  8e:   ee ea           ldi r30, 0xAE   ; 174
  90:   fb 7f           andi    r31, 0xFB   ; 251
  92:   90 0b           sbc r25, r16
  94:   cc 65           ori r28, 0x5C   ; 92
  96:   00 71           andi    r16, 0x10   ; 16
  98:   37 ed           ldi r19, 0xD7   ; 215
  9a:   5e 74           andi    r21, 0x4E   ; 78
  9c:   9c 79           andi    r25, 0x9C   ; 156
  9e:   2e e3           ldi r18, 0x3E   ; 62
  a0:   ec c6           rjmp    .+3544      ; 0xe7a <__SREG__+0xe3b>
  a2:   16 46           sbci    r17, 0x66   ; 102
  a4:   86 9f           mul r24, r22
  a6:   4c 4c           sbci    r20, 0xCC   ; 204
  a8:   8c 2b           or  r24, r28
  aa:   19 a5           ldd r17, Y+41   ; 0x29
  ac:   18 57           subi    r17, 0x78   ; 120
  ae:   31 02           muls    r19, r17
  b0:   fd c0           rjmp    .+506       ; 0x2ac <__SREG__+0x26d>
  b2:   b8 9a           sbi 0x17, 0 ; 23
  b4:   71 2e           mov r7, r17
  b6:   23 50           subi    r18, 0x03   ; 3
  b8:   c1 a7           std Z+41, r28   ; 0x29
  ba:   27 37           cpi r18, 0x77   ; 119
  bc:   7f b2           in  r7, 0x1f    ; 31
  be:   83 d4           rcall   .+2310      ; 0x9c6 <__SREG__+0x987>
  c0:   33 33           cpi r19, 0x33   ; 51
  c2:   32 30           cpi r19, 0x02   ; 2
  c4:   ae 01           movw    r20, r28
  c6:   ca dc           rcall   .-1644      ; 0xfffffa5c <__SREG__+0xfffffa1d>
  c8:   66 6c           ori r22, 0xC6   ; 198
  ca:   38 7c           andi    r19, 0xC8   ; 200
  cc:   fb 38           cpi r31, 0x8B   ; 139
  ce:   1b 13           cpse    r17, r27
  d0:   c8 78           andi    r28, 0x88   ; 136
  d2:   90 53           subi    r25, 0x30   ; 48
  d4:   9d 19           sub r25, r13
  d6:   ee 31           cpi r30, 0x1E   ; 30
  d8:   36 1e           adc r3, r22
  da:   b8 eb           ldi r27, 0xB8   ; 184
  dc:   0e e3           ldi r16, 0x3E   ; 62
  de:   3f 01           movw    r6, r30
  e0:   9a 0c           add r9, r10
  e2:   74 06           cpc r7, r20
  e4:   d0 51           subi    r29, 0x10   ; 16
  e6:   0e ce           rjmp    .-996       ; 0xfffffd04 <__SREG__+0xfffffcc5>
  e8:   56 31           cpi r21, 0x16   ; 22
  ea:   a1 c5           rjmp    .+2882      ; 0xc2e <__SREG__+0xbef>
  ec:   a9 45           sbci    r26, 0x59   ; 89
  ee:   c5 31           cpi r28, 0x15   ; 21
  f0:   e9 25           eor r30, r9
  f2:   f9 f9           .word   0xf9f9  ; ????
  f4:   b9 31           cpi r27, 0x19   ; 25
  f6:   fe 79           andi    r31, 0x9E   ; 158
  f8:   a9 2e           mov r10, r25
  fa:   45 99           sbic    0x08, 5 ; 8
  fc:   65 a9           ldd r22, Z+53   ; 0x35
  fe:   31 2e           mov r3, r17
 100:   f9 c9           rjmp    .-3086      ; 0xfffff4f4 <__SREG__+0xfffff4b5>
 102:   a5 b9           out 0x05, r26   ; 5
 104:   a9 79           andi    r26, 0x99   ; 153
 106:   25 c5           rjmp    .+2634      ; 0xb52 <__SREG__+0xb13>
 108:   31 8e           std Z+25, r3    ; 0x19
 10a:   45 29           or  r20, r5
 10c:   a5 99           sbic    0x14, 5 ; 20
 10e:   79 f9           .word   0xf979  ; ????
 110:   31 c9           rjmp    .-3486      ; 0xfffff374 <__SREG__+0xfffff335>
 112:   89 05           cpc r24, r9
 114:   b9 a9           ldd r27, Y+49   ; 0x31
 116:   25 a9           ldd r18, Z+53   ; 0x35
 118:   45 70           andi    r20, 0x05   ; 5
 11a:   86 1e           adc r8, r22
 11c:   50 94           com r5
 11e:   81 ad           ldd r24, Z+57   ; 0x39
 120:   38 27           eor r19, r24
 122:   35 b5           in  r19, 0x25   ; 37
 124:   80 01           movw    r16, r0
 126:   00 1d           adc r16, r0
 128:   9f 69           ori r25, 0x9F   ; 159
 12a:   9f f5           Address 0x0000012a is out of bounds.
.word   0xffff  ; ????

我不确定这是为什么。这可能是我对 avr-objdump 的调用，但我不知道要更改什么以显示正确的反汇编。

最佳答案

-flto 将 GCC 的内部表示放入 .o 中，用于链接时的跨文件优化。 https://gcc.gnu.org/wiki/LinkTimeOptimization

它不在代码段中，但您使用 -D 将非代码段反汇编为代码段。所以你得到了你想要的。

如果您没有使用 LTO，.o 中会有实际的 AVR 机器代码。

可能有一个选项可以在 .o 中包含机器代码和 gcc 内部表示，但这不会是将要进入的最终机器代码如果您在链接时使用 -flto 则二进制文件。但更好的方法是使用 gcc -O3 -S(另请参见 How to remove "noise" from GCC/clang assembly output?)。 (没有 -flto，否则您会看到 gcc 提供给 gas 以生成 .o 的汇编使用 .gnu.lto__Z13sleep... 部分而不是 .text 部分。)

查看最终二进制文件中代码的唯一方法是反汇编它。优化发生在创建它的同一步骤中，因此前面的步骤都不能保证是相同的。但是，查看编译器的 asm 输出可能很有用，因为它可以保留一些附加的符号信息，尤其是 -fverbose-asm。

关于c++ - avr-objdump 使用 g++ -flto 产生不正确的输出，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/46381665/

文章推荐： javascript - 如何使用 CSS 为文本字段中的值设置样式？

文章推荐： c++ - 如何分析固件镜像的大小？

文章推荐： c++ - 使用 memset 为 Union 分配内存时发生内存泄漏

g++ - 如何构建 g++
我目前正在尝试让 g++ 工作，并查看 http://gcc.gnu.org/install/build.html ，我似乎找不到它在哪里说如何“执行编译器的 3 阶段 bootstrap ”。我在哪
Python:理解(None for g in g if (yield from g) and False)
James Powell 在他对即将举行的演示文稿的简短描述中说，他自豪地发明了最粗糙的 Python 单行代码之一: (None for g in g if (yield from g) and F
graph-theory - 证明如果 G 的深度优先搜索树等于 G 的广度优先搜索树则 G 是树
请告诉我我的证明是否正确 We have a connected graph, and specific vertex u in V(G). Suppose we compute the dfs tr
powershell - PowerShell “$g = $json | ConvertFrom-Json | Group State”结果与 “$g = $json | ConvertFrom-Json ; $g = $g | Group State ;”不同
下面的test2和test3结果是不同的。我对此感到困惑，因为它看起来像相同的逻辑，并且与linux bash ||逻辑不同。 $data = @( [PSCustomObject]@{St
g-code - 寻找 G Code 语法规范，尝试制作简单的 G Code 解析器
我试图找到一个明确的 G 代码语法规范，而不是单个 G 代码的含义，我无处不在的规范，我的意思是详细的语法规范，目的是编写解析器。我编写解析器没有问题，我只是在寻找语法规范，例如。我知道您不必总是为
css - 为 g 推荐别的东西为 g 推荐别的东西为 g 推荐别的东西
我写了这个 mixin，但它循环了很多时间。你能帮我优化我的代码吗？或者你能建议一些其他的东西来获得想要的结果吗？ dfgdfgsdfgsdf 最佳答案希望这就是您要找的。 $spaces: (4,
g++ - 强制 g++ 为未使用的函数生成代码
默认情况下，g++ 似乎会省略未使用的类内定义方法的代码。示例 from my previous question : struct Foo { void bar() {} void baz(
g++ - 在 g++ 中管道文件内容进行编译
是否可以将文件内容通过管道传送到 g++编译程序？我想这样做是因为我想使用数据库中的文件而不是磁盘上的物理文件。可以通过我制作的 API 轻松检索文件内容。例如，我想做这样的事情: g++ con
g++ - 使用 g++ 进行分析
如何profile c++代码获取每行代码的调用次数和消耗时间，就像profile工具一样在 Matlab 中呢？我尝试使用-fprofile-arcs之类的东西，但它只生成代码覆盖率报告，其中可以
g++ - 如何通过几行代码禁用 g++ 中的所有警告
如何在几行代码上禁用所有警告。可以使用 GCC 诊断功能禁用特定警告，但是否有针对所有警告的标志。我尝试了这个方法，但不起作用 #pragma GCC diagnostic push #pragma
g++ - 修复共享库 g++ 上的断开链接
我有一个链接到 opencv 2.2 的可执行文件。但是，我删除了 opencv 2.2 并安装了 opencv 2.3。问题是，有没有办法在不重新编译整个源代码的情况下将这个可执行文件链接到新的共
g++ - 是否可以在 g++ 中启用数组边界检查？
在编译带有一些标志的以下文件时，是否可以让 g++ 显示错误？ #include using namespace std; int main() { int arr[ 2 ]; cout
haskell - 找到 Haskell 函数 f, g 使得 f g = f 。 G
在学习 Haskell 时，我遇到了一个挑战，要找到两个函数 f 和 g，例如 f g 和 f 。 g 是等价的(并且是总计，因此像 f = undefined 或 f = (.) f 这样的东西不算
algorithm - 如何证明 Θ(g(n)) = O(g(n)) ∩ Ω(g(n))
根据我的理解，Theta 位于 Big O 和 Omega 之间，但我看到了这个声明，但我无法理解为什么交集会出现在这里。我能否对 Θ(g(n)) = O(g(n)) ∩ Ω(g(n)) 获得数学和分
c - 递归函数到迭代，该函数给定 g(n) = 2*g(n-1)+3*g(n-2)
我需要为这个递归函数编写一个迭代函数。 int funcRec(int n){ if(n>1) { return 2*funcRec(n - 1) + 3*funcRec(n
c++ - g++、clang++、使用 libboost 的编译花絮——当 g++7 成功时，g++8 编译失败；
我在 github repository 上有代码示例并在 travis-ci 上创建了一个构建便于复制。最小的、完整的和可验证的例子可能不是最小的，但我相信它足够小它使用 boost.inte
haskell - f, g, h::Kleisli ((->) e) a b <=> f >>> (g &&& h) = (f >>> g) &&& (f >>> h)？
编辑:我们将调用箭头 p纯如果存在这样的函数f即:p = arr f . 我试图更好地掌握 Haskell 中的 Arrows，我想弄清楚什么时候 f >>> (g &&& h) = (f >>> g
Scalaz monad 转换器。将 f1 :A => G[B], f2:B => G[C] 函数应用于 F[G[A]] 对象
我有两个(或更多)函数定义为: val functionM: String => Option[Int] = s => Some(s.length) val functionM2: Int => Op
algorithm - 在渐近符号中，给定 g(n)，O(g(n)) 和 Ω(g(n)) 的并集是所有函数的通用集 U 吗？
好像是的。任何直观或严肃的证据都值得赞赏。最佳答案没有。我认为您的问题等同于:给定函数 f 和 g，f 是 O(g) 或 g 是 O(f) 是否总是正确的？这在 SE Computer Scie
algorithm - 如果 f(n) = o(g(n))，g(n) + f(n)=Θ(g(n)) 吗？
如果我设法证明 f(n) = o(g(n))(小 o)，那么这两个函数的总和 f( n) + g(n) 应该被“更大”的函数 g(n) 紧紧束缚。然而，我在证明这一点时遇到了一些麻烦。最佳答案以

行者123

个人简介

我是一名优秀的程序员,十分优秀！

作者热门文章

滴滴打车优惠券免费领取

全站热门文章

首页

博学

6Ren·AI

商城

c++ - avr-objdump 使用 g++ -flto 产生不正确的输出