由于这与查询相切相关，因此
我将其添加为另一个答案，而不是编辑第一个答案，
因此出现问题的代码可能会忽略编译器警告

<source>: In function 'int main()':
<source>:11:40: warning: ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]
   11 |     std::cout << foo(std::string("H"), "ello World!\n");
      |                                        ^~~~~~~~~~~~~~~
Compiler returned: 0

所以像 0x880d32 这样的 32 位地址作为参数传递给 64 位程序

我想知道在什么情况下会通过 edx 而不是 rdx
所以我破坏了

 _ZStplIcSt11char_traitsIcESaIcEENSt7__cxx1112basic_stringIT_T0_T1_EEOS8_PKS5_  

这导致

std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > std::operator+<char, std::char_traits<char>, std::allocator<char> >(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >&&, char const*) 

所以有问题的代码实际上使用了一个右值引用声明

c++11 功能gccrvalueref，msvcrvalueref
并且不传递引用使用显式 char*
可以通过编译下面的代码并查看反汇编来确定构造。

测试代码

#include <iostream>
#include <string>
std::string foo(std::string _lhs,char *_rhs)
{
    return std::operator+(_lhs , _rhs);
}
int main()
{
    char rval[] = {"ello World!\n"};
    std::cout << foo(std::string("H"), rval);
    std::cout << foo(std::string("H"), "ello World!\n");
    
}

第一次调用 foo() 的反汇编使用正确的 64 位 rdx

  lea rax, [rbp-176]
  lea rdx, [rbp-189]
  lea rcx, [rbp-144]
  mov rsi, rcx
  mov rdi, rax
  call foo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, char*)

对 foo() 的第二次调用的反汇编使用 32 位偏移量 edx

  lea rax, [rbp-96]
  lea rcx, [rbp-64]
  mov edx, OFFSET FLAT:.LC1 and if linked mov edx,0x402007 a 32 bit address
  mov rsi, rcx
  mov rdi, rax
  call foo(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, char*)
.LC1:
  .string "ello World!\n"

std::operator+ 接受两个参数，
都指向 std::string ，
如 std::operator+(_lhs , _rhs ); 并返回 _Ans 一个指向 _lhs 和 _rhs 连接结果的指针，
因为您使用的是 gcc 前三个适用的寄存器是 rdi、rsi 和 rdx

rdi 通常是 _Ans 结果 std::string 地址 rsi 通常是 _lhs rdx 通常是 _rhs

在您的反汇编中
rdi = rbx--> [rax+0xa0]
rsi = rax--> [rbp-0x60]
rdx = edx-> 0x880d32将常量移动到 edx 将 rdx 的上部归零

查看使用 unicorn 模拟 mov rdx,0xffffffffffffffff,mov edx,1 的结果

from __future__ import print_function
from unicorn import *
from unicorn.x86_const import *
# code to be emulated mov rdx,0xffffffffffffffff; mov edx,1
X86_CODE64 = b"\x48\xc7\xc2\xff\xff\xff\xff\xba\x01\x00\x00\x00" 
ADDRESS = 0x1000000000
try:
    mu = Uc(UC_ARCH_X86, UC_MODE_64)
    mu.mem_map(ADDRESS, 2 * 1024 * 1024)
    mu.mem_write(ADDRESS, X86_CODE64)
    mu.emu_start(ADDRESS, ADDRESS + 7)    
    print(">>> RDX = 0x%x" %mu.reg_read(UC_X86_REG_RDX))
    mu.emu_start(ADDRESS+7, ADDRESS + 12)    
    print(">>> RDX = 0x%x" %mu.reg_read(UC_X86_REG_RDX))
    
except UcError as e:
    print("ERROR: %s" % e)

每一步后寄存器 rdx 的结果

:\>python test1.py
>>> RDX = 0xffffffffffffffff
>>> RDX = 0x1

为了更好地理解，您可以在编译器资源管理器中使用您选择的编译器尝试以下代码

#include <iostream>
#include <string>
std::string conc(std::string first,std::string second)
{
    return std::operator+(first,second);
}
int main()
{  
    std::string result =  conc("hello ","world\n"); 
    std::cout << result;
}

编译gcc 5.4反汇编conc()如下

conc(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> >):
  push rbp
  mov rbp, rsp
  sub rsp, 32
  mov QWORD PTR [rbp-8], rdi
  mov QWORD PTR [rbp-16], rsi
  mov QWORD PTR [rbp-24], rdx
  mov rax, QWORD PTR [rbp-8]
  mov rdx, QWORD PTR [rbp-24]
  mov rcx, QWORD PTR [rbp-16]
  mov rsi, rcx
  mov rdi, rax
  call std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > std::operator+<char, std::char_traits<char>, std::allocator<char> >(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char> > const&)
  mov rax, QWORD PTR [rbp-8]
  leave
  ret