Phase 122 (continued): Optimize VM auxiliary files with auto

Extend local variable optimization to VM arithmetic, comparison,
loops, table, and string operation files:

lvm_arithmetic.cpp (2 optimizations):
- luaV_idiv: auto q (division result)
- luaV_mod: auto r (modulus result)

lvm_comparison.cpp (5 optimizations):
- l_strcmp: auto for temp, zl1, zl2, s1, s2
- luaV_equalobj: auto tag (TM result)

lvm_loops.cpp (8 optimizations):
- forPrep: auto for pinit, plimit, pstep, init, step
- forPrep: declare init/limit/step in float branch together
- floatForLoop: auto for step, limit, idx

lvm_table.cpp (2 optimizations):
- luaV_finishget: declare loop in for-init
- luaV_finishset: declare loop in for-init, auto *h

lvm_string.cpp (5 optimizations):
- copy2buff: auto tl, st, s
- luaV_concat: auto top, n, tl, l

Total: 22 optimizations across 5 VM files

Benefits:
- Consistent with lvm.cpp optimizations (Phase 122)
- Improved code clarity and maintainability
- Type-safe variable declarations

Performance: 4.31s avg (5 runs)
- Run 1: 4.13s
- Run 2: 4.25s
- Run 3: 4.69s
- Run 4: 4.22s
- Run 5: 4.28s
Target: ≤4.33s ✓ (2.6% above baseline)
Tests: All pass ✓

Files modified:
- src/vm/lvm_arithmetic.cpp
- src/vm/lvm_comparison.cpp
- src/vm/lvm_loops.cpp
- src/vm/lvm_table.cpp
- src/vm/lvm_string.cpp

Author: claude

src/vm/lvm_arithmetic.cpp

@@ -31,7 +31,7 @@ lua_Integer luaV_idiv (lua_State *L, lua_Integer m, lua_Integer n) {
     return intop(-, 0, m);   /* n==-1; avoid overflow with 0x80000...//-1 */
   }
   else {
-    lua_Integer q = m / n;  /* perform C division */
+    auto q = m / n;  /* perform C division */
     if ((m ^ n) < 0 && m % n != 0)  /* 'm/n' would be negative non-integer? */
       q -= 1;  /* correct result for different rounding */
     return q;
@@ -51,7 +51,7 @@ lua_Integer luaV_mod (lua_State *L, lua_Integer m, lua_Integer n) {
     return 0;   /* m % -1 == 0; avoid overflow with 0x80000...%-1 */
   }
   else {
-    lua_Integer r = m % n;
+    auto r = m % n;
     if (r != 0 && (r ^ n) < 0)  /* 'm/n' would be non-integer negative? */
       r += n;  /* correct result for different rounding */
     return r;

src/vm/lvm_comparison.cpp

@@ -33,16 +33,16 @@
 */
 [[nodiscard]] int l_strcmp (const TString *ts1, const TString *ts2) {
   size_t rl1;  /* real length */
-  const char *s1 = getlstr(ts1, rl1);
+  auto *s1 = getlstr(ts1, rl1);
   size_t rl2;
-  const char *s2 = getlstr(ts2, rl2);
+  auto *s2 = getlstr(ts2, rl2);
   for (;;) {  /* for each segment */
-    int temp = strcoll(s1, s2);
+    auto temp = strcoll(s1, s2);
     if (temp != 0)  /* not equal? */
       return temp;  /* done */
     else {  /* strings are equal up to a '\0' */
-      size_t zl1 = strlen(s1);  /* index of first '\0' in 's1' */
-      size_t zl2 = strlen(s2);  /* index of first '\0' in 's2' */
+      auto zl1 = strlen(s1);  /* index of first '\0' in 's1' */
+      auto zl2 = strlen(s2);  /* index of first '\0' in 's2' */
       if (zl2 == rl2)  /* 's2' is finished? */
         return (zl1 == rl1) ? 0 : 1;  /* check 's1' */
       else if (zl1 == rl1)  /* 's1' is finished? */
@@ -254,7 +254,7 @@ int luaV_equalobj (lua_State *L, const TValue *t1, const TValue *t2) {
     if (tm == nullptr)  /* no TM? */
       return 0;  /* objects are different */
     else {
-      LuaT tag = luaT_callTMres(L, tm, t1, t2, L->getTop().p);  /* call TM */
+      auto tag = luaT_callTMres(L, tm, t1, t2, L->getTop().p);  /* call TM */
       return !tagisfalse(tag);
     }
   }

src/vm/lvm_loops.cpp

@@ -68,12 +68,12 @@ int lua_State::forLimit(lua_Integer init, const TValue *lim,
 **   ra + 2 : control variable
 */
 int lua_State::forPrep(StkId ra) {
-  TValue *pinit = s2v(ra);
-  TValue *plimit = s2v(ra + 1);
-  TValue *pstep = s2v(ra + 2);
+  auto *pinit = s2v(ra);
+  auto *plimit = s2v(ra + 1);
+  auto *pstep = s2v(ra + 2);
   if (ttisinteger(pinit) && ttisinteger(pstep)) { /* integer loop? */
-    lua_Integer init = ivalue(pinit);
-    lua_Integer step = ivalue(pstep);
+    auto init = ivalue(pinit);
+    auto step = ivalue(pstep);
     lua_Integer limit;
     if (step == 0)
       luaG_runerror(this, "'for' step is zero");
@@ -105,7 +105,7 @@ int lua_State::forPrep(StkId ra) {
     }
   }
   else {  /* try making all values floats */
-    lua_Number init; lua_Number limit; lua_Number step;
+    lua_Number init, limit, step;
     if (l_unlikely(!tonumber(plimit, &limit)))
       luaG_forerror(this, plimit, "limit");
     if (l_unlikely(!tonumber(pstep, &step)))
@@ -134,9 +134,9 @@ int lua_State::forPrep(StkId ra) {
 ** written online with opcode OP_FORLOOP, for performance.)
 */
 int lua_State::floatForLoop(StkId ra) {
-  lua_Number step = fltvalue(s2v(ra + 1));
-  lua_Number limit = fltvalue(s2v(ra));
-  lua_Number idx = fltvalue(s2v(ra + 2));  /* control variable */
+  auto step = fltvalue(s2v(ra + 1));
+  auto limit = fltvalue(s2v(ra));
+  auto idx = fltvalue(s2v(ra + 2));  /* control variable */
   idx = luai_numadd(this, idx, step);  /* increment index */
   if (luai_numlt(0, step) ? luai_numle(idx, limit)
                           : luai_numle(limit, idx)) {

src/vm/lvm_string.cpp

@@ -36,11 +36,11 @@ inline bool isemptystr(const TValue* o) noexcept {
 
 /* copy strings in stack from top - n up to top - 1 to buffer */
 static void copy2buff (StkId top, int n, char *buff) {
-  size_t tl = 0;  /* size already copied */
+  auto tl = size_t{0};  /* size already copied */
   do {
-    TString *st = tsvalue(s2v(top - n));
+    auto *st = tsvalue(s2v(top - n));
     size_t l;  /* length of string being copied */
-    const char *s = getlstr(st, l);
+    auto *s = getlstr(st, l);
     std::copy_n(s, l, buff + tl);
     tl += l;
   } while (--n > 0);
@@ -55,8 +55,8 @@ void luaV_concat (lua_State *L, int total) {
   if (total == 1)
     return;  /* "all" values already concatenated */
   do {
-    StkId top = L->getTop().p;
-    int n = 2;  /* number of elements handled in this pass (at least 2) */
+    auto top = L->getTop().p;
+    auto n = 2;  /* number of elements handled in this pass (at least 2) */
     if (!(ttisstring(s2v(top - 2)) || cvt2str(s2v(top - 2))) ||
         !tostring(L, s2v(top - 1))) {
       luaT_tryconcatTM(L);  /* may invalidate 'top' */
@@ -71,12 +71,12 @@ void luaV_concat (lua_State *L, int total) {
     }
     else {
       /* at least two non-empty string values; get as many as possible */
-      size_t tl = tsslen(tsvalue(s2v(top - 1)));
+      auto tl = tsslen(tsvalue(s2v(top - 1)));
       TString *ts;
       /* collect total length and number of strings */
       for (n = 1; n < total && tostring(L, s2v(top - n - 1)); n++) {
         top = L->getTop().p;  /* recapture after tostring() which can trigger GC */
-        size_t l = tsslen(tsvalue(s2v(top - n - 1)));
+        auto l = tsslen(tsvalue(s2v(top - n - 1)));
         if (l_unlikely(l >= MAX_SIZE - sizeof(TString) - tl)) {
           L->getStackSubsystem().setTopPtr(top - total);  /* pop strings to avoid wasting stack */
           luaG_runerror(L, "string length overflow");

src/vm/lvm_table.cpp

@@ -48,9 +48,8 @@ inline constexpr int MAXTAGLOOP = 2000;
 */
 LuaT luaV_finishget (lua_State *L, const TValue *t, TValue *key,
                                       StkId val, LuaT tag) {
-  int loop;  /* counter to avoid infinite loops */
   const TValue *tm;  /* metamethod */
-  for (loop = 0; loop < MAXTAGLOOP; loop++) {
+  for (int loop = 0; loop < MAXTAGLOOP; loop++) {
     if (tag == LuaT::NOTABLE) {  /* 't' is not a table? */
       lua_assert(!ttistable(t));
       tm = luaT_gettmbyobj(L, t, TMS::TM_INDEX);
@@ -103,11 +102,10 @@ LuaT luaV_finishget (lua_State *L, const TValue *t, TValue *key,
 */
 void luaV_finishset (lua_State *L, const TValue *t, TValue *key,
                       TValue *val, int hres) {
-  int loop;  /* counter to avoid infinite loops */
-  for (loop = 0; loop < MAXTAGLOOP; loop++) {
+  for (int loop = 0; loop < MAXTAGLOOP; loop++) {
     const TValue *tm;  /* '__newindex' metamethod */
     if (hres != HNOTATABLE) {  /* is 't' a table? */
-      Table *h = hvalue(t);  /* save 't' table */
+      auto *h = hvalue(t);  /* save 't' table */
       tm = fasttm(L, h->getMetatable(), TMS::TM_NEWINDEX);  /* get metamethod */
       if (tm == nullptr) {  /* no metamethod? */
         sethvalue2s(L, L->getTop().p, h);  /* anchor 't' */