标签: x86-64

我想过编写一个程序集存根来mprotect使用页面地址进行调用，但随后我需要在进程的同一地址空间中运行此存根，而且我不知道该怎么做。还有其他方法吗？

我正在研究基本的 shell 代码和orw代码。
但是，在此过程中，我收到以下错误消息：

错误：不支持的指令mov

这是我的 C 和汇编代码框架：

// File name: orw.c
// Compile: gcc -o orw orw.c -masm=intel

__asm__(

    ".global run_sh\n"
    "run_sh:\n"

    "push 0x67\n"
    "mov rax, 0x616c662f706d742f \n"
    "push rax\n"
    "mov rdi, rsp\n"
    "xor rsi, rsi\n"
    "xor rdx, rdx\n"
    "xor eax, eax\n"
    "mov eax, 2\n"
    "syscall"
    "\n"
    "mov rdi, eax\n"
    "mov rsi, rsp\n"
    "sub rsi, 0x30\n"
    "mov rdx, 0x30\n"
    "xor eax, eax\n"
    "syscall"
    "\n"
    "mov rdi,1\n"
    "mov eax,1\n"
    "syscall" 
);

void run_sh();

int main() { run_sh(); …

我知道在x86中我们可以使用括号中的32位地址作为地址。例如：

lea eax, [0xCAFEBABE]

但是在 64 位模式下我应该做什么呢？

下一个代码将无法编译，因为（据我所知）64 位常量只是禁止用于地址。

lea rax, [0xCAFEBABEDEADBEEF]

如何使用这个括号访问一些具有已知常量地址的常量？

AVD 管理器未启动模拟器，每当尝试启动模拟器时，它都会在屏幕截图中显示以下错误

我正在考虑购买一台新的 macbook pro，但是有一件事困扰着我，那就是我可能需要在这台机器上编译 x86 golang 二进制文件并将其复制到其他 x86 机器上，我在 Google 上做了一些搜索，似乎Go 支持交叉编译，但是有人有过这方面的经验吗？我可以在 m1 macbook pro 上编译并获得 x86-64 golang 二进制文件，该二进制文件可以在具有 Ubuntu 20.04 等系统的 x86-64 机器上运行吗？

谢谢。

我正在阅读Randal E. Bryant 和 David R. O'Hallaron 撰写的《计算机系统：程序员的视角》第三版。

在第3章和第7.5节中，有图演示了堆栈帧是如何分配的，如下所示：

我不明白为什么需要第 4 行和第 12 行。似乎不需要这些行，因为堆栈内存的剩余 8 个字节根本没有被使用。

正如评论所示，恕我直言，它似乎不可避免地被分配为按 24 字节对齐堆栈帧：

• 分别为pushq %rbp和附加 16 个字节pushq %rbx
• ，以及 8 个字节subq $8, %rsp

所以，我的问题可以概括为“为什么堆栈帧按 24 字节对齐？ ”

我如何跳转到 intel 汇编语法（x32 和 x64）中的已知内存地址。

我想我已经掌握了 64 位语法。例如，如果在 x64 中我想跳转到位于 的代码0x75767并且我位于0000，我会这样做：

0000: FF 25 01 00 00 00         jmp QWORD PTR [rip+0x75761]

^ 正确吗？我想我可以使用 objdump 将这些字节分解为 x32 指令，objdump.exe -D -Mintel,i386 -b binary -m i386 test.bin结果是：

jmp    DWORD PTR 0x75761

然后只需使用clang++.exe -masm=intel -m32 -c test.o将此指令转换为 x32 字节即可，但它显示：

error: invalid operand for instruction
jmp DWORD PTR 0x75761
^

我想避免写入任何寄存器。

我的 x64 jmp 指令正确吗？

我如何在 x32 中完成类似的事情？假设在 x32 中我需要跳转到0x400107并且我在0x400000

我正在调整 Windows 上的运行进程内存。如果我的问题有不准确的地方，请原谅我，我正在学习。

为什么是以下情况：

for (auto & x : vec) { /* do stuff with x */ } 

比...快

for (int i = 0; i < v.size(); ++i) { /* do stuff with v[i] */ }

正如我的标题所说，我被告知增加和取消引用迭代器比增加单独的变量并将其索引到数组中更快，但不明白为什么？

究竟发生了什么让它变得更快？

我试图走过去看看发生了什么，这就是我想到的

// pseudo instructions
// iterator

increment iterator
    e.g., if the object is 3 integers you would increment the iterator
    by 12
dereference this iterator

// pseudo instructions
// array

increment array index
    add 1 to index counter
multiply by size of object 
    e.g., if …

    ALIGNTO(16) uint8_t noise_frame_flags[16] = { 0 };

    // Code detects noise and sets noise_frame_flags omitted

    __m128i xmm0            = _mm_load_si128((__m128i*)noise_frame_flags);
    bool    isNoiseToCancel = _mm_extract_epi64(xmm0, 0) | _mm_extract_epi64(xmm0, 1);

    if (isNoiseToCancel)
        cancelNoises(audiobuffer, nAudioChannels, audio_samples, noise_frame_flags);

这是我在 Linux 上的 AV Capture 工具的代码片段。这里的noise_frame_flags是16通道音频的标志数组。对于每个通道，相应的字节可以是 0 或 1。1 表示该通道有一些噪声需要消除。例如，如果noise_frame_flags[0] == 1，则意味着设置了第一个通道噪声标志（通过省略的代码）。

即使设置了一个“标志”，我也需要调用cancelNoises. 这段代码在这方面似乎工作得很好。正如您所看到的，我曾经_mm_load_si128加载正确对齐的整个标志数组，然后加载两个_mm_extract_epi64来提取“标志”。我的问题是有更好的方法来做到这一点（也许使用流行计数）？

注意：ALIGNTO(16)是一个宏扩展以纠正 GCC 等效项，但外观更好。

好吧，我的问题如下，我在某处看到一个linux进程在堆栈上分配8 MiB供使用，例如，如果我有一个C程序，我只在堆栈上分配两个变量，这是正确的说法我分配了或者更好地说我只是重复使用了该空间？由于进程在堆栈上分配 8 MiB，因此它不取决于我将在程序中使用的大小，只要它不超过我的堆栈，即无论哪个术语合适，我都会在堆栈或者我将重用Linux进程已经分配的数据？

#include <stdio.h>

void f() {
   int x = 5;
   printf("Value = %d End = %p\n", x, &x);
}

void g() {
   int y = 10;
   printf("Value = %d End = %p\n", y, &y);
}

int main(){

  f();
  g();
  return 0;
}

看到地址将是相同的，因为我重复使用了已经分配的大小，而 malloc 不会发生同样的情况，总结术语“在堆栈中分配正确的数据”不是很正确？