setjmp()/longjmp()的使用方法和场合

setjmp和longjmp.为了让你实现复杂的流控制,程序在系统里面运行完全依靠内存(代码段,全局段,堆存储器,栈存储器)和寄存器的内容(栈指针,基地址,计数器),setjmp保存当前的寄存器里面的内容,longjmp是恢复这些内容.longjmp返回setjmp程序当前的状态.

#include < setjmp.h >
int setjmp(jmp_buf env);

保存当前寄存器的状态到env这个结构体里面.

这个结构体定义如下:

#define _JBLEN  9
typedef struct { int _jb[_JBLEN + 1]; } jmp_buf[1];
这是一个气人的方法,这是一个长度为_JBLEN + 1整型的数组,当调用setjmp的时候,存储寄存器的数字在这个数组里面.函数的返回值为0.

longjmp(jmp_buf env, int val);longjmp将数组里面存储的内容恢复到寄存器里面.但是longjmp没有返回值.与之相反的是,当调用它的时候,只要你在调用setjmp保存了env,就OK了.因为其他寄存器被存储,PC才被保存.Setjmp返回的值可以作为longjmp的参数val,但是不能为零.因此,如果setjmp返回非零值,并且返回值作为longjmp的参数,这样longjmp恢复的就是这个setjmp的环境.

这里有一个小例子:

#include < setjmp.h >

main()
{
  jmp_buf env;
  int i;

  i = setjmp(env);
  printf("i = %d\n", i);

  if (i != 0) exit(0);

  longjmp(env, 2);
  printf("Does this line get printed?\n");

}
运行结果是:

UNIX> sj1
i = 0
i = 2
UNIX>

这里setjmp返回的值为0,因此我用2作为longjmp的参数.这个让代码从setjmp位置返回并且返回值为2.值被打印出,并且程序退出.

如果程序在反复或者递归调用的过程中被检测出来了某个错误,利用setjmp和longjmp程序能在高层次被很好的处理掉.看下面一个例子:

#include <setjmp.h>
#include <stdio.h>


int proc_4(jmp_buf env, int i)
{
  if (i == 0) longjmp(env, 1);
  return 14 % i;
}
 
int proc_3(jmp_buf env, int i, int j)
{
  return proc_4(env, i) + proc_4(env, j);
}

int proc_2(jmp_buf env, int i, int j, int k)
{
  return proc_3(env, i, k) + proc_3(env, j, k);
}

int proc_1(jmp_buf env, int i, int j, int k, int l)
{
  return proc_2(env, i, j, k+1);
}


main(int argc, char **argv)
{
  jmp_buf env;
  int sj;
  int i, j, k, l;

  if (argc != 5) {
    fprintf(stderr, "usage: sj2 i j k l\n");
    exit(1);
  }

  sj = setjmp(env);
  if (sj != 0) {
    printf("Error -- bad value of i (%d), j (%d), k (%d), l (%d)\n",
           i, j, k, l);
    exit(0);
  }

  i = atoi(argv[1]);
  j = atoi(argv[2]);
  k = atoi(argv[3]);
  l = atoi(argv[4]);
 
  printf("proc_1(%d, %d, %d, %d) = %d\n", i, j, k, l, proc_1(env, i, j, k, l));
}
这个程序看起来是复杂的,但是实际上并不是这样.在这么复杂的调用程序的过程,到底什么发生了呢?proc_1调用了proc_4.如果proc_4的参数是0,调用longjmp将出现错误.否则处理正常.从这里看,如果你调用sj2传递非负参数,运行成功.如果传递参数全部是0,当你调用longjmp的时候,提示一个错误.

现在setjmp保存了所有的寄存器,包括sp和fp.这个意思就是调用setjmp之后,setjmp的env将不在可用.因为它存储了进程的sp和fp.当你恢复的时候,程序返回.堆栈是不同的状态和以前,并且你将有一个错误.请看例sj3.c

 

#include <setjmp.h>#include <stdio.h>int a(char *s, jmp_buf env){int i;i = setjmp(env);printf("Setjmp returned -- i = %d, 0x%x\n", i, s);printf("s = %s\n", s);return i;}int b(int i, jmp_buf env){printf("In B: i=%d.  Calling longjmp(env, i)\n", i);longjmp(env, i);}main(int argc, char **argv){jmp_buf env;if (a("Jim", env) != 0) exit(0);b(3, env);}

执行结果如下:

UNIX> sj3
Setjmp() returned -- i = 0
s = Jim
In B: i=3.  Calling longjmp(env, i)
Setjmp() returned -- i = 3
Segmentation fault (core dumped)
UNIX>
当main第一次运行的时候,到底什么发生了.它的堆栈如下显示:

        Stack       
        |--------------   |
        |                      |
        |                      |
        |                      |
        |                      |
        |                      |
        |                      | <-------- sp
        | env[0]            |
        | env[1]            |
        | env[2]            |               pc = main
        | env[3]            |
        | ....                 |
        | env[8]            |
        | other stuff      | <------- fp
        |--------------- |
当main调用a()的时候,将反顺序将参数压入栈中,并且这个时候jsr被调用,压返回的ps和老的fp到堆栈中.fp和sp被改变为了建立一个空的堆栈为了调用a().

        Stack        
                                    |---------------- |
                                    |                        |
                                    |                        | <--------- sp, fp
                /------------- | old fp in main    |
                |                   | old pc in main   |
                |   "Jim" <---  | s = "Jim"          |
                |         /---     | pointer to env   |
                |         \-->    | env[0]              |
                |                   | env[1]              |
                |                   | env[2]              |               pc = a
                |                   | env[3]              |
                |                   | ....                   |
                |                   | env[8]              |
                \------------> | other stuff       |
                                     |---------------  |

首先a()分配空间给局部变量i.

          Stack       
                                    |----------------|
                                    |                       | <--------- sp
                                    |      i                 | <--------- fp
                /------------- | old fp in main   |
                |                   | old pc in main   |
                |   "Jim" <---  | s = "Jim"          |
                |         /---     | pointer to env   |
                |         \-->    | env[0]              |
                |                   | env[1]              |
                |                   | env[2]              |               pc = a
                |                   | env[3]              |
                |                   | ....                   |
                |                   | env[8]              |
                \------------> | other stuff    |
                                     |--------------- |
这个时候调用setjmp,保存当前寄存器当前状态.总之,它保存当前的状态值sp,fp和pc.现在 a()打印"i=0",并且"s=jim",然后返回.现在堆栈和以前一样,除了env在a()内被机器的状态初始化了.

            Stack       
                               |----------------|
                               |                      |
                               |                      |
                               |                      |
                               |                      |
                               |                      |
                               |                      | <----------- sp
                               | env[0]            |
                               | env[1]            |
                               | env[2]            |               pc = main
                               | env[3]            |
                               | ....                 |
                               | env[8]            |
                               | other stuff      | <------------ fp
                               |--------------- |
这时main调用b(),并且堆栈如下显示:

           Stack       
                               |----------------|
                               |                |
                               |                | <--------- sp, fp
                /------------- | old fp in main |
                |              | old pc in main |
                |              | i = 3          |
                |         /--- | pointer to env |
                |         \--> | env[0]         |
                |              | env[1]         |
                |              | env[2]         |               pc = b
                |              | env[3]         |
                |              | ....           |
                |              | env[8]         |
                \------------> | other stuff    |
                               |--------------- |

此时longjmp被调用,寄存器被恢复到a()调用setjmp的状态.并且pc返回到a函数中的setjmp.然而堆栈的值是和b()一样.

        Stack       
                               |----------------|
                               |                | <--------- sp
                               | i = 2          | <--------- fp
                /------------- | old fp in main |
                |              | old pc in main |
                |              | s??    = 3     |
                |         /--- | pointer to env |
                |         \--> | env[0]         |
                |              | env[1]         |
                |              | env[2]         |               pc = a
                |              | env[3]         |
                |              | ....           |
                |              | env[8]         |
                \------------> | other stuff    |
                               |--------------- |
你应该看到这个问题.堆栈是在一个错误的状态.特别是a()中显示字符地址s,代替这个地址的数值是3.这样,当程序想打印出s的时候,程序尝试在内存位置3找到一个字符串,发生段错误.这是一个非常普便的bug,为了合适的用它们,你不能返回从调用了setjmp的程序中.