]>
git.proxmox.com Git - ceph.git/blob - ceph/src/jaegertracing/opentelemetry-cpp/third_party/prometheus-cpp/3rdparty/civetweb/src/third_party/lua-5.3.6/src/ldebug.c
2 ** $Id: ldebug.c,v 2.121.1.2 2017/07/10 17:21:50 roberto Exp $
4 ** See Copyright Notice in lua.h
34 #define noLuaClosure(f) ((f) == NULL || (f)->c.tt == LUA_TCCL)
37 /* Active Lua function (given call info) */
38 #define ci_func(ci) (clLvalue((ci)->func))
41 static const char *funcnamefromcode (lua_State
*L
, CallInfo
*ci
,
45 static int currentpc (CallInfo
*ci
) {
46 lua_assert(isLua(ci
));
47 return pcRel(ci
->u
.l
.savedpc
, ci_func(ci
)->p
);
51 static int currentline (CallInfo
*ci
) {
52 return getfuncline(ci_func(ci
)->p
, currentpc(ci
));
57 ** If function yielded, its 'func' can be in the 'extra' field. The
58 ** next function restores 'func' to its correct value for debugging
59 ** purposes. (It exchanges 'func' and 'extra'; so, when called again,
60 ** after debugging, it also "re-restores" ** 'func' to its altered value.
62 static void swapextra (lua_State
*L
) {
63 if (L
->status
== LUA_YIELD
) {
64 CallInfo
*ci
= L
->ci
; /* get function that yielded */
65 StkId temp
= ci
->func
; /* exchange its 'func' and 'extra' values */
66 ci
->func
= restorestack(L
, ci
->extra
);
67 ci
->extra
= savestack(L
, temp
);
73 ** This function can be called asynchronously (e.g. during a signal).
74 ** Fields 'oldpc', 'basehookcount', and 'hookcount' (set by
75 ** 'resethookcount') are for debug only, and it is no problem if they
76 ** get arbitrary values (causes at most one wrong hook call). 'hookmask'
77 ** is an atomic value. We assume that pointers are atomic too (e.g., gcc
78 ** ensures that for all platforms where it runs). Moreover, 'hook' is
79 ** always checked before being called (see 'luaD_hook').
81 LUA_API
void lua_sethook (lua_State
*L
, lua_Hook func
, int mask
, int count
) {
82 if (func
== NULL
|| mask
== 0) { /* turn off hooks? */
87 L
->oldpc
= L
->ci
->u
.l
.savedpc
;
89 L
->basehookcount
= count
;
91 L
->hookmask
= cast_byte(mask
);
95 LUA_API lua_Hook
lua_gethook (lua_State
*L
) {
100 LUA_API
int lua_gethookmask (lua_State
*L
) {
105 LUA_API
int lua_gethookcount (lua_State
*L
) {
106 return L
->basehookcount
;
110 LUA_API
int lua_getstack (lua_State
*L
, int level
, lua_Debug
*ar
) {
113 if (level
< 0) return 0; /* invalid (negative) level */
115 for (ci
= L
->ci
; level
> 0 && ci
!= &L
->base_ci
; ci
= ci
->previous
)
117 if (level
== 0 && ci
!= &L
->base_ci
) { /* level found? */
121 else status
= 0; /* no such level */
127 static const char *upvalname (Proto
*p
, int uv
) {
128 TString
*s
= check_exp(uv
< p
->sizeupvalues
, p
->upvalues
[uv
].name
);
129 if (s
== NULL
) return "?";
130 else return getstr(s
);
134 static const char *findvararg (CallInfo
*ci
, int n
, StkId
*pos
) {
135 int nparams
= clLvalue(ci
->func
)->p
->numparams
;
136 int nvararg
= cast_int(ci
->u
.l
.base
- ci
->func
) - nparams
;
138 return NULL
; /* no such vararg */
140 *pos
= ci
->func
+ nparams
- n
;
141 return "(*vararg)"; /* generic name for any vararg */
146 static const char *findlocal (lua_State
*L
, CallInfo
*ci
, int n
,
148 const char *name
= NULL
;
151 if (n
< 0) /* access to vararg values? */
152 return findvararg(ci
, n
, pos
);
155 name
= luaF_getlocalname(ci_func(ci
)->p
, n
, currentpc(ci
));
160 if (name
== NULL
) { /* no 'standard' name? */
161 StkId limit
= (ci
== L
->ci
) ? L
->top
: ci
->next
->func
;
162 if (limit
- base
>= n
&& n
> 0) /* is 'n' inside 'ci' stack? */
163 name
= "(*temporary)"; /* generic name for any valid slot */
165 return NULL
; /* no name */
167 *pos
= base
+ (n
- 1);
172 LUA_API
const char *lua_getlocal (lua_State
*L
, const lua_Debug
*ar
, int n
) {
176 if (ar
== NULL
) { /* information about non-active function? */
177 if (!isLfunction(L
->top
- 1)) /* not a Lua function? */
179 else /* consider live variables at function start (parameters) */
180 name
= luaF_getlocalname(clLvalue(L
->top
- 1)->p
, n
, 0);
182 else { /* active function; get information through 'ar' */
183 StkId pos
= NULL
; /* to avoid warnings */
184 name
= findlocal(L
, ar
->i_ci
, n
, &pos
);
186 setobj2s(L
, L
->top
, pos
);
196 LUA_API
const char *lua_setlocal (lua_State
*L
, const lua_Debug
*ar
, int n
) {
197 StkId pos
= NULL
; /* to avoid warnings */
201 name
= findlocal(L
, ar
->i_ci
, n
, &pos
);
203 setobjs2s(L
, pos
, L
->top
- 1);
204 L
->top
--; /* pop value */
212 static void funcinfo (lua_Debug
*ar
, Closure
*cl
) {
213 if (noLuaClosure(cl
)) {
215 ar
->linedefined
= -1;
216 ar
->lastlinedefined
= -1;
221 ar
->source
= p
->source
? getstr(p
->source
) : "=?";
222 ar
->linedefined
= p
->linedefined
;
223 ar
->lastlinedefined
= p
->lastlinedefined
;
224 ar
->what
= (ar
->linedefined
== 0) ? "main" : "Lua";
226 luaO_chunkid(ar
->short_src
, ar
->source
, LUA_IDSIZE
);
230 static void collectvalidlines (lua_State
*L
, Closure
*f
) {
231 if (noLuaClosure(f
)) {
238 int *lineinfo
= f
->l
.p
->lineinfo
;
239 Table
*t
= luaH_new(L
); /* new table to store active lines */
240 sethvalue(L
, L
->top
, t
); /* push it on stack */
242 setbvalue(&v
, 1); /* boolean 'true' to be the value of all indices */
243 for (i
= 0; i
< f
->l
.p
->sizelineinfo
; i
++) /* for all lines with code */
244 luaH_setint(L
, t
, lineinfo
[i
], &v
); /* table[line] = true */
249 static const char *getfuncname (lua_State
*L
, CallInfo
*ci
, const char **name
) {
250 if (ci
== NULL
) /* no 'ci'? */
251 return NULL
; /* no info */
252 else if (ci
->callstatus
& CIST_FIN
) { /* is this a finalizer? */
254 return "metamethod"; /* report it as such */
256 /* calling function is a known Lua function? */
257 else if (!(ci
->callstatus
& CIST_TAIL
) && isLua(ci
->previous
))
258 return funcnamefromcode(L
, ci
->previous
, name
);
259 else return NULL
; /* no way to find a name */
263 static int auxgetinfo (lua_State
*L
, const char *what
, lua_Debug
*ar
,
264 Closure
*f
, CallInfo
*ci
) {
266 for (; *what
; what
++) {
273 ar
->currentline
= (ci
&& isLua(ci
)) ? currentline(ci
) : -1;
277 ar
->nups
= (f
== NULL
) ? 0 : f
->c
.nupvalues
;
278 if (noLuaClosure(f
)) {
283 ar
->isvararg
= f
->l
.p
->is_vararg
;
284 ar
->nparams
= f
->l
.p
->numparams
;
289 ar
->istailcall
= (ci
) ? ci
->callstatus
& CIST_TAIL
: 0;
293 ar
->namewhat
= getfuncname(L
, ci
, &ar
->name
);
294 if (ar
->namewhat
== NULL
) {
295 ar
->namewhat
= ""; /* not found */
301 case 'f': /* handled by lua_getinfo */
303 default: status
= 0; /* invalid option */
310 LUA_API
int lua_getinfo (lua_State
*L
, const char *what
, lua_Debug
*ar
) {
320 api_check(L
, ttisfunction(func
), "function expected");
321 what
++; /* skip the '>' */
322 L
->top
--; /* pop function */
327 lua_assert(ttisfunction(ci
->func
));
329 cl
= ttisclosure(func
) ? clvalue(func
) : NULL
;
330 status
= auxgetinfo(L
, what
, ar
, cl
, ci
);
331 if (strchr(what
, 'f')) {
332 setobjs2s(L
, L
->top
, func
);
335 swapextra(L
); /* correct before option 'L', which can raise a mem. error */
336 if (strchr(what
, 'L'))
337 collectvalidlines(L
, cl
);
344 ** {======================================================
345 ** Symbolic Execution
346 ** =======================================================
349 static const char *getobjname (Proto
*p
, int lastpc
, int reg
,
354 ** find a "name" for the RK value 'c'
356 static void kname (Proto
*p
, int pc
, int c
, const char **name
) {
357 if (ISK(c
)) { /* is 'c' a constant? */
358 TValue
*kvalue
= &p
->k
[INDEXK(c
)];
359 if (ttisstring(kvalue
)) { /* literal constant? */
360 *name
= svalue(kvalue
); /* it is its own name */
363 /* else no reasonable name found */
365 else { /* 'c' is a register */
366 const char *what
= getobjname(p
, pc
, c
, name
); /* search for 'c' */
367 if (what
&& *what
== 'c') { /* found a constant name? */
368 return; /* 'name' already filled */
370 /* else no reasonable name found */
372 *name
= "?"; /* no reasonable name found */
376 static int filterpc (int pc
, int jmptarget
) {
377 if (pc
< jmptarget
) /* is code conditional (inside a jump)? */
378 return -1; /* cannot know who sets that register */
379 else return pc
; /* current position sets that register */
384 ** try to find last instruction before 'lastpc' that modified register 'reg'
386 static int findsetreg (Proto
*p
, int lastpc
, int reg
) {
388 int setreg
= -1; /* keep last instruction that changed 'reg' */
389 int jmptarget
= 0; /* any code before this address is conditional */
390 for (pc
= 0; pc
< lastpc
; pc
++) {
391 Instruction i
= p
->code
[pc
];
392 OpCode op
= GET_OPCODE(i
);
397 if (a
<= reg
&& reg
<= a
+ b
) /* set registers from 'a' to 'a+b' */
398 setreg
= filterpc(pc
, jmptarget
);
402 if (reg
>= a
+ 2) /* affect all regs above its base */
403 setreg
= filterpc(pc
, jmptarget
);
408 if (reg
>= a
) /* affect all registers above base */
409 setreg
= filterpc(pc
, jmptarget
);
413 int b
= GETARG_sBx(i
);
414 int dest
= pc
+ 1 + b
;
415 /* jump is forward and do not skip 'lastpc'? */
416 if (pc
< dest
&& dest
<= lastpc
) {
417 if (dest
> jmptarget
)
418 jmptarget
= dest
; /* update 'jmptarget' */
423 if (testAMode(op
) && reg
== a
) /* any instruction that set A */
424 setreg
= filterpc(pc
, jmptarget
);
432 static const char *getobjname (Proto
*p
, int lastpc
, int reg
,
435 *name
= luaF_getlocalname(p
, reg
+ 1, lastpc
);
436 if (*name
) /* is a local? */
438 /* else try symbolic execution */
439 pc
= findsetreg(p
, lastpc
, reg
);
440 if (pc
!= -1) { /* could find instruction? */
441 Instruction i
= p
->code
[pc
];
442 OpCode op
= GET_OPCODE(i
);
445 int b
= GETARG_B(i
); /* move from 'b' to 'a' */
447 return getobjname(p
, pc
, b
, name
); /* get name for 'b' */
452 int k
= GETARG_C(i
); /* key index */
453 int t
= GETARG_B(i
); /* table index */
454 const char *vn
= (op
== OP_GETTABLE
) /* name of indexed variable */
455 ? luaF_getlocalname(p
, t
+ 1, pc
)
457 kname(p
, pc
, k
, name
);
458 return (vn
&& strcmp(vn
, LUA_ENV
) == 0) ? "global" : "field";
461 *name
= upvalname(p
, GETARG_B(i
));
466 int b
= (op
== OP_LOADK
) ? GETARG_Bx(i
)
467 : GETARG_Ax(p
->code
[pc
+ 1]);
468 if (ttisstring(&p
->k
[b
])) {
469 *name
= svalue(&p
->k
[b
]);
475 int k
= GETARG_C(i
); /* key index */
476 kname(p
, pc
, k
, name
);
479 default: break; /* go through to return NULL */
482 return NULL
; /* could not find reasonable name */
487 ** Try to find a name for a function based on the code that called it.
488 ** (Only works when function was called by a Lua function.)
489 ** Returns what the name is (e.g., "for iterator", "method",
490 ** "metamethod") and sets '*name' to point to the name.
492 static const char *funcnamefromcode (lua_State
*L
, CallInfo
*ci
,
494 TMS tm
= (TMS
)0; /* (initial value avoids warnings) */
495 Proto
*p
= ci_func(ci
)->p
; /* calling function */
496 int pc
= currentpc(ci
); /* calling instruction index */
497 Instruction i
= p
->code
[pc
]; /* calling instruction */
498 if (ci
->callstatus
& CIST_HOOKED
) { /* was it called inside a hook? */
502 switch (GET_OPCODE(i
)) {
505 return getobjname(p
, pc
, GETARG_A(i
), name
); /* get function name */
506 case OP_TFORCALL
: { /* for iterator */
507 *name
= "for iterator";
508 return "for iterator";
510 /* other instructions can do calls through metamethods */
511 case OP_SELF
: case OP_GETTABUP
: case OP_GETTABLE
:
514 case OP_SETTABUP
: case OP_SETTABLE
:
517 case OP_ADD
: case OP_SUB
: case OP_MUL
: case OP_MOD
:
518 case OP_POW
: case OP_DIV
: case OP_IDIV
: case OP_BAND
:
519 case OP_BOR
: case OP_BXOR
: case OP_SHL
: case OP_SHR
: {
520 int offset
= cast_int(GET_OPCODE(i
)) - cast_int(OP_ADD
); /* ORDER OP */
521 tm
= cast(TMS
, offset
+ cast_int(TM_ADD
)); /* ORDER TM */
524 case OP_UNM
: tm
= TM_UNM
; break;
525 case OP_BNOT
: tm
= TM_BNOT
; break;
526 case OP_LEN
: tm
= TM_LEN
; break;
527 case OP_CONCAT
: tm
= TM_CONCAT
; break;
528 case OP_EQ
: tm
= TM_EQ
; break;
529 case OP_LT
: tm
= TM_LT
; break;
530 case OP_LE
: tm
= TM_LE
; break;
532 return NULL
; /* cannot find a reasonable name */
534 *name
= getstr(G(L
)->tmname
[tm
]);
538 /* }====================================================== */
543 ** The subtraction of two potentially unrelated pointers is
544 ** not ISO C, but it should not crash a program; the subsequent
545 ** checks are ISO C and ensure a correct result.
547 static int isinstack (CallInfo
*ci
, const TValue
*o
) {
548 ptrdiff_t i
= o
- ci
->u
.l
.base
;
549 return (0 <= i
&& i
< (ci
->top
- ci
->u
.l
.base
) && ci
->u
.l
.base
+ i
== o
);
554 ** Checks whether value 'o' came from an upvalue. (That can only happen
555 ** with instructions OP_GETTABUP/OP_SETTABUP, which operate directly on
558 static const char *getupvalname (CallInfo
*ci
, const TValue
*o
,
560 LClosure
*c
= ci_func(ci
);
562 for (i
= 0; i
< c
->nupvalues
; i
++) {
563 if (c
->upvals
[i
]->v
== o
) {
564 *name
= upvalname(c
->p
, i
);
572 static const char *varinfo (lua_State
*L
, const TValue
*o
) {
573 const char *name
= NULL
; /* to avoid warnings */
574 CallInfo
*ci
= L
->ci
;
575 const char *kind
= NULL
;
577 kind
= getupvalname(ci
, o
, &name
); /* check whether 'o' is an upvalue */
578 if (!kind
&& isinstack(ci
, o
)) /* no? try a register */
579 kind
= getobjname(ci_func(ci
)->p
, currentpc(ci
),
580 cast_int(o
- ci
->u
.l
.base
), &name
);
582 return (kind
) ? luaO_pushfstring(L
, " (%s '%s')", kind
, name
) : "";
586 l_noret
luaG_typeerror (lua_State
*L
, const TValue
*o
, const char *op
) {
587 const char *t
= luaT_objtypename(L
, o
);
588 luaG_runerror(L
, "attempt to %s a %s value%s", op
, t
, varinfo(L
, o
));
592 l_noret
luaG_concaterror (lua_State
*L
, const TValue
*p1
, const TValue
*p2
) {
593 if (ttisstring(p1
) || cvt2str(p1
)) p1
= p2
;
594 luaG_typeerror(L
, p1
, "concatenate");
598 l_noret
luaG_opinterror (lua_State
*L
, const TValue
*p1
,
599 const TValue
*p2
, const char *msg
) {
601 if (!tonumber(p1
, &temp
)) /* first operand is wrong? */
602 p2
= p1
; /* now second is wrong */
603 luaG_typeerror(L
, p2
, msg
);
608 ** Error when both values are convertible to numbers, but not to integers
610 l_noret
luaG_tointerror (lua_State
*L
, const TValue
*p1
, const TValue
*p2
) {
612 if (!tointeger(p1
, &temp
))
614 luaG_runerror(L
, "number%s has no integer representation", varinfo(L
, p2
));
618 l_noret
luaG_ordererror (lua_State
*L
, const TValue
*p1
, const TValue
*p2
) {
619 const char *t1
= luaT_objtypename(L
, p1
);
620 const char *t2
= luaT_objtypename(L
, p2
);
621 if (strcmp(t1
, t2
) == 0)
622 luaG_runerror(L
, "attempt to compare two %s values", t1
);
624 luaG_runerror(L
, "attempt to compare %s with %s", t1
, t2
);
628 /* add src:line information to 'msg' */
629 const char *luaG_addinfo (lua_State
*L
, const char *msg
, TString
*src
,
631 char buff
[LUA_IDSIZE
];
633 luaO_chunkid(buff
, getstr(src
), LUA_IDSIZE
);
634 else { /* no source available; use "?" instead */
635 buff
[0] = '?'; buff
[1] = '\0';
637 return luaO_pushfstring(L
, "%s:%d: %s", buff
, line
, msg
);
641 l_noret
luaG_errormsg (lua_State
*L
) {
642 if (L
->errfunc
!= 0) { /* is there an error handling function? */
643 StkId errfunc
= restorestack(L
, L
->errfunc
);
644 setobjs2s(L
, L
->top
, L
->top
- 1); /* move argument */
645 setobjs2s(L
, L
->top
- 1, errfunc
); /* push function */
646 L
->top
++; /* assume EXTRA_STACK */
647 luaD_callnoyield(L
, L
->top
- 2, 1); /* call it */
649 luaD_throw(L
, LUA_ERRRUN
);
653 l_noret
luaG_runerror (lua_State
*L
, const char *fmt
, ...) {
654 CallInfo
*ci
= L
->ci
;
657 luaC_checkGC(L
); /* error message uses memory */
659 msg
= luaO_pushvfstring(L
, fmt
, argp
); /* format message */
661 if (isLua(ci
)) /* if Lua function, add source:line information */
662 luaG_addinfo(L
, msg
, ci_func(ci
)->p
->source
, currentline(ci
));
667 void luaG_traceexec (lua_State
*L
) {
668 CallInfo
*ci
= L
->ci
;
669 lu_byte mask
= L
->hookmask
;
670 int counthook
= (--L
->hookcount
== 0 && (mask
& LUA_MASKCOUNT
));
672 resethookcount(L
); /* reset count */
673 else if (!(mask
& LUA_MASKLINE
))
674 return; /* no line hook and count != 0; nothing to be done */
675 if (ci
->callstatus
& CIST_HOOKYIELD
) { /* called hook last time? */
676 ci
->callstatus
&= ~CIST_HOOKYIELD
; /* erase mark */
677 return; /* do not call hook again (VM yielded, so it did not move) */
680 luaD_hook(L
, LUA_HOOKCOUNT
, -1); /* call count hook */
681 if (mask
& LUA_MASKLINE
) {
682 Proto
*p
= ci_func(ci
)->p
;
683 int npc
= pcRel(ci
->u
.l
.savedpc
, p
);
684 int newline
= getfuncline(p
, npc
);
685 if (npc
== 0 || /* call linehook when enter a new function, */
686 ci
->u
.l
.savedpc
<= L
->oldpc
|| /* when jump back (loop), or when */
687 newline
!= getfuncline(p
, pcRel(L
->oldpc
, p
))) /* enter a new line */
688 luaD_hook(L
, LUA_HOOKLINE
, newline
); /* call line hook */
690 L
->oldpc
= ci
->u
.l
.savedpc
;
691 if (L
->status
== LUA_YIELD
) { /* did hook yield? */
693 L
->hookcount
= 1; /* undo decrement to zero */
694 ci
->u
.l
.savedpc
--; /* undo increment (resume will increment it again) */
695 ci
->callstatus
|= CIST_HOOKYIELD
; /* mark that it yielded */
696 ci
->func
= L
->top
- 1; /* protect stack below results */
697 luaD_throw(L
, LUA_YIELD
);