程序集调用和RET堆栈
程序集调用是指在软件开发中，将多个程序模块（也称为程序集）组合在一起，以实现特定的功能。程序集调用可以通过调用程序集中的函数、方法或对象来实现。
RET堆栈（Return Stack）是一种用于存储函数调用返回地址的数据结构。在程序执行过程中，当一个函数被调用时，当前函数的返回地址会被保存在RET堆栈中，以便在函数执行完毕后能够返回到调用该函数的位置继续执行。
程序集调用和RET堆栈在软件开发中起着重要的作用。程序集调用可以实现模块化开发，将复杂的功能划分为多个程序集，提高代码的可维护性和复用性。RET堆栈则保证了函数调用的正确返回，避免了函数执行完毕后无法返回到正确的位置的问题。
在云计算领域，程序集调用和RET堆栈的概念同样适用。云计算平台提供了丰富的开发工具和服务，开发者可以将自己的程序集部署到云上，并通过程序集调用实现各种功能。RET堆栈则由云计算平台自动管理，确保函数调用的正确返回。
腾讯云提供了一系列与程序集调用和RET堆栈相关的产品和服务，例如云函数（Cloud Function）、容器服务（Tencent Kubernetes Engine）、虚拟机（Tencent Virtual Machine）等。这些产品和服务可以帮助开发者快速部署和管理程序集，并提供高可用性和弹性扩展的能力。
更多关于腾讯云相关产品和服务的详细介绍，请参考以下链接：
相关·内容
2回答
我编写了一个使用AT&T语法的程序，用于GNU汇编程序：
.data
format: .ascii "%d\n"
.text
.global main
main:
mov $format, %rbx
mov (%rbx), %rdi
mov $1, %rsi
call printf
ret
我用GCC来组装和连接：
gcc -o主板
浏览 1提问于2016-07-12得票数 17
回答已采纳
我目前正在学习x86汇编。然而，在使用堆栈进行函数调用时，我仍然不清楚一些事情。我知道调用指令将涉及将返回地址压入堆栈，然后用要调用的函数的地址加载程序计数器。ret指令将该地址加载回程序计数器。
我的困惑是，在过程/函数中调用ret指令有关系吗？它是否总是找到堆栈上存储的正确返回地址，或者堆栈指针当前必须指向存储返回地址的位置？如果是这样的话，难道我们不能只使用push和pop而不是call和ret吗？
例如，下面的代码可能是进入函数的第一个，如果我们在堆栈上推入不同的寄存器，是否必须只有在以相反的顺序弹出寄存器之后才调用ret指令，以便在pop%ebp指令之后，堆栈指针将指向堆栈上返回地址
浏览 3提问于2017-10-13得票数 2
2回答
正如标题所说，我想在我的C程序中打印堆栈的内容。
以下是我所采取的步骤：
我创建了一个简单的程序集(helper.s)文件，其中包括返回ebp寄存器地址的函数和返回esp寄存器地址的函数。
.globl get_esp get_esp: movl %esp，%eax ret # get_ebp定义类似，并包含在.globl部分中
我从C程序调用了get_esp ()和get_ebp ()函数( fpC = get_esp ();，其中fpC是int)
我(我想成功地)打印了我的esp和ebp寄存器( fprintf (stderr, "%x", fcP); )的地址
浏览 4提问于2012-02-02得票数 5
3回答
问题是:当按值返回时，临时对象在哪里分配？也就是说，在堆栈上，在动态分配的内存中，编译器在这种情况下会做什么？
我正在深入研究C++03中的move构造函数成语中的底层逻辑，如中所描述的，有趣的部分是如何返回对象：
struct foo {
int values[100];
...
};
foo func() {
foo ret;
... // assign value to ret
return ret;
}
int main() {
foo a(func());
...
return 0;
}
return ret;和a(
浏览 2提问于2013-09-08得票数 1
回答已采纳
我使用的是NASM，我有一个关于ret指令的问题。我知道我应该在ret之后指定我发送到堆栈的变量的数量，但是我如何动态地做到这一点呢？我试过了：
ret eax
和
ret dword[var]
但这两种方法都不管用。有没有办法做到这一点？
浏览 2提问于2016-07-14得票数 2
我试图跟随一个关于缓冲区溢出的教程(的缓冲区溢出Primer )。我实际上是遵循他的代码，它在演示中为他工作，并且在此之前一直为我工作。
下面的C程序的目标是将退出系统调用的外壳代码分配给一个变量，然后将指向__lib_start_main的主函数的默认返回地址替换为外壳代码变量的内存地址，以便程序在完成主函数后执行外壳代码，然后优雅地退出程序，其值为20 (如在“execiting (20)”中)。不幸的是，该程序以分段错误结束。我正在32位Linux上运行这个程序。我用gcc编译了代码，并用--ggdb和-mized-堆栈边界=2选项编译了它，我已经尝试了-fno-堆栈保护器选项和不带-f
浏览 1提问于2019-06-27得票数 2
回答已采纳
1回答
为什么不使用堆栈内存时会分配它？
、、、、
请考虑以下示例：
struct vector {
int size() const;
bool empty() const;
};
bool vector::empty() const
{
return size() == 0;
}
为vector::empty生成的程序集代码(通过clang进行优化)：
push rax
call vector::size() const
test eax, eax
sete al
pop rcx
ret
为什么要分配堆栈空间？它根本不被使用。push和pop可以省略。MSVC和gcc的优化构建也使
浏览 1提问于2020-01-07得票数 14
回答已采纳
我这里有一个下面的Koka代码片段，我希望有人能解释一下当调用处理程序时，堆栈框架会发生什么。我尝试通过打印值和全局计数器来使处理程序堆栈帧也可见，并且在表达式中去掉了垃圾。 effect foo<a> { control foo() : a }
fun main() {
var c:int := 0
val r = (handler {
return(x:int) { println("in RET ctrl: " ++ x.show); x*2 }
control foo() {
c := c + 1
浏览 12提问于2021-07-28得票数 1
回答已采纳
考虑以下程序： class C {
...
};
const C f() {
C ret;
cout << &ret << endl;
return ret;
}
int main() {
C value = f();
cout << &value << endl;
}
result: // note the address are the same
0x7ffdd24b26e0
0x7ffdd24b26e0 函数f()中的变量'ret‘和变量'value’具有
浏览 45提问于2016-07-06得票数 1
回答已采纳
4回答
import java.math.BigInteger;
import java.util.HashMap;
/**
*
* @author cypronmaya
*/
public class test {
static HashMap<Integer, BigInteger> cache = new HashMap<Integer, BigInteger>();
public static void main(String[] args) {
System.out.println(factorial(20000));
}
浏览 5提问于2012-02-05得票数 3
回答已采纳
1回答
我目前正在学习x86汇编语言(我刚开始学习这个课程)，我在理解堆栈在特定情况下是如何工作时遇到了一些问题。
假设我有这样的代码：
double(entier n) { return n + n; }
我尝试将其转换为x86代码，最后得到如下结果：
push ebp #save old pointer stack
mov ebp, esp #put new pointer stack
mov ebx, dword[ebp + 8] #get argument n and put it in ebx
add ebx, dword[ebp + 8] #add n to ebx
但是后来我被完全阻止
浏览 0提问于2019-04-20得票数 2
考虑以下空C程序(标准保证编译器执行隐式return 0)：
int main(int argc, char* argv[]) {}
您可以在此函数中添加操作argc和argv的任何逻辑。然而，当main完成时，它的组装代码只会执行一个简单的ret而不是ret 4。我希望看到一个ret 4，因为在我看来，main是其他函数的调用，因此必须清除堆栈中的两个参数: int和char数组指针。为甚麽不这样做呢？
浏览 0提问于2017-10-29得票数 1
回答已采纳
2回答
查找DLL的DLLs
、、、、
我为雷鸟做了延期。它(通过js)调用我编写的C++ DLL，然后引用其他DLL，这些DLL是用C# (现有代码)编写的程序集。如果所有文件都在雷鸟可执行文件所在的目录中，那么所有文件都能正常工作。
现在，我已经将自己的文件移到了我创建的目录中，以使它们与Thunderbird文件区别开来。目录位于路径中，因此调用时会加载我的C++ DLL。但是，当它开始查找引用的程序集时，它将失败。
Procmon显示，它只在运行Thunderbird的目录中查找引用的程序集。不仅没有路径，甚至没有查看系统目录。
如果不将所有内容转储到Thunderbird自己的文件夹中，那么我如何才能让DLL加载它的依赖项
浏览 10提问于2014-01-22得票数 1
回答已采纳
3回答
我有一个具有以下签名的非托管C++函数：
int function(char* param, int ret)
我正在尝试从C#调用它：
unsafe delegate int MyFunc(char* param, int ret);
..。
int Module = LoadLibrary("fullpathToUnamanagedDll");
IntPtr pProc = GetProcAddress(Module, "functionName");
MyFunc func = (MyFunc)System.Runtime.InteropServices.
浏览 3提问于2010-07-22得票数 4
回答已采纳
2回答
这是我第一次尝试使用std::future。
我想同时解析三个不同的文件。有三个函数可以做到这一点。称为parseSentences、parseTags和parseLinks。它们中的每一个都是通过使用一个非常简单的lambda函数std::async在单独的线程中启动的：[]() { parser->function(); }，其中parser是一个静态变量，而function是我之前命名的三个函数之一。
int parser::start()
{
int ret = SUCCESS;
ASSERT( m_output != nullptr );
static
浏览 2提问于2012-08-28得票数 3
回答已采纳
3回答
我正在尝试用汇编语言做一个子程序，它会在屏幕上画一个正方形。我不认为我可以像在C++中那样将参数传递给子程序，所以我认为可以使用堆栈来存储和访问参数(我不能使用公共数据寄存器，因为要传递的变量太多了)。
问题是(我记得在某处读过)，当我使用call命令访问当前“程序”的地址时，它被保存在堆栈中，因此当它使用"ret“命令时，它将知道返回到哪里。但是如果我在堆栈上存储一些东西，然后调用函数，我将不得不将地址保存在某个地方(即堆栈的顶部)，然后安全地弹出参数。然后，在代码完成之后，在调用"ret“之前，我必须推回地址。
我说的对吗？如果是，我可以在哪里存储地址(我不认为地址只有1字
浏览 2提问于2016-05-29得票数 7
回答已采纳
在gcc的装配中，主要功能可以是返回或退出，两者都在其中工作。这里我有两个程序，其中一个使用syscall int $0x80退出，另一个简单地调用ret。有什么关系？
.data
hello: .string "Hello, World!"
.globl main
main:
push %rbx
movq $hello, %rdi
call puts
pop %rbx
ret
和
.data
hello: .string "Hello, World!"
.globl main
main:
push %rbx
movq $hello
浏览 2提问于2018-07-15得票数 1
回答已采纳
2回答
我读到了尾递归和传统递归的区别，发现它提到“尾递归是一种不使用任何堆栈空间的递归形式，因此是一种安全使用递归的方法。”
我在努力弄明白怎么做。
用传统递归法和尾递归法求数的阶乘比较
传统递归
/* traditional recursion */
fun(5);
int fun(int n)
{
if(n == 0)
return 1;
return n * fun(n-1);
}
在这里，调用堆栈看起来就像
5 * fact(4)
|
4 * fact(3)
|
3 * fact(2)
|
浏览 2提问于2015-07-02得票数 2
回答已采纳
2回答
执行ret时，它会弹出(返回)地址并将其放入EIP寄存器中。
但是，所有函数的参数都留在堆栈上呢？我们只是无视他们，重新设置他们的ESP？(ESP+8，如果有两个args)
浏览 3提问于2022-05-06得票数 2
1回答
我试图在函数调用/返回期间分析Linux程序集堆栈初始化/清理，使用下面的代码片段。未初始化的变量是有意的。
#define MAX 16
typedef struct _CONTEXT {
int arr[MAX];
int a;
int b;
int c;
};
void init(CONTEXT* ctx)
{
memset(ctx->arr, 0, sizeof(ctx->arr[0]));
ctx->a = 1;
}
void process(CONTEXT* ctx)
{
int trash;
浏览 4提问于2013-11-22得票数 0
回答已采纳
2回答
我创建了一个函数来计算C字符串的长度(我试图使用-O3击败clang的优化器)。我在运行macOS。
_string_length1:
push rbp
mov rbp, rsp
xor rax, rax
.body:
cmp byte [rdi], 0
je .exit
inc rdi
inc rax
jmp .body
.exit:
pop rbp
ret
这是我想要击败的C函数：
size_t string_length2(const char *str) {
size_t ret = 0;
whil
浏览 3提问于2017-07-24得票数 5
回答已采纳
我开始学习程序集(在OSX上的NASM中有x86-64)，现在正在探索函数在其中的外观。
解释“调用约定”工作方式的大多数资源都显示了这样的示例：
// c code
MyFunction1(a, b);
// assembly code
main:
push a
push b
push rbp ; save frame pointer on stack
mov rsp, rbp ; save stack pointer in frame pointer
xor rax, rax ; set function return value to 0.
call _My
浏览 4提问于2014-12-22得票数 1
回答已采纳
1回答
我写了一个拼音工具。它在指令执行时为程序实现一个堆栈。在遇到调用指令的情况下，它将按顺序将下一条指令的地址推入堆栈。当调用的过程完成并且遇到返回指令时，它验证ret指令中的目标地址是否等于堆栈的顶部，并弹出该顶部。
正常情况下，调用指令的数量应该等于返回指令的数量。但是这个工具会监控大量的返回指令。这怎麽可能？有什么问题吗？我该怎么解决它呢？
编辑1：
pintool的代码
VOID f_jump(int a, int b)
{
s.push(b);
cout<<s.top()<<"\t";
icount1++;
}
VOID f_ret(in
浏览 13提问于2017-07-26得票数 1
回答已采纳
我试图通过GAS来理解堆栈框架，这里展示了一个递归函数汇编案例，它是一个32位x86程序，用于Linux：
.section .data
.section .text
.globl _start
.globl factorial
_start:
pushl $3
call factorial
popl %ebx
movl %eax, %ebx
movl $1, %eax
int $0x80
.type factorial, @function
factorial:
pushl %ebp
movl %esp, %ebp
浏览 0提问于2022-03-29得票数 0
回答已采纳
1回答
我是新来的。我想做一个子程序，我需要遵循惯例。调用者将值放入寄存器中，然后推送到堆栈。在子程序中，您需要从堆栈中提取，但我有一些问题。这是我的代码：
.286
.model huge
.stack 100h
mov bl, 'd' ; just put d to test
push bx
call putch
call terminate
; ---------- void putch(char c) ----------
putch:
; Print character into screen
; bl <- character to be printed
mo
浏览 3提问于2015-01-28得票数 1
回答已采纳
4回答
我的编程语言编译成C，我想要实现尾递归优化。这里的问题是如何在不从当前函数“返回”的情况下将控制传递给另一个函数。
如果将控件传递给相同的函数，则非常容易：
void f() {
__begin:
do something here...
goto __begin; // "call" itself
}
如您所见，没有返回值，也没有参数，这些参数在一个由全局变量嵌入的单独堆栈中传递。
另一个选项是使用内联程序集：
#ifdef __clang__
#define tail_call(func_name) asm("jmp " fu
浏览 0提问于2018-02-06得票数 8
1回答
我遵循Grey黑客中的缓冲区溢出示例，成功地执行了外壳代码，并使用下面的利用程序打开了一个shell，但是，由于初始ESP值的不同，如果不首先猜测缓冲区的偏移量，我就无法运行它。
这是针对任何本地、易受攻击的缓冲区的利用程序(删除了一些行)：
unsigned long get_sp(void){
__asm__("movl %esp, %eax");
}
int main(int argc, char *argv[1]) {
int i, offset = 0;
unsigned int esp, ret, *addr_ptr;
char *
浏览 2提问于2014-09-17得票数 1
回答已采纳
1回答
我编写了一个最小的函数来测试我是否能够调用/链接C和x86_64汇编代码。
这是我的main.c
#include <stdio.h>
extern int test(int);
int main(int argc, char* argv[])
{
int a = 10;
int b = test(a);
printf("b=%d\n", b);
return 0;
}
这是我的test.asm
section .text
global test
test:
mov ebx,2
add e
浏览 2提问于2022-05-16得票数 0
我了解推栈函数是如何工作的，我也知道如何将它用于插件(我猜这就是它最常用的地方，仅用于内部使用和end()正常工作和其他类似方法)。
下面是推堆栈的jquery源代码，请看一看：
pushStack: function( elems ) {
// Build a new jQuery matched element set
var ret = jQuery.merge( this.constructor(), elems );
// Add the old object onto the stack (as a reference)
ret.prevObject
浏览 0提问于2015-06-22得票数 0
回答已采纳
1回答
使用以下示例，ESP和EIP寄存器之间的区别是什么？解释代码在做什么。
main PROC
0000 0020 call MySub
0000 0025 mov eax, ebx
.
.
main ENDP
MySub PROC
0000 0040 mov eax, edx
.
.
ret
MySub ENDP
00000 0025是紧跟在CALL指令之后的指令的偏移量
00000 0040是MySub内部第一条指令的偏移量
CALL指令将0000 0025压入堆栈，并将00
浏览 1提问于2016-10-30得票数 3
回答已采纳
2回答
“对齐堆栈”在组装中意味着什么？
、、、、
在ASMx64中，堆栈对齐是如何工作的？什么时候需要在函数调用之前对齐堆栈，需要减去多少？
我不明白它的目的是什么。我知道还有其他关于这件事的帖子，但对我来说还不够清楚。例如：
extern foo
global bar
section .text
bar:
;some code...
sub rsp, 8 ; Why 8 (I saw this on some posts) ? Can it be another value ? Why do we need to substract?
call foo ; Do we need to align sta
浏览 1提问于2020-11-07得票数 3
回答已采纳
以这个有争议的代码为例。
struct X {
int arr[1];
float something_else;
};
struct X get_x(int first)
{
struct X ret = { .arr = { first } };
return ret;
}
int main(int argc, char **argv) {
int *p = get_x(argc+50).arr;
return *p;
}
get_x返回一个struct X。我只对它的成员arr感兴趣。如果我只想要arr，为什么
浏览 8提问于2021-03-26得票数 10
回答已采纳
6回答
在行为良好的C程序中，return语句(RET)是否应该始终返回到CALL语句后面的指令？我知道这是默认的，但我想检查是否有人知道或记得这个标准不适用的真实例子(常见的编译器优化或其他事情...)。有人告诉我，这可能发生在函数指针上(函数指针会将值放在堆栈上，而不是调用...我搜索了它，但我没有看到任何地方的解释)。
让我试着更好地解释我的问题。我知道我们可以使用其他结构来改变执行流程(包括操纵堆栈)……我知道如果我们改变写在堆栈上的返回地址，执行流程就会变成写在堆栈上的地址。我需要知道的是:有没有不寻常的执行情况，下一条指令不是调用之后的指令？我的意思是，我希望确保它不会发生，除非发生了一些
浏览 0提问于2012-03-10得票数 4
我正在阅读类似DEP的堆栈溢出保护机制，并编写了可以使用Ret2plt和system()绕过它的文章。
什么是Ret2plt，它是如何工作的？我在谷歌上找不到一个关于这个词的解释。
浏览 0提问于2017-03-30得票数 3
4回答
我有一个存储过程，如果存储过程这样做：
SELECT 0 As Ret
DELETE FROM table where value1 = 1
返回1行结果，其值为0，列名为Ret
但如果我这样做：
DELETE FROM table where value1 = 1
SELECT 0 As Ret
我没有得到返回的结果。
我的问题是，如何让第二个变量返回值。
我正在使用C++和ODBC。
浏览 3提问于2009-02-05得票数 0
回答已采纳
2回答
出口程序x86
、、、
我正在学习x86程序集。我试图了解“退出程序”如何在x86上工作。我们有一个密码：
push ebp
mov ebp,esp
//Some stuff here
mov esp, ebp
pop ebp
ret
当处理器执行指令"ret“时：
EIP将具有从堆栈中弹出的值，换句话说，是0。处理器将进入0地址并尝试执行指令.它不包含程序代码/可执行代码。那么，处理器到底是怎么回事呢？是否有条件检查，例如，if EIP = 0 -> exit program? Or if ESP out of bounds -> exit program?‘如何理解这个RET指令是程序的结束？
浏览 5提问于2015-09-05得票数 0
回答已采纳
1回答
我使用x86_64程序集中的单链接列表编写了一个堆栈实现。这个堆栈支持通常的push/pop操作，以及迭代每个元素的第一个/下一步操作。
我在找一般的反馈。
下面是堆栈子例程：
; Stack Structure
; Pointer Head
; Pointer Current
; Stack Node
; Pointer Next
; Pointer Value
; input
; void
; output
; stack or 0 on error
StackCreate:
mov rdi, 24
call malloc
test rax,rax
浏览 0提问于2014-04-02得票数 27
回答已采纳
1回答
我有以下代码(caller.c)：
#include <stdio.h>
extern int callee(int);
int main(int argc, char *argv[]){
callee(4);
return 1;
}
和(被叫)：
.globl callee
callee:
pop %eax
add $4, %eax
ret
我用: gcc -m32 caller.c callee.s编译
然后跑：
./a.
分段故障(堆芯倾弃)
我想知道我的错误是什么，因为我认为main现在应该推送32口的堆栈号。我没有更改堆栈，因此被调用者现在应该能
浏览 2提问于2017-04-18得票数 3
回答已采纳
我一直在考虑堆栈溢出的基本问题，从不适用于NX位的经典shell代码注入到更新的ROP小工具。
我的第一个问题是关于有分支寄存器的中央处理器。就像Itanium所做的那样，在跟踪分支寄存器“堆栈”中的CPU上进行任何这类攻击似乎都是很困难的，如果可能的话。显然，还有其他的攻击不需要覆盖返回IP，但是分支寄存器和NX位的组合是否会导致大量攻击呢？如果是这样的话，为什么人们不考虑使用使用分支寄存器的处理器架构来处理边缘设备呢？
下面的问题是，为什么Intel/AMD不采用一种操作模式来验证和执行一系列调用/RET指令？看起来真正的问题是CPU将返回in的跟踪放在堆栈上，由进程来处理。简单地不将返回
浏览 0提问于2013-11-29得票数 1
回答已采纳
1回答
调用例程后访问推送args
、、、、
我正在使用x86和nasm学习FreeDOS组装。我有一个小测试程序，它所做的就是把A打印到屏幕上，然后退出。
如果我不使用写例程，它就能正常工作。
但是，当我把A推到堆栈上，然后调用，写它，把下一个IP放到堆栈上时，当我在例程中弹出A时，我得到的是IP，而不是我推送的值。
我相信这是很简单的事情，但我看不出问题所在。
segment data ; start of data segment
segment code ; start of code segment
..start:
label1:
top:
浏览 3提问于2020-03-09得票数 0
回答已采纳
6回答
给定具有入口点的程序集，如：
int FooClass::doFoo(int x, double y)
{
int ret;
// Do some foo
return ret;
}
是否可以使用另一个程序集来模拟以下内容：
int FooClass::doFoo(int x, double y)
{
int ret;
TRACE_PARAM_INT(x)
TRACE_PARAM_DOUBLE(y)
// Do some foo
TRACE_RETURN_INT(ret)
return ret;
}
并且只有在调试存在时才启用此代码注入。如
浏览 14提问于2009-08-14得票数 2
回答已采纳
3回答
我在main开头查看堆栈，但是main的ebp丢失了。
我声明了一个变量来检查它在堆栈上的位置，结果发现这个变量和n __libc_start_main的返回地址之间是零的！
我正在使用的系统
I'm using fedora Linux 3.1.2-1.fc16.i686
ASLR is disabled.
Debugging with GDB.
下面是代码：
void main(){
char ret ='a';
}
登记资料：
(gdb)
eax 0x1 1
ecx 0xbffff5f4
浏览 1提问于2011-12-13得票数 0
回答已采纳
1回答
我知道RVO在一般情况下是可取的，但是当它不能应用时会发生什么呢？具体而言，生成的程序集代码如何将本地类/结构实例返回给其调用方？
MyClass callee() {
MyClass a;
/* RVO is disabled */
return a;
}
void caller() {
/* RVO is disabled */
MyClass b = no_rvo();
}
在这种情况下，堆栈是什么样子的？caller()和callee()是否分别在堆栈上为a和b分配空间，然后将a复制到b？如果是这样的话，那么callee()末尾的RET语句是否
浏览 0提问于2019-05-29得票数 1
回答已采纳
全,
ret = SQLForeignKeys( stmt_fk, NULL, 0, NULL, 0, NULL, 0, catalogName, SQL_NTS, schemaName, SQL_NTS, tableName, SQL_NTS );
if( ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO )
{
// error handling
}
bool fkFound = false;
for( ret = SQLFetch( stmt_fk ); ( ret == SQL_SUCCESS || ret =
浏览 0提问于2018-06-08得票数 0
我对大会有一点了解。让我先介绍一下密码，然后解释一下我的思维方式。
#This is the Assembly version.
pushq %rbp
movq %rsp, %rbp
movl $2, -4(%rbp)
movl $3, -8(%rbp)
movl $5, %eax
popq %rbp
ret
#This is the C version.
int twothree() {
int a = 2;
int b = 3;
return 2 + 3;
}
好的，第一件事是，我们没有用变量a和b作为a+b，所以它们是不必要
浏览 7提问于2022-04-11得票数 2
回答已采纳
2回答
堆栈和引用传递
、、、、
假设我有这个结构。
typedef struct Symbol {
char* name;
/* Other variables declared here... */
struct Symbol *next;
}Symbol;
我想要做的是在堆栈中插入一些这些符号。除了其他的the，这些符号将被插入。因此，我创建了一个func类型的结构来处理堆栈，如下所示：
typedef struct func{
Symbol* sym;
struct func* next
}func;
并声明了一个指向堆栈func* funcstack;的指针，该指针将用作我的
浏览 1提问于2016-05-31得票数 0
回答已采纳
2回答
我为一种语言实现了一个编译器和虚拟机。该实现是在C#中实现的，基于堆栈的VM使用反射对一组内置程序进行函数调用。
大部分代码只需简单地推送和弹出堆栈值，但工作马是函数调用。当前，函数调用的实现如下所示：
var calli = gencode[pc++] as CallInfo;
var calla = PopStackList(calli.NumArgs).ToArray();
var ret = calli.MethodInfo.Invoke(instance, calla);
if (ret != null) PushStack(ret);
浏览 3提问于2017-09-06得票数 1
回答已采纳
1回答
我正在尝试在linux机器上测试绝对路径，以找出程序所在的位置，这样我就可以使用我的特定参数来运行它。问题是，当我找到它时，我不断地将更多的字符串添加到正确的路径中，并通过释放动态分配的内存来避免内存泄漏。堆栈转储的唯一修复方法是不释放(Ret)。我相信，基于gdb，当我使用"ls“运行一个示例时，它会找到程序并运行它，但会产生奇怪的结果。
for(j = 0; j < i; j++, path = NULL)
{
token = strtok_r(path, delim, &saver);
if(token == NULL)
break;
e
浏览 2提问于2011-09-27得票数 0
1回答
我目前正在手工编写x86程序集(FASM)，我经常犯的一个典型错误是在堆栈上push一个参数，但在执行pop之前返回。
这将导致调用方的堆栈偏移量发生变化，这将导致程序崩溃。
这是一个粗略的例子来说明：
proc MyFunction
; A loop:
mov ecx, 100
.loop:
push ecx
; ==== loop content
...
; Somewhere, the decision is made to return, not just to exit the loop
jmp .ret
浏览 4提问于2021-06-24得票数 2
回答已采纳
2回答
我想从程序堆栈中检索参数，通过它们在内存中的连续相对位置，但是它失败了，对下面的代码片段有什么想法吗？
#include <stdio.h>
int __cdecl sum(int num, ...) {
int* p = &num + 1;
int ret = 0;
while(num--) {
ret += *p++;
}
return ret;
}
int __cdecl main(int argc, char** argv) {
printf("%d\n", sum(3, 1, 2, 3)); // wrong
浏览 3提问于2020-06-24得票数 0
回答已采纳
扫码
添加站长 进交流群
领取专属 10元无门槛券
手把手带您无忧上云
相关资讯
热门标签
云服务器
ICP备案
实时音视频
对象存储
云直播活动推荐
腾讯云开发者
