相关疑难解决方法(0)

我想知道是否/如何可以看到编译器在启用优化时如何使用clang ++/g ++重构一段代码.我知道英特尔编译器有一个标志来产生相关的输出,但我似乎无法找到其他编译器中的等价物.

考虑这个函数：

std::string 
myClass::myFunction2() {
  std::string result = myClass::myFunction1();
  return result;
}

我希望编译执行返回值优化。我怎样才能确保这确实发生了，并且代码不会重复复制结果？

我编写了一个简单的程序来实现SSE内在函数来计算两个大(100000或更多元素)向量的内积.该程序比较两种内部产品的执行时间,以传统方式计算内部产品和使用内在函数.一切都很好,直到我在计算内积的语句之前插入(仅为了它的乐趣)一个内循环.在我走得更远之前,这是代码:

    //this is a sample Intrinsics program to compute inner product of two vectors and compare Intrinsics with traditional method of doing things.

        #include <iostream>
        #include <iomanip>
        #include <xmmintrin.h>
        #include <stdio.h>
        #include <time.h>
        #include <stdlib.h>
        using namespace std;

        typedef float v4sf __attribute__ ((vector_size(16)));

        double innerProduct(float* arr1, int len1, float* arr2, int len2) {  //assume len1 = len2.

          float result = 0.0;
          for(int i = 0; i < len1; i++) {
            for(int j = 0; j < len1; j++) {
              result …

我需要查看为某些C函数生成的汇编代码,编译C代码时应该使用哪些标志？

编辑:使用G ++编译器,抱歉!

这是一个代码片段,用于计算从http://felix.abecassis.me/2011/09/cpp-getting-started-with-sse/获取的浮点数组中的平方根值

void sse(float* a, int N)
{
    // We assume N % 4 == 0.
    int nb_iters = N / 4;
   __m128* ptr = (__m128*)a;


    for (int i = 0; i < nb_iters; ++i, ++ptr, a += 4){
        _mm_store_ps(a, _mm_sqrt_ps(*ptr));
    }

}

当我解释这个代码时,我看到只使用了一个xmm(xmm0).我假设展开循环会给编译器一个提示,可以使用更多的xmms.我将代码修改为

void sse3(float* a, int N)
{
__m128* ptr = (__m128*)a;

 for (int i = 0; i < N; i+=32){

    _mm_store_ps(a + i, _mm_sqrt_ps(*ptr));
    ptr++;
    _mm_store_ps(a + i + 4, _mm_sqrt_ps(*ptr));
    ptr++;
    _mm_store_ps(a + i + …

以下是通过装配网站找到的示例.这是C代码:

 int main()
 {
     int a = 5;
     int b = a + 6;
     return 0;
 }

这是相关的汇编代码:

    (gdb) disassemble
    Dump of assembler code for function main:
    0x0000000100000f50 <main+0>:    push   %rbp
    0x0000000100000f51 <main+1>:    mov    %rsp,%rbp
    0x0000000100000f54 <main+4>:    mov    $0x0,%eax
    0x0000000100000f59 <main+9>:    movl   $0x0,-0x4(%rbp)
    0x0000000100000f60 <main+16>:   movl   $0x5,-0x8(%rbp)
    0x0000000100000f67 <main+23>:   mov    -0x8(%rbp),%ecx
    0x0000000100000f6a <main+26>:   add    $0x6,%ecx
    0x0000000100000f70 <main+32>:   mov    %ecx,-0xc(%rbp)
    0x0000000100000f73 <main+35>:   pop    %rbp
    0x0000000100000f74 <main+36>:   retq   
    End of assembler dump.

我可以放心地假设这行汇编代码:

  0x0000000100000f6a <main+26>:   add    $0x6,%ecx

与此C行相关:

     int b = a …

我正在运行以下基准测试:

int main(int argc, char **argv)
{
 char *d = malloc(sizeof(char) * 13);

 TIME_THIS(func_a(999, d), 99999999);
 TIME_THIS(func_b(999, d), 99999999);

 return 0;
}

通过正常编译,两个函数的结果相同

% gcc func_overhead.c func_overhead_plus.c -o func_overhead && ./func_overhead                                                                               
[func_a(999, d)                     ]      9276227.73
[func_b(999, d)                     ]      9265085.90

但是与-O3他们是非常不同的

% gcc -O3 func_overhead.c func_overhead_plus.c -o func_overhead && ./func_overhead                                                                
[func_a(999, d)                     ]    178580674.69
[func_b(999, d)                     ]     48450175.29

func_a和func_b定义如下:

char *func_a(uint64_t id, char *d)
{
 register size_t i, j;
 register char c;

 for (i = 0, j = 36; i <= …

可能重复:
如何从gcc中的C/C++源获得汇编程序输出？

你好,那里!

我有一个C和C++源代码,我想在汇编代码中看到.如何为这些生成等效的asm代码？我应该使用什么工具？或者是否已经可以使用gcc编译器等工具？然后我应该执行什么命令？我更喜欢Linux之上的工具,尤其是Ubuntu.

提前致谢!

我写了一个简单的c ++程序,打印出"Hello World!"

#include <iostream>
using namespace std;
int main(){
cout<<"Hello World!\n";
}

然后我用g ++编译它

$ g++ Desktop/sample.cpp -o Desktop/hello

我怎样才能查看机器语言,只是它

$ less Desktop/hello

？

我很想知道"机器语言"是什么样的.以下是上述命令的示例

C>^D<A1><F4><9E>^D^H<83><F8><FF>t^S<BB><F4><9E>^D^Hf<90><83><EB>^D<FF>?^C<83><F8><FF>u<F4><83><C4>^D[]Ð<90>U
<89><E5>S<83><EC>^D<E8>^@^@^@^@[<81>Ì^X^@^@<E8><<FE><FF><FF>Y[<C9><C3>^C^@^@^@^A^@^B^@Hello World!
^@^@^@^AESC^C; ^@^@^@^C^@^@^@<A4><FE><FF><FF>@^@^@^@<C8><FE><FF><FF>\^@^@^@^H<FF><FF><FF>x^@^

我知道一些 C 和一点汇编，想开始学习逆向工程，所以我下载了适用于 Mac 的 Hopper Disassembler 试用版。我创建了一个超级基本的 C 程序：

int main() {
    int a = 5;
    return 0;
}

并使用 -g 标志编译它（因为我之前看到过这个并且不确定它是否重要）：

gcc -g simple.c

然后我a.out在 Hopper Disassembler 中打开文件并点击伪代码按钮，它给了我：

int _main() {
    rax = 0x0;
    var_4 = 0x0;
    var_8 = 0x5;
    rsp = rsp + 0x8;
    rbp = stack[2047];
    return 0x0;
}

我在这里理解的唯一一行是将变量设置为0x5. rsp = rsp + 0x8;对于这样一个简单的程序，我无法理解所有这些附加行的用途（例如）。有人愿意向我解释这个吗？

此外，如果有人知道逆向工程介绍的良好来源/教程，那也会非常有帮助。谢谢。

我要进行汇编测试，并且对汇编指针有疑问。我正在尝试锻炼，但无法解决。

考虑一下C中的语句：

int x=100, y=200;
int far *ptx;
int far *pty;

假设指令已经执行：

ptx=&x;
pty=(int *)malloc(sizeof(int));   

我的问题是关于如何在汇编中编码以下几点：

1. ptx=pty
2. *ptx=*pty

可能重复:
如何从gcc中的C/C++源获得汇编程序输出？

我有一个简单的问题.

我有一些为Android应用程序编写的本机C++代码.

当我在Eclipse中编译项目时,有什么方法可以看到我的GCC编译器生成的汇编代码？