从lua的c源码了解lua栈结构和函数调用流程

Posted 2021-11-27 winsons

因为实习需要用到lua所以最近在学习lua，在学习过程中我使用C++与lua做交互。正常来说，如果lua要调用C++的函数，C++需要返回一个整数，这个整数的值是这个C++函数需要返回给lua调用的值的个数。这样的做法才是正确的，只是我突然间想了下，如果我返回一个不正确的值会怎样呢?于是我这么做了，然后数据如预料之中变得很不正常。然后我又在想，为什么我返回不正确的值lua会得到这样的数据呢。于是我开始了lua的C源码分析。其实就是给自己挖了个大坑23333，然后我又是属于那种有问题没解决心里仿佛有块石头压着的那种人。没办法，只好硬着头皮上了。

一、问题建立

实验代码：

main.cpp

#include <iostream>
#include <string>
#include "lua.hpp"
#include "Utils.hpp"

int CGetPow(lua_State *l)
{
    lua_pushstring(l, "hello");
    lua_pushstring(l, "world");
    StackDump(l);
    return 2;
}



int main(int argc, const char *argv[])
{
    using namespace std;
    int error,error1,error2;
    string fname;
    fname = argv[1]; 
    lua_State *L = luaL_newstate();
    luaL_openlibs(L);
    lua_pushstring(L, "fuck");
    lua_pushcfunction(L, CGetPow);
    lua_setglobal(L, "pow");
    error1 = luaL_loadfile(L, fname.c_str());
    error2 = lua_pcall(L, 0, 0, 0);
    error = error1 || error2;
    if (error)
    {
        std::cout << fname << std::endl;
        fprintf(stderr, "%s\\n", lua_tostring(L, -1));
        lua_pop(L, 1);
    }
    lua_close(L);
    return 0;
}

 StackDump的作用是打印栈上的内容：

void StackDump(lua_State *l)
{
    int top = lua_gettop(l);
    std::cout << "Stack: ";
    for (int i = 1; i <= top; i++)
    {
        int t = lua_type(l, i);
        switch (t)
        {
        case LUA_TSTRING:
            std::cout << "‘" << lua_tostring(l, i) << "‘";
            break;
        case LUA_TBOOLEAN:
            std::cout << lua_toboolean(l, i) ? "true" : "false";
            break;
        case LUA_TNUMBER:
            std::cout << lua_tonumber(l, i);
            break;
        default:
            std::cout  << lua_typename(l, t);
            break;
        }
        std::cout << "\\t";
    }
    std::cout << std::endl;
}

test.lua

print(pow(2,3))--这句是最主要的，下面三个输出只是为了对比函数而已
print("print",print)
print("pow",pow)

print("test.lua",debug.getinfo(1, "f").func)

　

现在，CGetPow返回的整数是2，而函数中push的内容也的确只有两个，所以，它会很正常的返回"hellow"和"world"内容，输出：

如上图所示，print(pow(2,3))的输出是 hello world（下面三行还没用到，可以先无视）。

然后第一次，把CGetPow的返回改为5，它会输出：

这时候输出变成了function：xxxxx  2  3  hello  world，第一个function:xxxxxx可以由下面的函数对照发现是pow函数，也就是CGetPow，从这时候看好像看起来还是栈结构，虽然它返回来我们不需要的参数2和3和正在CGetPow函数.

第二次，把CGetPow的返回改为8，输出为：

由函数对照发现，输出在重复：fuck，加载test.lua生成的函数，print函数。这时候它的输出又不像一个栈结构了，因为2,3，hello，world不见了。为什么会这样呢？lua是怎么push值到栈中的，怎么从栈中取值的，函数调用到底干了什么？我决定通过分析lua的c源码来弄明白这些问题。

 

二、源码分析

1、lua_State和栈的初始化

　　lua_State由lua_newstate创建：

LUA_API lua_State *lua_newstate (lua_Alloc f, void *ud) {
  int i;
  lua_State *L;
  global_State *g;
　//LG由传进来的f进行分配，其中就已经包含了lua_State
  LG *l = cast(LG *, (*f)(ud, NULL, LUA_TTHREAD, sizeof(LG)));
  if (l == NULL) return NULL;
　//从LG中取出要返回的lua_State
  L = &l->l.l;
  g = &l->g;
  L->next = NULL;
  L->tt = LUA_TTHREAD;
  g->currentwhite = bitmask(WHITE0BIT);
  L->marked = luaC_white(g);
  preinit_thread(L, g);
  g->frealloc = f;
  g->ud = ud;
  g->mainthread = L;
  g->seed = makeseed(L);
  g->gcrunning = 0;  /* no GC while building state */
  g->GCestimate = 0;
  g->strt.size = g->strt.nuse = 0;
  g->strt.hash = NULL;
  setnilvalue(&g->l_registry);
  g->panic = NULL;
  g->version = NULL;
  g->gcstate = GCSpause;
  g->gckind = KGC_NORMAL;
  g->allgc = g->finobj = g->tobefnz = g->fixedgc = NULL;
  g->sweepgc = NULL;
  g->gray = g->grayagain = NULL;
  g->weak = g->ephemeron = g->allweak = NULL;
  g->twups = NULL;
  g->totalbytes = sizeof(LG);
  g->GCdebt = 0;
  g->gcfinnum = 0;
  g->gcpause = LUAI_GCPAUSE;
  g->gcstepmul = LUAI_GCMUL;
  for (i=0; i < LUA_NUMTAGS; i++) g->mt[i] = NULL;
  if (luaD_rawrunprotected(L, f_luaopen, NULL) != LUA_OK) {
    /* memory allocation error: free partial state */
    close_state(L);
    L = NULL;
  }
  return L;
}

展开lua_rawrunprotected

int luaD_rawrunprotected (lua_State *L, Pfunc f, void *ud) {
  ......
  LUAI_TRY(L, &lj,
    (*f)(L, ud);
  );
  ......
}

 

发现调用了传进来的f_luaopen函数，追踪这个函数

static void f_luaopen (lua_State *L, void *ud) {
  ......
  stack_init(L, L);  /* init stack */
  ......
}

 

由作者注释可知stack_init是初始化栈的函数，找到这个函数的实现

static void stack_init (lua_State *L1, lua_State *L) {
  int i; CallInfo *ci;
  /* initialize stack array */
  L1->stack = luaM_newvector(L, BASIC_STACK_SIZE, TValue);
  L1->stacksize = BASIC_STACK_SIZE;
  for (i = 0; i < BASIC_STACK_SIZE; i++)
    setnilvalue(L1->stack + i);  /* erase new stack */
  L1->top = L1->stack;
  L1->stack_last = L1->stack + L1->stacksize - EXTRA_STACK;
  /* initialize first ci */
  ci = &L1->base_ci;
  ci->next = ci->previous = NULL;
  ci->callstatus = 0;
  ci->func = L1->top;
  setnilvalue(L1->top++);  /* ‘function‘ entry for this ‘ci‘ */
  ci->top = L1->top + LUA_MINSTACK;
  L1->ci = ci;
}

分析得知：lua_State由luaM_newvector初始化并返回一个基地址给L1->stack，栈的大小为40（由BASIC_STACK_SIZE的宏定义得到），然后初始化把栈上的值全设置为nil，设置栈最后一个元素的地址L1->stack_last，初始化当前调用信息L1->ci，把lua_State的top设置为第一个栈上的第二个空元素（第一个是空元素已经被用作ci了，所以不能使用），设置ci的top（其实相当于ci作为栈基，然后ci这个栈的长度为LUA_MINSTACK，也就是20，在这个栈中push时不能超过这个长度，除非重新设置栈长度）。

 

2、lua从栈中取数据和往栈中push数据

首先是取数据，这里用lua_tointegerx作例子

LUA_API lua_Integer lua_tointegerx (lua_State *L, int idx, int *pisnum) {
  lua_Integer res;
　 //重点是这句，TValue是lua中用的最多的数据结构，index2addr则是根据传入的栈索引从栈取出数据
  const TValue *o = index2addr(L, idx);
  int isnum = tointeger(o, &res);
  if (!isnum)
    res = 0;  /* call to ‘tointeger‘ may change ‘n‘ even if it fails */
  if (pisnum) *pisnum = isnum;
  return res;
}

查看TValue的数据结构

//Value是具体的值，tt_则是定义好的数据类型，数据类型在lua中也是使用宏定义设置的
#define TValuefields    Value value_; int tt_

typedef struct lua_TValue {
  TValuefields;
} TValue;

展开index2addr的实现：

static TValue *index2addr (lua_State *L, int idx) {
 //当前调用函数的信息
  CallInfo *ci = L->ci;
  if (idx > 0) {
    //在栈基(这里的栈基不是指整个lua_State的栈基，而是当前调用函数信息的栈基，也可以简单理解成就是当前函数在栈中的地址)基础上加上传进来的索引获取到正确的数据
    TValue *o = ci->func + idx;
    //下面是检测数据正确性
    api_check(L, idx <= ci->top - (ci->func + 1), "unacceptable index");
    if (o >= L->top) return NONVALIDVALUE;
    //返回获取到的数据
    else return o;
  }
   ......
}

通过index2addr从栈中获取到数据，然后在根据tt_获取到数据类型，得到对应的值。lua_tolstring,lua_toboolean等基本都是这样从栈中取数据。

然后是向栈中push数据。这里以lua_pushinteger做例子：

#define api_incr_top(L) {L->top++; api_check(L, L->top <= L->ci->top,                 "stack overflow");}
#define setivalue(obj,x) \\
{ TValue *io=(obj); val_(io).i=(x); settt_(io, LUA_TNUMINT); }


LUA_API void lua_pushinteger (lua_State *L, lua_Integer n) {
  lua_lock(L);
  setivalue(L->top, n);
  api_incr_top(L);
  lua_unlock(L);
}

这里所做的操作显示把L->top指向的空元素设置为想要设置的元素，然后再把L->top只向下一个空元素，期间同样会涉及到向栈推元素需要做的安全性检查。push其他类型元素的操作也和这个操作原理一样。

 

3、函数的调用

通常我们在C中调用函数，会先push要调用的函数，然后再按顺序push参数，最后使用lua_pcall指定lua_state,参数个数以及返回个数。先来分析源码

//lua_pcall是个宏定义，展开后是lua_pcallk()
#define lua_pcall(L,n,r,f)    lua_pcallk(L, (n), (r), (f), 0, NULL)

//看看lua_pcallk的实现，代码太多，只展示要说明的
LUA_API int lua_pcallk (lua_State *L, int nargs, int nresults, int errfunc,
                        lua_KContext ctx, lua_KFunction k) {
  struct CallS c;
  int status;
  ptrdiff_t func;
  lua_lock(L);
  //检查正确性
  api_check(L, k == NULL || !isLua(L->ci),
    "cannot use continuations inside hooks");
  api_checknelems(L, nargs+1);
  api_check(L, L->status == LUA_OK, "cannot do calls on non-normal thread");
  checkresults(L, nargs, nresults);
  //errfunc为0代表没指定错误处理函数
  if (errfunc == 0)
    func = 0;
  else {
    ......
  }
  //c.func通过栈的运算获得，是要调用的函数在栈上的位置
  c.func = L->top - (nargs+1);  /* function to be called */
  //k为空代表没有延续
  if (k == NULL || L->nny > 0) {  /* no continuation or no yieldable? */
    //设置返回结果个数
    c.nresults = nresults;  /* do a ‘conventional‘ protected call */
     //luaD_pcall才是重点，在这里传进去了f_call函数
    status = luaD_pcall(L, f_call, &c, savestack(L, c.func), func);
  }
  else {  /* prepare continuation (call is already protected by ‘resume‘) */
    ......    
  }
  //调整栈顶位置
  adjustresults(L, nresults);
  lua_unlock(L);
  return status;
}

//展开luaD_pcall
int luaD_pcall (lua_State *L, Pfunc func, void *u,
                ptrdiff_t old_top, ptrdiff_t ef) {
  ......
  //在这里调用了上一步传进来的f_call函数
  status = luaD_rawrunprotected(L, func, u);
  ......
}

//继续展开f_call函数
static void f_call (lua_State *L, void *ud) {
  struct CallS *c = cast(struct CallS *, ud);
  //f_call里有调用了luaD_callnoyield函数
  luaD_callnoyield(L, c->func, c->nresults);
}

//展开luaD_callnoyield函数
void luaD_callnoyield (lua_State *L, StkId func, int nResults) {
  L->nny++;
  //好吧，继续看看这个
  luaD_call(L, func, nResults);
  L->nny--;
}

void luaD_call (lua_State *L, StkId func, int nResults) {
  if (++L->nCcalls >= LUAI_MAXCCALLS)
    stackerror(L);
  //重点函数：luaD_precall，展开之
  if (!luaD_precall(L, func, nResults))  /* is a Lua function? */
    luaV_execute(L);  /* call it */
  L->nCcalls--;
}

int luaD_precall (lua_State *L, StkId func, int nresults) {
  lua_CFunction f;
  CallInfo *ci;
  switch (ttype(func)) {
    case LUA_TCCL:  /* C closure */
      f = clCvalue(func)->f;
      goto Cfunc;
    case LUA_TLCF:  /* light C function */
      f = fvalue(func);
     Cfunc: {
      //n是c函数中返回的值
      int n;  /* number of returns */
       //栈检查，这个没细看，都是些检查安全性的东西
      checkstackp(L, LUA_MINSTACK, func);  /* ensure minimum stack size */
      //创建并初始化新的调用函数信息，并进入新的函数
      ci = next_ci(L);  /* now ‘enter‘ new function */
      ci->nresults = nresults;
      ci->func = func;
      ci->top = L->top + LUA_MINSTACK;
      lua_assert(ci->top <= L->stack_last);
      ci->callstatus = 0;
      if (L->hookmask & LUA_MASKCALL)
        luaD_hook(L, LUA_HOOKCALL, -1);
      lua_unlock(L);
      //终于来了！！妈的调用来调用去的你终于执行到了真正要执行的函数了啊！C函数的返回值赋给了n。
      n = (*f)(L);  /* do the actual call */
      lua_lock(L);
      api_checknelems(L, n);
      //这个函数也很重要，就是把执行函数后push进来的值重新放置到正确的位置,L->top-n是指第一个元素，n是指有多少个元素
      luaD_poscall(L, ci, L->top - n, n);
      return 1;
    }
  //这里只说明c函数部分，其他lua函数等部分的原理都是差不多的。
    ......
  }
}

//展开luaD_poscall
int luaD_poscall (lua_State *L, CallInfo *ci, StkId firstResult, int nres) {
  StkId res;
  int wanted = ci->nresults;
  ......
  //res指向当前调用函数在栈中的位置
  res = ci->func;  /* res == final position of 1st result */
  //通过调用函数信息链回到上一个调用函数信息中
  L->ci = ci->previous;  /* back to caller */
  /* move results to proper place */
  //moveresults真正执行移动元素的操作
  return moveresults(L, firstResult, res, nres, wanted);
}

//展开moveresults
static int moveresults (lua_State *L, const TValue *firstResult, StkId res,
                                      int nres, int wanted) {
  switch (wanted) {  /* handle typical cases separately */
    //不需要返回则不需要转移
    case 0: break;  /* nothing to move */
    //需要一个元素，只转移第一个元素
    case 1: {  /* one result needed */
      if (nres == 0)   /* no results? */
        firstResult = luaO_nilobject;  /* adjust with nil */
      setobjs2s(L, res, firstResult);  /* move it to proper place */
      break;
    }
    //如同print函数这些需要所有返回值的则调用这个，转移所有元素
    case LUA_MULTRET: {
      int i;
     //遍历nres个元素并转移到新位置，可以发现转移元素实际上使用到了setobjs2s()
      for (i = 0; i < nres; i++)  /* move all results to correct place */
        setobjs2s(L, res + i, firstResult + i);
      //重新设置栈顶
      L->top = res + nres;
      return 0;  /* wanted == LUA_MULTRET */
    }
    default: {
      int i;
      if (wanted <= nres) {  /* enough results? */
        for (i = 0; i < wanted; i++)  /* move wanted results to correct place */
          setobjs2s(L, res + i, firstResult + i);
      }
      else {  /* not enough results; use all of them plus nils */
        for (i = 0; i < nres; i++)  /* move all results to correct place */
          setobjs2s(L, res + i, firstResult + i);
        for (; i < wanted; i++)  /* complete wanted number of results */
          setnilvalue(res + i);
      }
      break;
    }
  }
  //重设置栈顶
  L->top = res + wanted;  /* top points after the last result */
  return 1;
}


//展开setobjs2s
//发现原来又是宏定义
#define setobjs2s    setob
//还是宏定义，原来就是直接把obj2的值赋给了obj1而已
#define setobj(L,obj1,obj2) \\
    { TValue *io1=(obj1); *io1 = *(obj2);       (void)L; checkliveness(L,io1); }

OK～到这里，就基本上明白了整个函数调用流程以及在流程中的栈变化了。

 

三、得出结论

为什么当CGetPow的返回值为5的时候它看起来还像是个栈结构，但是返回值为8的时候却会重复fuck  编译test.lua得出的函数  print这三个呢？

解：

　　因为在调用print(pow(2,3))中，栈中的结构为1:nil（已通过实验确定这是最初的lua_state的ci->func），2：fuck， 3：function（加载test.lua得到的函数），4：print函数，5：pow函数，6：参数2，7：参数3.

当push了"hello"和"world“后，栈结构多了8：”hello“，9：”world“。

　　然后如果这时候返回值为5，移动栈元素时会从L->top-5（当前的top在索引10上）的元素开始，移动5个元素到从当前函数（pow）在栈中的位置开始的位置上。也就是说把从第5个索引开始的5个元素转移到从pow函数所在位置开始的新位置，所以实际上栈的元素是没有变动过的。所以当调用第4个索引位置上的print输出他们的时候，输出结果为：pow  2  3  hello  world。

　　然后当返回值为8时，移动栈元素时会从L->top-8，也就是索引2开始把8个元素转移到pow函数所在位置开始的新位置后。这里就会出现一个现象，因为2->5,3->6,4->7，所以实际上现在第5索引上的元素为最开始第2个索引上的元素，所以5->8后，第8索引上的元素为fuck，同理6->9实际上是3->9，7->10实际上是4->10，这就导致了print输出时一直重复fuck  test.lua编译出来的函数  print这3个元素。

　　至此问题解决，并且还对lua的认识增加了许多。就是看lua的宏定义看得我脑壳疼了一天。233333