Attachment 586938 Details for Bug 825244 – Difference between stap -p3 output befor/after the tweak

Difference between stap -p3 output befor/after the tweak

stap_p3.diff (text/plain), 58.13 KB, created by Mark Wielaard on 2012-05-25 19:58:59 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Mark Wielaard

Created: 2012-05-25 19:58:59 UTC

Size: 58.13 KB

patch

obsolete

>--- stap_p3.before.out	2012-05-25 21:53:53.639473957 +0200
>+++ stap_p3.after.out	2012-05-25 21:53:52.967477706 +0200
>@@ -577,225 +577,215 @@
>                     };
>                     struct {
>                       union {
>-                        struct {
>-                          string_t __tmp75;
>-                          int64_t __tmp77;
>-                          string_t __tmp78;
>-                        };
>                       };
>                       union {
>                         struct {
>-                          int64_t __tmp85;
>+                          int64_t __tmp83;
>                         };
>                         struct {
>+                          int64_t __tmp85;
>                           int64_t __tmp87;
>-                          int64_t __tmp89;
>                         };
>                         struct {
>-                          string_t __tmp90;
>-                          int64_t __tmp92;
>+                          string_t __tmp88;
>+                          int64_t __tmp90;
>                         };
>                       };
>                     };
>                     struct {
>-                      string_t __tmp93;
>+                      string_t __tmp91;
>+                      int64_t __tmp92;
>                       int64_t __tmp94;
>-                      int64_t __tmp96;
>+                      int64_t __tmp95;
>                       int64_t __tmp97;
>-                      int64_t __tmp99;
>                     };
>                     struct {
>                       union {
>                         struct {
>+                          int64_t __tmp100;
>                           int64_t __tmp102;
>-                          int64_t __tmp104;
>                         };
>                         struct {
>+                          int64_t __tmp103;
>                           int64_t __tmp105;
>-                          int64_t __tmp107;
>-                          int64_t __tmp108;
>+                          int64_t __tmp106;
>                         };
>                       };
>                     };
>                     struct {
>                       union {
>                         struct {
>+                          int64_t __tmp107;
>                           int64_t __tmp109;
>-                          int64_t __tmp111;
>                         };
>                         struct {
>-                          int64_t __tmp112;
>+                          int64_t __tmp110;
>                         };
>                         struct {
>+                          int64_t __tmp112;
>                           int64_t __tmp114;
>-                          int64_t __tmp116;
>                         };
>                         struct {
>+                          int64_t __tmp115;
>                           int64_t __tmp117;
>-                          int64_t __tmp119;
>                         };
>                         struct {
>+                          int64_t __tmp118;
>                           int64_t __tmp120;
>-                          int64_t __tmp122;
>                         };
>                         struct {
>+                          int64_t __tmp121;
>                           int64_t __tmp123;
>-                          int64_t __tmp125;
>                         };
>                         struct {
>+                          int64_t __tmp124;
>                           int64_t __tmp126;
>-                          int64_t __tmp128;
>                         };
>                         struct {
>+                          int64_t __tmp127;
>                           int64_t __tmp129;
>-                          int64_t __tmp131;
>                         };
>                         struct {
>+                          int64_t __tmp130;
>                           int64_t __tmp132;
>-                          int64_t __tmp134;
>                         };
>                         struct {
>+                          int64_t __tmp133;
>                           int64_t __tmp135;
>-                          int64_t __tmp137;
>                         };
>                         struct {
>                           union {
>                             struct {
>+                              int64_t __tmp136;
>                               int64_t __tmp138;
>-                              int64_t __tmp140;
>                             };
>                             struct {
>+                              int64_t __tmp139;
>                               int64_t __tmp141;
>-                              int64_t __tmp143;
>                             };
>                             struct {
>+                              int64_t __tmp142;
>                               int64_t __tmp144;
>-                              int64_t __tmp146;
>                             };
>                             struct {
>+                              int64_t __tmp145;
>                               int64_t __tmp147;
>-                              int64_t __tmp149;
>                             };
>                             struct {
>-                              string_t __tmp150;
>-                              int64_t __tmp152;
>-                              int64_t __tmp153;
>+                              string_t __tmp148;
>+                              int64_t __tmp150;
>+                              int64_t __tmp151;
>                             };
>                           };
>                         };
>                         struct {
>+                          string_t __tmp154;
>                           string_t __tmp156;
>-                          string_t __tmp158;
>-                          string_t __tmp159;
>-                          int64_t __tmp162;
>-                          string_t __tmp163;
>+                          string_t __tmp157;
>+                          int64_t __tmp160;
>+                          string_t __tmp161;
>                         };
>                         struct {
>+                          string_t __tmp162;
>                           string_t __tmp164;
>-                          string_t __tmp166;
>-                          int64_t __tmp167;
>+                          int64_t __tmp165;
>+                          int64_t __tmp166;
>+                          string_t __tmp167;
>                           int64_t __tmp168;
>-                          string_t __tmp169;
>-                          int64_t __tmp170;
>-                          int64_t __tmp171;
>+                          int64_t __tmp169;
>+                          string_t __tmp170;
>+                          string_t __tmp171;
>                           string_t __tmp172;
>-                          string_t __tmp173;
>-                          string_t __tmp174;
>                         };
>                       };
>+                      string_t __tmp173;
>                       string_t __tmp175;
>-                      string_t __tmp177;
>-                      string_t __tmp178;
>-                      int64_t __tmp181;
>-                      string_t __tmp182;
>+                      string_t __tmp176;
>+                      int64_t __tmp179;
>+                      string_t __tmp180;
>                     };
>                     struct {
>-                      string_t __tmp183;
>+                      string_t __tmp181;
>                       union {
>                         struct {
>+                          int64_t __tmp184;
>                           int64_t __tmp186;
>-                          int64_t __tmp188;
>                         };
>                       };
>                     };
>                   };
>                   union {
>-                    struct {
>-                      string_t __tmp189;
>-                      int64_t __tmp191;
>-                      string_t __tmp192;
>-                    };
>                   };
>                 };
>               };
>-              string_t __tmp195;
>-              int64_t __tmp197;
>+              string_t __tmp191;
>+              int64_t __tmp193;
>             };
>             struct {
>-              int64_t __tmp198;
>+              int64_t __tmp194;
>             };
>             struct {
>-              int64_t __tmp200;
>+              int64_t __tmp196;
>             };
>             struct {
>-              int64_t __tmp202;
>+              int64_t __tmp198;
>             };
>             struct {
>-              int64_t __tmp204;
>-              int64_t __tmp206;
>+              int64_t __tmp200;
>+              int64_t __tmp202;
>             };
>             struct {
>-              int64_t __tmp207;
>-              int64_t __tmp209;
>+              int64_t __tmp203;
>+              int64_t __tmp205;
>             };
>             struct {
>               union {
>                 struct {
>                   union {
>                     struct {
>-                      int64_t __tmp214;
>+                      int64_t __tmp210;
>                     };
>                     struct {
>-                      int64_t __tmp216;
>-                      int64_t __tmp218;
>+                      int64_t __tmp212;
>+                      int64_t __tmp214;
>                     };
>                     struct {
>-                      int64_t __tmp219;
>-                      int64_t __tmp221;
>+                      int64_t __tmp215;
>+                      int64_t __tmp217;
>                     };
>                     struct {
>-                      int64_t __tmp223;
>+                      int64_t __tmp219;
>                     };
>                   };
>                 };
>                 struct {
>                   union {
>                     struct {
>-                      string_t __tmp224;
>-                      string_t __tmp226;
>+                      string_t __tmp220;
>+                      string_t __tmp222;
>                     };
>                   };
>                 };
>               };
>             };
>             struct {
>-              string_t __tmp230;
>+              string_t __tmp226;
>               union {
>                 struct {
>                   union {
>                     struct {
>-                      string_t __tmp231;
>+                      string_t __tmp227;
>                     };
>                     struct {
>-                      string_t __tmp233;
>-                      string_t __tmp235;
>-                      string_t __tmp236;
>+                      string_t __tmp229;
>+                      string_t __tmp231;
>+                      string_t __tmp232;
>                     };
>                   };
>-                  string_t __tmp237;
>+                  string_t __tmp233;
>                 };
>                 struct {
>-                  int64_t __tmp239;
>+                  int64_t __tmp235;
>                 };
>               };
>             };
>@@ -804,10 +794,10 @@
>         struct {
>           union {
>             struct {
>+              string_t __tmp238;
>+              string_t __tmp240;
>+              string_t __tmp241;
>               string_t __tmp242;
>-              string_t __tmp244;
>-              string_t __tmp245;
>-              string_t __tmp246;
>             };
>           };
>         };
>@@ -900,24 +890,16 @@
>   #endif
>   #ifndef STP_LEGACY_PRINT
>   union {
>-    struct stp_sprintf_3_locals {
>+    struct stp_sprintf_2_locals {
>       const char* arg0;
>       const char* arg1;
>       const char* arg2;
>       const char* arg3;
>       char * __retvalue;
>-    } stp_sprintf_3;
>-    struct stp_sprintf_2_locals {
>-      const char* arg0;
>-      int64_t arg1;
>-      char * __retvalue;
>     } stp_sprintf_2;
>-    struct stp_sprintf_4_locals {
>-      int64_t arg0;
>-      char * __retvalue;
>-    } stp_sprintf_4;
>     struct stp_sprintf_1_locals {
>-      int64_t arg0;
>+      const char* arg0;
>+      int64_t arg1;
>       char * __retvalue;
>     } stp_sprintf_1;
>   } printf_locals;
>@@ -943,8 +925,8 @@
> #endif
> #ifndef STP_LEGACY_PRINT
> 
>-static noinline void stp_sprintf_3 (struct context* __restrict__ c) {
>-  struct stp_sprintf_3_locals * __restrict__ l = & c->printf_locals.stp_sprintf_3;
>+static noinline void stp_sprintf_2 (struct context* __restrict__ c) {
>+  struct stp_sprintf_2_locals * __restrict__ l = & c->printf_locals.stp_sprintf_2;
>   char *str = NULL, *end = NULL;
>   str = l->__retvalue;
>   end = str + MAXSTRINGLEN - 1;
>@@ -981,8 +963,8 @@
>   }
> }
> 
>-static noinline void stp_sprintf_2 (struct context* __restrict__ c) {
>-  struct stp_sprintf_2_locals * __restrict__ l = & c->printf_locals.stp_sprintf_2;
>+static noinline void stp_sprintf_1 (struct context* __restrict__ c) {
>+  struct stp_sprintf_1_locals * __restrict__ l = & c->printf_locals.stp_sprintf_1;
>   char *str = NULL, *end = NULL;
>   str = l->__retvalue;
>   end = str + MAXSTRINGLEN - 1;
>@@ -1018,62 +1000,6 @@
>       *end = '\0';
>   }
> }
>-
>-static noinline void stp_sprintf_4 (struct context* __restrict__ c) {
>-  struct stp_sprintf_4_locals * __restrict__ l = & c->printf_locals.stp_sprintf_4;
>-  char *str = NULL, *end = NULL;
>-  str = l->__retvalue;
>-  end = str + MAXSTRINGLEN - 1;
>-  if (str && str <= end) {
>-    {
>-      const char *src = "<unknown_frame@0x";
>-      while (*src && str <= end)
>-        *str++ = *src++;
>-    }
>-    {
>-      int width = -1;
>-      int precision = -1;
>-      str = number(str, end, l->arg0, 16, width, precision, 0);
>-    }
>-    {
>-      const char *src = ">";
>-      while (*src && str <= end)
>-        *str++ = *src++;
>-    }
>-    if (str <= end)
>-      *str = '\0';
>-    else
>-      *end = '\0';
>-  }
>-}
>-
>-static noinline void stp_sprintf_1 (struct context* __restrict__ c) {
>-  struct stp_sprintf_1_locals * __restrict__ l = & c->printf_locals.stp_sprintf_1;
>-  char *str = NULL, *end = NULL;
>-  str = l->__retvalue;
>-  end = str + MAXSTRINGLEN - 1;
>-  if (str && str <= end) {
>-    {
>-      const char *src = "<unused_code_block@0x";
>-      while (*src && str <= end)
>-        *str++ = *src++;
>-    }
>-    {
>-      int width = -1;
>-      int precision = -1;
>-      str = number(str, end, l->arg0, 16, width, precision, 0);
>-    }
>-    {
>-      const char *src = ">";
>-      while (*src && str <= end)
>-        *str++ = *src++;
>-    }
>-    if (str <= end)
>-      *str = '\0';
>-    else
>-      *end = '\0';
>-  }
>-}
> #endif // STP_LEGACY_PRINT
> 
> #include "runtime_context.h"
>@@ -3940,21 +3866,8 @@
>                   {
>                     (void) 
>                     ({
>-                      strlcpy (l->__tmp75, 
>-                      ({
>-                        l->__tmp77 = l->pc;
>-                        #ifndef STP_LEGACY_PRINT
>-                          c->printf_locals.stp_sprintf_1.arg0 = l->__tmp77;
>-                          c->printf_locals.stp_sprintf_1.__retvalue = l->__tmp78;
>-                          stp_sprintf_1 (c);
>-                        #else // STP_LEGACY_PRINT
>-                          _stp_snprintf (l->__tmp78, MAXSTRINGLEN, "<unused_code_block@0x%llx>", l->__tmp77);
>-                        #endif // STP_LEGACY_PRINT
>-                        if (unlikely(c->last_error)) goto out;
>-                        l->__tmp78;
>-                      }), MAXSTRINGLEN);
>-                      strlcpy (l->frame, l->__tmp75, MAXSTRINGLEN);
>-                      l->__tmp75;
>+                      strlcpy (l->frame, "<unused_code_block>", MAXSTRINGLEN);
>+                      "<unused_code_block>";
>                     });
>                     
>                     (void) 
>@@ -3987,37 +3900,37 @@
>                   {
>                     (void) 
>                     ({
>-                      l->__tmp85 = ((l->block) + (global.s_HeapBlock_Header_size));
>-                      l->blob = l->__tmp85;
>-                      l->__tmp85;
>+                      l->__tmp83 = ((l->block) + (global.s_HeapBlock_Header_size));
>+                      l->blob = l->__tmp83;
>+                      l->__tmp83;
>                     });
>                     
>                     (void) 
>                     ({
>-                      l->__tmp87 = 
>+                      l->__tmp85 = 
>                       ({
>-                        l->__tmp89 = l->blob;
>-                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_10.pointer = l->__tmp89;
>+                        l->__tmp87 = l->blob;
>+                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_10.pointer = l->__tmp87;
>                         function__dwarf_cast_get_cast_10 (c);
>                         if (unlikely(c->last_error)) goto out;
>                         c->locals[c->nesting+1].function__dwarf_cast_get_cast_10.__retvalue;
>                       });
>-                      l->blob_name_ptr = l->__tmp87;
>-                      l->__tmp87;
>+                      l->blob_name_ptr = l->__tmp85;
>+                      l->__tmp85;
>                     });
>                     
>                     (void) 
>                     ({
>-                      strlcpy (l->__tmp90, (((((l->blob_name_ptr) == (((int64_t)0LL))))) ? ("<unknown-code-blob>") : (
>+                      strlcpy (l->__tmp88, (((((l->blob_name_ptr) == (((int64_t)0LL))))) ? ("<unknown-code-blob>") : (
>                       ({
>-                        l->__tmp92 = l->blob_name_ptr;
>-                        c->locals[c->nesting+1].function_user_string.addr = l->__tmp92;
>+                        l->__tmp90 = l->blob_name_ptr;
>+                        c->locals[c->nesting+1].function_user_string.addr = l->__tmp90;
>                         function_user_string (c);
>                         if (unlikely(c->last_error)) goto out;
>                         c->locals[c->nesting+1].function_user_string.__retvalue;
>                       }))), MAXSTRINGLEN);
>-                      strlcpy (l->blob_name, l->__tmp90, MAXSTRINGLEN);
>-                      l->__tmp90;
>+                      strlcpy (l->blob_name, l->__tmp88, MAXSTRINGLEN);
>+                      l->__tmp88;
>                     });
>                     
>                   }
>@@ -4036,21 +3949,21 @@
>                   goto out;
>                 }
>                 if ((({
>-                    strlcpy (l->__tmp93, l->blob_name, MAXSTRINGLEN);
>-                    strncmp (l->__tmp93, "nmethod", MAXSTRINGLEN) == 0;
>+                    strlcpy (l->__tmp91, l->blob_name, MAXSTRINGLEN);
>+                    strncmp (l->__tmp91, "nmethod", MAXSTRINGLEN) == 0;
>                   }))) {
>                   (void) 
>                   ({
>-                    l->__tmp94 = 
>+                    l->__tmp92 = 
>                     ({
>-                      l->__tmp96 = l->blob;
>-                      c->locals[c->nesting+1].function__dwarf_cast_get_cast_9.pointer = l->__tmp96;
>+                      l->__tmp94 = l->blob;
>+                      c->locals[c->nesting+1].function__dwarf_cast_get_cast_9.pointer = l->__tmp94;
>                       function__dwarf_cast_get_cast_9 (c);
>                       if (unlikely(c->last_error)) goto out;
>                       c->locals[c->nesting+1].function__dwarf_cast_get_cast_9.__retvalue;
>                     });
>-                    l->methodOopPtr = l->__tmp94;
>-                    l->__tmp94;
>+                    l->methodOopPtr = l->__tmp92;
>+                    l->__tmp92;
>                   });
>                   c->actionremaining -= 1;
>                   if (unlikely (c->actionremaining <= 0)) {
>@@ -4062,16 +3975,16 @@
>                 else {
>                   (void) 
>                   ({
>-                    l->__tmp97 = ((
>+                    l->__tmp95 = ((
>                     ({
>-                      l->__tmp99 = ((l->fp) + (((((int64_t)-3LL)) * (global.s_ptr_size))));
>-                      c->locals[c->nesting+1].function_user_long.addr = l->__tmp99;
>+                      l->__tmp97 = ((l->fp) + (((((int64_t)-3LL)) * (global.s_ptr_size))));
>+                      c->locals[c->nesting+1].function_user_long.addr = l->__tmp97;
>                       function_user_long (c);
>                       if (unlikely(c->last_error)) goto out;
>                       c->locals[c->nesting+1].function_user_long.__retvalue;
>                     })) & (global.s_ptr_mask));
>-                    l->methodOopPtr = l->__tmp97;
>-                    l->__tmp97;
>+                    l->methodOopPtr = l->__tmp95;
>+                    l->__tmp95;
>                   });
>                   c->actionremaining -= 1;
>                   if (unlikely (c->actionremaining <= 0)) {
>@@ -4104,33 +4017,33 @@
>                   {
>                     (void) 
>                     ({
>-                      l->__tmp102 = 
>+                      l->__tmp100 = 
>                       ({
>-                        l->__tmp104 = l->methodOopPtr;
>-                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_10.pointer = l->__tmp104;
>+                        l->__tmp102 = l->methodOopPtr;
>+                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_10.pointer = l->__tmp102;
>                         function__dwarf_cast_get_cast_10 (c);
>                         if (unlikely(c->last_error)) goto out;
>                         c->locals[c->nesting+1].function__dwarf_cast_get_cast_10.__retvalue;
>                       });
>-                      l->methodOopKlass = l->__tmp102;
>-                      l->__tmp102;
>+                      l->methodOopKlass = l->__tmp100;
>+                      l->__tmp100;
>                     });
>                     
>                     (void) 
>                     ({
>-                      l->__tmp105 = (((l->methodOopKlass) == (
>+                      l->__tmp103 = (((l->methodOopKlass) == (
>                       ({
>-                        l->__tmp107 = 
>+                        l->__tmp105 = 
>                         ({
>                           function_pid (c);
>                           if (unlikely(c->last_error)) goto out;
>                           c->locals[c->nesting+1].function_pid.__retvalue;
>                         });
>-                        l->__tmp108 = _stp_map_get_ii (global.s_Universe_methodKlassObj, l->__tmp107);
>-                        l->__tmp108;
>+                        l->__tmp106 = _stp_map_get_ii (global.s_Universe_methodKlassObj, l->__tmp105);
>+                        l->__tmp106;
>                       }))));
>-                      l->isMethodOop = l->__tmp105;
>-                      l->__tmp105;
>+                      l->isMethodOop = l->__tmp103;
>+                      l->__tmp103;
>                     });
>                     
>                   }
>@@ -4152,135 +4065,135 @@
>                   {
>                     (void) 
>                     ({
>-                      l->__tmp109 = 
>+                      l->__tmp107 = 
>                       ({
>-                        l->__tmp111 = l->methodOopPtr;
>-                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_11.pointer = l->__tmp111;
>+                        l->__tmp109 = l->methodOopPtr;
>+                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_11.pointer = l->__tmp109;
>                         function__dwarf_cast_get_cast_11 (c);
>                         if (unlikely(c->last_error)) goto out;
>                         c->locals[c->nesting+1].function__dwarf_cast_get_cast_11.__retvalue;
>                       });
>-                      l->constantPoolOopDesc = l->__tmp109;
>-                      l->__tmp109;
>+                      l->constantPoolOopDesc = l->__tmp107;
>+                      l->__tmp107;
>                     });
>                     
>                     (void) 
>                     ({
>-                      l->__tmp112 = ((l->constantPoolOopDesc) + (global.s_constantPoolOopDesc_size));
>-                      l->constantPoolOop_base = l->__tmp112;
>-                      l->__tmp112;
>+                      l->__tmp110 = ((l->constantPoolOopDesc) + (global.s_constantPoolOopDesc_size));
>+                      l->constantPoolOop_base = l->__tmp110;
>+                      l->__tmp110;
>                     });
>                     
>                     (void) 
>                     ({
>-                      l->__tmp114 = 
>+                      l->__tmp112 = 
>                       ({
>-                        l->__tmp116 = l->constantPoolOopDesc;
>-                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_12.pointer = l->__tmp116;
>+                        l->__tmp114 = l->constantPoolOopDesc;
>+                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_12.pointer = l->__tmp114;
>                         function__dwarf_cast_get_cast_12 (c);
>                         if (unlikely(c->last_error)) goto out;
>                         c->locals[c->nesting+1].function__dwarf_cast_get_cast_12.__retvalue;
>                       });
>-                      l->klassPtr = l->__tmp114;
>-                      l->__tmp114;
>+                      l->klassPtr = l->__tmp112;
>+                      l->__tmp112;
>                     });
>                     
>                     (void) 
>                     ({
>-                      l->__tmp117 = 
>+                      l->__tmp115 = 
>                       ({
>-                        l->__tmp119 = ((l->klassPtr) + (global.s_oopDesc_size));
>-                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_13.pointer = l->__tmp119;
>+                        l->__tmp117 = ((l->klassPtr) + (global.s_oopDesc_size));
>+                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_13.pointer = l->__tmp117;
>                         function__dwarf_cast_get_cast_13 (c);
>                         if (unlikely(c->last_error)) goto out;
>                         c->locals[c->nesting+1].function__dwarf_cast_get_cast_13.__retvalue;
>                       });
>-                      l->klassSymbol = l->__tmp117;
>-                      l->__tmp117;
>+                      l->klassSymbol = l->__tmp115;
>+                      l->__tmp115;
>                     });
>                     
>                     (void) 
>                     ({
>-                      l->__tmp120 = 
>+                      l->__tmp118 = 
>                       ({
>-                        l->__tmp122 = l->klassSymbol;
>-                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_14.pointer = l->__tmp122;
>+                        l->__tmp120 = l->klassSymbol;
>+                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_14.pointer = l->__tmp120;
>                         function__dwarf_cast_get_cast_14 (c);
>                         if (unlikely(c->last_error)) goto out;
>                         c->locals[c->nesting+1].function__dwarf_cast_get_cast_14.__retvalue;
>                       });
>-                      l->klassName = l->__tmp120;
>-                      l->__tmp120;
>+                      l->klassName = l->__tmp118;
>+                      l->__tmp118;
>                     });
>                     
>                     (void) 
>                     ({
>-                      l->__tmp123 = 
>+                      l->__tmp121 = 
>                       ({
>-                        l->__tmp125 = l->klassSymbol;
>-                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_15.pointer = l->__tmp125;
>+                        l->__tmp123 = l->klassSymbol;
>+                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_15.pointer = l->__tmp123;
>                         function__dwarf_cast_get_cast_15 (c);
>                         if (unlikely(c->last_error)) goto out;
>                         c->locals[c->nesting+1].function__dwarf_cast_get_cast_15.__retvalue;
>                       });
>-                      l->klassLength = l->__tmp123;
>-                      l->__tmp123;
>+                      l->klassLength = l->__tmp121;
>+                      l->__tmp121;
>                     });
>                     
>                     (void) 
>                     ({
>-                      l->__tmp126 = 
>+                      l->__tmp124 = 
>                       ({
>-                        l->__tmp128 = l->methodOopPtr;
>-                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_16.pointer = l->__tmp128;
>+                        l->__tmp126 = l->methodOopPtr;
>+                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_16.pointer = l->__tmp126;
>                         function__dwarf_cast_get_cast_16 (c);
>                         if (unlikely(c->last_error)) goto out;
>                         c->locals[c->nesting+1].function__dwarf_cast_get_cast_16.__retvalue;
>                       });
>-                      l->methodIndex = l->__tmp126;
>-                      l->__tmp126;
>+                      l->methodIndex = l->__tmp124;
>+                      l->__tmp124;
>                     });
>                     
>                     (void) 
>                     ({
>-                      l->__tmp129 = 
>+                      l->__tmp127 = 
>                       ({
>-                        l->__tmp131 = ((l->constantPoolOop_base) + (((l->methodIndex) * (global.s_ptr_size))));
>-                        c->locals[c->nesting+1].function_user_long.addr = l->__tmp131;
>+                        l->__tmp129 = ((l->constantPoolOop_base) + (((l->methodIndex) * (global.s_ptr_size))));
>+                        c->locals[c->nesting+1].function_user_long.addr = l->__tmp129;
>                         function_user_long (c);
>                         if (unlikely(c->last_error)) goto out;
>                         c->locals[c->nesting+1].function_user_long.__retvalue;
>                       });
>-                      l->methodOopDesc = l->__tmp129;
>-                      l->__tmp129;
>+                      l->methodOopDesc = l->__tmp127;
>+                      l->__tmp127;
>                     });
>                     
>                     (void) 
>                     ({
>-                      l->__tmp132 = 
>+                      l->__tmp130 = 
>                       ({
>-                        l->__tmp134 = l->methodOopDesc;
>-                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_14.pointer = l->__tmp134;
>+                        l->__tmp132 = l->methodOopDesc;
>+                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_14.pointer = l->__tmp132;
>                         function__dwarf_cast_get_cast_14 (c);
>                         if (unlikely(c->last_error)) goto out;
>                         c->locals[c->nesting+1].function__dwarf_cast_get_cast_14.__retvalue;
>                       });
>-                      l->methodName = l->__tmp132;
>-                      l->__tmp132;
>+                      l->methodName = l->__tmp130;
>+                      l->__tmp130;
>                     });
>                     
>                     (void) 
>                     ({
>-                      l->__tmp135 = 
>+                      l->__tmp133 = 
>                       ({
>-                        l->__tmp137 = l->methodOopDesc;
>-                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_15.pointer = l->__tmp137;
>+                        l->__tmp135 = l->methodOopDesc;
>+                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_15.pointer = l->__tmp135;
>                         function__dwarf_cast_get_cast_15 (c);
>                         if (unlikely(c->last_error)) goto out;
>                         c->locals[c->nesting+1].function__dwarf_cast_get_cast_15.__retvalue;
>                       });
>-                      l->methodLength = l->__tmp135;
>-                      l->__tmp135;
>+                      l->methodLength = l->__tmp133;
>+                      l->__tmp133;
>                     });
>                     c->actionremaining -= 10;
>                     if (unlikely (c->actionremaining <= 0)) {
>@@ -4299,74 +4212,74 @@
>                       {
>                         (void) 
>                         ({
>-                          l->__tmp138 = 
>+                          l->__tmp136 = 
>                           ({
>-                            l->__tmp140 = l->methodOopPtr;
>-                            c->locals[c->nesting+1].function__dwarf_cast_get_cast_19.pointer = l->__tmp140;
>+                            l->__tmp138 = l->methodOopPtr;
>+                            c->locals[c->nesting+1].function__dwarf_cast_get_cast_19.pointer = l->__tmp138;
>                             function__dwarf_cast_get_cast_19 (c);
>                             if (unlikely(c->last_error)) goto out;
>                             c->locals[c->nesting+1].function__dwarf_cast_get_cast_19.__retvalue;
>                           });
>-                          l->sigIndex = l->__tmp138;
>-                          l->__tmp138;
>+                          l->sigIndex = l->__tmp136;
>+                          l->__tmp136;
>                         });
>                         
>                         (void) 
>                         ({
>-                          l->__tmp141 = 
>+                          l->__tmp139 = 
>                           ({
>-                            l->__tmp143 = ((l->constantPoolOop_base) + (((l->sigIndex) * (global.s_ptr_size))));
>-                            c->locals[c->nesting+1].function_user_long.addr = l->__tmp143;
>+                            l->__tmp141 = ((l->constantPoolOop_base) + (((l->sigIndex) * (global.s_ptr_size))));
>+                            c->locals[c->nesting+1].function_user_long.addr = l->__tmp141;
>                             function_user_long (c);
>                             if (unlikely(c->last_error)) goto out;
>                             c->locals[c->nesting+1].function_user_long.__retvalue;
>                           });
>-                          l->sigOopDesc = l->__tmp141;
>-                          l->__tmp141;
>+                          l->sigOopDesc = l->__tmp139;
>+                          l->__tmp139;
>                         });
>                         
>                         (void) 
>                         ({
>-                          l->__tmp144 = 
>+                          l->__tmp142 = 
>                           ({
>-                            l->__tmp146 = l->sigOopDesc;
>-                            c->locals[c->nesting+1].function__dwarf_cast_get_cast_14.pointer = l->__tmp146;
>+                            l->__tmp144 = l->sigOopDesc;
>+                            c->locals[c->nesting+1].function__dwarf_cast_get_cast_14.pointer = l->__tmp144;
>                             function__dwarf_cast_get_cast_14 (c);
>                             if (unlikely(c->last_error)) goto out;
>                             c->locals[c->nesting+1].function__dwarf_cast_get_cast_14.__retvalue;
>                           });
>-                          l->sigName = l->__tmp144;
>-                          l->__tmp144;
>+                          l->sigName = l->__tmp142;
>+                          l->__tmp142;
>                         });
>                         
>                         (void) 
>                         ({
>-                          l->__tmp147 = 
>+                          l->__tmp145 = 
>                           ({
>-                            l->__tmp149 = l->sigOopDesc;
>-                            c->locals[c->nesting+1].function__dwarf_cast_get_cast_15.pointer = l->__tmp149;
>+                            l->__tmp147 = l->sigOopDesc;
>+                            c->locals[c->nesting+1].function__dwarf_cast_get_cast_15.pointer = l->__tmp147;
>                             function__dwarf_cast_get_cast_15 (c);
>                             if (unlikely(c->last_error)) goto out;
>                             c->locals[c->nesting+1].function__dwarf_cast_get_cast_15.__retvalue;
>                           });
>-                          l->sigLength = l->__tmp147;
>-                          l->__tmp147;
>+                          l->sigLength = l->__tmp145;
>+                          l->__tmp145;
>                         });
>                         
>                         (void) 
>                         ({
>-                          strlcpy (l->__tmp150, 
>+                          strlcpy (l->__tmp148, 
>                           ({
>-                            l->__tmp152 = l->sigName;
>-                            l->__tmp153 = l->sigLength;
>-                            c->locals[c->nesting+1].function_user_string_n.addr = l->__tmp152;
>-                            c->locals[c->nesting+1].function_user_string_n.n = l->__tmp153;
>+                            l->__tmp150 = l->sigName;
>+                            l->__tmp151 = l->sigLength;
>+                            c->locals[c->nesting+1].function_user_string_n.addr = l->__tmp150;
>+                            c->locals[c->nesting+1].function_user_string_n.n = l->__tmp151;
>                             function_user_string_n (c);
>                             if (unlikely(c->last_error)) goto out;
>                             c->locals[c->nesting+1].function_user_string_n.__retvalue;
>                           }), MAXSTRINGLEN);
>-                          strlcpy (l->sig, l->__tmp150, MAXSTRINGLEN);
>-                          l->__tmp150;
>+                          strlcpy (l->sig, l->__tmp148, MAXSTRINGLEN);
>+                          l->__tmp148;
>                         });
>                         
>                       }
>@@ -4393,75 +4306,75 @@
>                     
>                     (void) 
>                     ({
>-                      strlcpy (l->__tmp156, ((l->log_native) ? (
>+                      strlcpy (l->__tmp154, ((l->log_native) ? (
>                       ({
>-                        strlcpy (l->__tmp158, 
>+                        strlcpy (l->__tmp156, 
>                         ({
>-                          strlcpy (l->__tmp159, l->blob_name, MAXSTRINGLEN);
>-                          strlcpy (c->locals[c->nesting+1].function_str_replace.prnt_str, l->__tmp159, MAXSTRINGLEN);
>+                          strlcpy (l->__tmp157, l->blob_name, MAXSTRINGLEN);
>+                          strlcpy (c->locals[c->nesting+1].function_str_replace.prnt_str, l->__tmp157, MAXSTRINGLEN);
>                           strlcpy (c->locals[c->nesting+1].function_str_replace.srch_str, " ", MAXSTRINGLEN);
>                           strlcpy (c->locals[c->nesting+1].function_str_replace.rplc_str, "_", MAXSTRINGLEN);
>                           function_str_replace (c);
>                           if (unlikely(c->last_error)) goto out;
>                           c->locals[c->nesting+1].function_str_replace.__retvalue;
>                         }), MAXSTRINGLEN);
>-                        l->__tmp162 = l->pc;
>+                        l->__tmp160 = l->pc;
>                         #ifndef STP_LEGACY_PRINT
>-                          c->printf_locals.stp_sprintf_2.arg0 = l->__tmp158;
>-                          c->printf_locals.stp_sprintf_2.arg1 = l->__tmp162;
>-                          c->printf_locals.stp_sprintf_2.__retvalue = l->__tmp163;
>-                          stp_sprintf_2 (c);
>+                          c->printf_locals.stp_sprintf_1.arg0 = l->__tmp156;
>+                          c->printf_locals.stp_sprintf_1.arg1 = l->__tmp160;
>+                          c->printf_locals.stp_sprintf_1.__retvalue = l->__tmp161;
>+                          stp_sprintf_1 (c);
>                         #else // STP_LEGACY_PRINT
>-                          _stp_snprintf (l->__tmp163, MAXSTRINGLEN, "<%s@0x%llx>", l->__tmp158, l->__tmp162);
>+                          _stp_snprintf (l->__tmp161, MAXSTRINGLEN, "<%s@0x%llx>", l->__tmp156, l->__tmp160);
>                         #endif // STP_LEGACY_PRINT
>                         if (unlikely(c->last_error)) goto out;
>-                        l->__tmp163;
>+                        l->__tmp161;
>                       })) : ("")), MAXSTRINGLEN);
>-                      strlcpy (l->code_name, l->__tmp156, MAXSTRINGLEN);
>-                      l->__tmp156;
>+                      strlcpy (l->code_name, l->__tmp154, MAXSTRINGLEN);
>+                      l->__tmp154;
>                     });
>                     
>                     (void) 
>                     ({
>-                      strlcpy (l->__tmp164, 
>+                      strlcpy (l->__tmp162, 
>                       ({
>-                        strlcpy (l->__tmp166, 
>+                        strlcpy (l->__tmp164, 
>                         ({
>-                          l->__tmp167 = l->klassName;
>-                          l->__tmp168 = l->klassLength;
>-                          c->locals[c->nesting+1].function_user_string_n.addr = l->__tmp167;
>-                          c->locals[c->nesting+1].function_user_string_n.n = l->__tmp168;
>+                          l->__tmp165 = l->klassName;
>+                          l->__tmp166 = l->klassLength;
>+                          c->locals[c->nesting+1].function_user_string_n.addr = l->__tmp165;
>+                          c->locals[c->nesting+1].function_user_string_n.n = l->__tmp166;
>                           function_user_string_n (c);
>                           if (unlikely(c->last_error)) goto out;
>                           c->locals[c->nesting+1].function_user_string_n.__retvalue;
>                         }), MAXSTRINGLEN);
>-                        strlcpy (l->__tmp169, 
>+                        strlcpy (l->__tmp167, 
>                         ({
>-                          l->__tmp170 = l->methodName;
>-                          l->__tmp171 = l->methodLength;
>-                          c->locals[c->nesting+1].function_user_string_n.addr = l->__tmp170;
>-                          c->locals[c->nesting+1].function_user_string_n.n = l->__tmp171;
>+                          l->__tmp168 = l->methodName;
>+                          l->__tmp169 = l->methodLength;
>+                          c->locals[c->nesting+1].function_user_string_n.addr = l->__tmp168;
>+                          c->locals[c->nesting+1].function_user_string_n.n = l->__tmp169;
>                           function_user_string_n (c);
>                           if (unlikely(c->last_error)) goto out;
>                           c->locals[c->nesting+1].function_user_string_n.__retvalue;
>                         }), MAXSTRINGLEN);
>-                        strlcpy (l->__tmp172, l->sig, MAXSTRINGLEN);
>-                        strlcpy (l->__tmp173, l->code_name, MAXSTRINGLEN);
>+                        strlcpy (l->__tmp170, l->sig, MAXSTRINGLEN);
>+                        strlcpy (l->__tmp171, l->code_name, MAXSTRINGLEN);
>                         #ifndef STP_LEGACY_PRINT
>-                          c->printf_locals.stp_sprintf_3.arg0 = l->__tmp166;
>-                          c->printf_locals.stp_sprintf_3.arg1 = l->__tmp169;
>-                          c->printf_locals.stp_sprintf_3.arg2 = l->__tmp172;
>-                          c->printf_locals.stp_sprintf_3.arg3 = l->__tmp173;
>-                          c->printf_locals.stp_sprintf_3.__retvalue = l->__tmp174;
>-                          stp_sprintf_3 (c);
>+                          c->printf_locals.stp_sprintf_2.arg0 = l->__tmp164;
>+                          c->printf_locals.stp_sprintf_2.arg1 = l->__tmp167;
>+                          c->printf_locals.stp_sprintf_2.arg2 = l->__tmp170;
>+                          c->printf_locals.stp_sprintf_2.arg3 = l->__tmp171;
>+                          c->printf_locals.stp_sprintf_2.__retvalue = l->__tmp172;
>+                          stp_sprintf_2 (c);
>                         #else // STP_LEGACY_PRINT
>-                          _stp_snprintf (l->__tmp174, MAXSTRINGLEN, "%s.%s%s%s", l->__tmp166, l->__tmp169, l->__tmp172, l->__tmp173);
>+                          _stp_snprintf (l->__tmp172, MAXSTRINGLEN, "%s.%s%s%s", l->__tmp164, l->__tmp167, l->__tmp170, l->__tmp171);
>                         #endif // STP_LEGACY_PRINT
>                         if (unlikely(c->last_error)) goto out;
>-                        l->__tmp174;
>+                        l->__tmp172;
>                       }), MAXSTRINGLEN);
>-                      strlcpy (l->frame, l->__tmp164, MAXSTRINGLEN);
>-                      l->__tmp164;
>+                      strlcpy (l->frame, l->__tmp162, MAXSTRINGLEN);
>+                      l->__tmp162;
>                     });
>                     
>                   }
>@@ -4482,32 +4395,32 @@
>                   if (l->log_native) {
>                     (void) 
>                     ({
>-                      strlcpy (l->__tmp175, 
>+                      strlcpy (l->__tmp173, 
>                       ({
>-                        strlcpy (l->__tmp177, 
>+                        strlcpy (l->__tmp175, 
>                         ({
>-                          strlcpy (l->__tmp178, l->blob_name, MAXSTRINGLEN);
>-                          strlcpy (c->locals[c->nesting+1].function_str_replace.prnt_str, l->__tmp178, MAXSTRINGLEN);
>+                          strlcpy (l->__tmp176, l->blob_name, MAXSTRINGLEN);
>+                          strlcpy (c->locals[c->nesting+1].function_str_replace.prnt_str, l->__tmp176, MAXSTRINGLEN);
>                           strlcpy (c->locals[c->nesting+1].function_str_replace.srch_str, " ", MAXSTRINGLEN);
>                           strlcpy (c->locals[c->nesting+1].function_str_replace.rplc_str, "_", MAXSTRINGLEN);
>                           function_str_replace (c);
>                           if (unlikely(c->last_error)) goto out;
>                           c->locals[c->nesting+1].function_str_replace.__retvalue;
>                         }), MAXSTRINGLEN);
>-                        l->__tmp181 = l->pc;
>+                        l->__tmp179 = l->pc;
>                         #ifndef STP_LEGACY_PRINT
>-                          c->printf_locals.stp_sprintf_2.arg0 = l->__tmp177;
>-                          c->printf_locals.stp_sprintf_2.arg1 = l->__tmp181;
>-                          c->printf_locals.stp_sprintf_2.__retvalue = l->__tmp182;
>-                          stp_sprintf_2 (c);
>+                          c->printf_locals.stp_sprintf_1.arg0 = l->__tmp175;
>+                          c->printf_locals.stp_sprintf_1.arg1 = l->__tmp179;
>+                          c->printf_locals.stp_sprintf_1.__retvalue = l->__tmp180;
>+                          stp_sprintf_1 (c);
>                         #else // STP_LEGACY_PRINT
>-                          _stp_snprintf (l->__tmp182, MAXSTRINGLEN, "<%s@0x%llx>", l->__tmp177, l->__tmp181);
>+                          _stp_snprintf (l->__tmp180, MAXSTRINGLEN, "<%s@0x%llx>", l->__tmp175, l->__tmp179);
>                         #endif // STP_LEGACY_PRINT
>                         if (unlikely(c->last_error)) goto out;
>-                        l->__tmp182;
>+                        l->__tmp180;
>                       }), MAXSTRINGLEN);
>-                      strlcpy (l->frame, l->__tmp175, MAXSTRINGLEN);
>-                      l->__tmp175;
>+                      strlcpy (l->frame, l->__tmp173, MAXSTRINGLEN);
>+                      l->__tmp173;
>                     });
>                     c->actionremaining -= 1;
>                     if (unlikely (c->actionremaining <= 0)) {
>@@ -4525,8 +4438,8 @@
>                   goto out;
>                 }
>                 if ((({
>-                    strlcpy (l->__tmp183, l->blob_name, MAXSTRINGLEN);
>-                    strncmp (l->__tmp183, "nmethod", MAXSTRINGLEN) == 0;
>+                    strlcpy (l->__tmp181, l->blob_name, MAXSTRINGLEN);
>+                    strncmp (l->__tmp181, "nmethod", MAXSTRINGLEN) == 0;
>                   }))) {
>                   {
>                     (void) 
>@@ -4537,16 +4450,16 @@
>                     
>                     (void) 
>                     ({
>-                      l->__tmp186 = 
>+                      l->__tmp184 = 
>                       ({
>-                        l->__tmp188 = l->blob;
>-                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_22.pointer = l->__tmp188;
>+                        l->__tmp186 = l->blob;
>+                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_22.pointer = l->__tmp186;
>                         function__dwarf_cast_get_cast_22 (c);
>                         if (unlikely(c->last_error)) goto out;
>                         c->locals[c->nesting+1].function__dwarf_cast_get_cast_22.__retvalue;
>                       });
>-                      l->frame_size = l->__tmp186;
>-                      l->__tmp186;
>+                      l->frame_size = l->__tmp184;
>+                      l->__tmp184;
>                     });
>                     
>                   }
>@@ -4575,21 +4488,8 @@
>             {
>               (void) 
>               ({
>-                strlcpy (l->__tmp189, 
>-                ({
>-                  l->__tmp191 = l->pc;
>-                  #ifndef STP_LEGACY_PRINT
>-                    c->printf_locals.stp_sprintf_4.arg0 = l->__tmp191;
>-                    c->printf_locals.stp_sprintf_4.__retvalue = l->__tmp192;
>-                    stp_sprintf_4 (c);
>-                  #else // STP_LEGACY_PRINT
>-                    _stp_snprintf (l->__tmp192, MAXSTRINGLEN, "<unknown_frame@0x%llx>", l->__tmp191);
>-                  #endif // STP_LEGACY_PRINT
>-                  if (unlikely(c->last_error)) goto out;
>-                  l->__tmp192;
>-                }), MAXSTRINGLEN);
>-                strlcpy (l->frame, l->__tmp189, MAXSTRINGLEN);
>-                l->__tmp189;
>+                strlcpy (l->frame, "<unknown_frame>", MAXSTRINGLEN);
>+                "<unknown_frame>";
>               });
>               
>               (void) 
>@@ -4621,16 +4521,16 @@
>         if (l->log_native) {
>           (void) 
>           ({
>-            strlcpy (l->__tmp195, 
>+            strlcpy (l->__tmp191, 
>             ({
>-              l->__tmp197 = l->pc;
>-              c->locals[c->nesting+1].function_usymname.addr = l->__tmp197;
>+              l->__tmp193 = l->pc;
>+              c->locals[c->nesting+1].function_usymname.addr = l->__tmp193;
>               function_usymname (c);
>               if (unlikely(c->last_error)) goto out;
>               c->locals[c->nesting+1].function_usymname.__retvalue;
>             }), MAXSTRINGLEN);
>-            strlcpy (l->frame, l->__tmp195, MAXSTRINGLEN);
>-            l->__tmp195;
>+            strlcpy (l->frame, l->__tmp191, MAXSTRINGLEN);
>+            l->__tmp191;
>           });
>           c->actionremaining -= 1;
>           if (unlikely (c->actionremaining <= 0)) {
>@@ -4643,51 +4543,51 @@
>       
>       (void) 
>       ({
>-        l->__tmp198 = l->fp;
>-        l->old_fp = l->__tmp198;
>-        l->__tmp198;
>+        l->__tmp194 = l->fp;
>+        l->old_fp = l->__tmp194;
>+        l->__tmp194;
>       });
>       
>       (void) 
>       ({
>-        l->__tmp200 = l->sp;
>-        l->old_sp = l->__tmp200;
>-        l->__tmp200;
>+        l->__tmp196 = l->sp;
>+        l->old_sp = l->__tmp196;
>+        l->__tmp196;
>       });
>       
>       (void) 
>       ({
>-        l->__tmp202 = l->fp;
>-        l->sp = l->__tmp202;
>-        l->__tmp202;
>+        l->__tmp198 = l->fp;
>+        l->sp = l->__tmp198;
>+        l->__tmp198;
>       });
>       
>       (void) 
>       ({
>-        l->__tmp204 = 
>+        l->__tmp200 = 
>         ({
>-          l->__tmp206 = l->sp;
>-          c->locals[c->nesting+1].function_user_long.addr = l->__tmp206;
>+          l->__tmp202 = l->sp;
>+          c->locals[c->nesting+1].function_user_long.addr = l->__tmp202;
>           function_user_long (c);
>           if (unlikely(c->last_error)) goto out;
>           c->locals[c->nesting+1].function_user_long.__retvalue;
>         });
>-        l->fp = l->__tmp204;
>-        l->__tmp204;
>+        l->fp = l->__tmp200;
>+        l->__tmp200;
>       });
>       
>       (void) 
>       ({
>-        l->__tmp207 = 
>+        l->__tmp203 = 
>         ({
>-          l->__tmp209 = ((l->fp) + (global.s_ptr_size));
>-          c->locals[c->nesting+1].function_user_long.addr = l->__tmp209;
>+          l->__tmp205 = ((l->fp) + (global.s_ptr_size));
>+          c->locals[c->nesting+1].function_user_long.addr = l->__tmp205;
>           function_user_long (c);
>           if (unlikely(c->last_error)) goto out;
>           c->locals[c->nesting+1].function_user_long.__retvalue;
>         });
>-        l->pc = l->__tmp207;
>-        l->__tmp207;
>+        l->pc = l->__tmp203;
>+        l->__tmp203;
>       });
>       
>       c->actionremaining -= 6;
>@@ -4721,44 +4621,44 @@
>           {
>             (void) 
>             ({
>-              l->__tmp214 = ((l->old_sp) + (((((l->frame_size) + (l->i))) * (global.s_ptr_size))));
>-              l->sp = l->__tmp214;
>-              l->__tmp214;
>+              l->__tmp210 = ((l->old_sp) + (((((l->frame_size) + (l->i))) * (global.s_ptr_size))));
>+              l->sp = l->__tmp210;
>+              l->__tmp210;
>             });
>             
>             (void) 
>             ({
>-              l->__tmp216 = 
>+              l->__tmp212 = 
>               ({
>-                l->__tmp218 = l->sp;
>-                c->locals[c->nesting+1].function_user_long.addr = l->__tmp218;
>+                l->__tmp214 = l->sp;
>+                c->locals[c->nesting+1].function_user_long.addr = l->__tmp214;
>                 function_user_long (c);
>                 if (unlikely(c->last_error)) goto out;
>                 c->locals[c->nesting+1].function_user_long.__retvalue;
>               });
>-              l->fp = l->__tmp216;
>-              l->__tmp216;
>+              l->fp = l->__tmp212;
>+              l->__tmp212;
>             });
>             
>             (void) 
>             ({
>-              l->__tmp219 = 
>+              l->__tmp215 = 
>               ({
>-                l->__tmp221 = ((l->fp) + (global.s_ptr_size));
>-                c->locals[c->nesting+1].function_user_long.addr = l->__tmp221;
>+                l->__tmp217 = ((l->fp) + (global.s_ptr_size));
>+                c->locals[c->nesting+1].function_user_long.addr = l->__tmp217;
>                 function_user_long (c);
>                 if (unlikely(c->last_error)) goto out;
>                 c->locals[c->nesting+1].function_user_long.__retvalue;
>               });
>-              l->pc = l->__tmp219;
>-              l->__tmp219;
>+              l->pc = l->__tmp215;
>+              l->__tmp215;
>             });
>             
>             (void) 
>             ({
>-              l->__tmp223 = l->i;
>+              l->__tmp219 = l->i;
>               l->i += 1;
>-              l->__tmp223;
>+              l->__tmp219;
>             });
>             
>           }
>@@ -4790,13 +4690,13 @@
>               if ((! (l->print_frames))) {
>                 (void) 
>                 ({
>-                  strlcpy (l->__tmp224, ({ 
>-                    strlcpy (l->__tmp226, l->frames, MAXSTRINGLEN);
>-                    strlcat (l->__tmp226, " <stack_lost>", MAXSTRINGLEN);
>-                    l->__tmp226;
>+                  strlcpy (l->__tmp220, ({ 
>+                    strlcpy (l->__tmp222, l->frames, MAXSTRINGLEN);
>+                    strlcat (l->__tmp222, " <stack_lost>", MAXSTRINGLEN);
>+                    l->__tmp222;
>                   }), MAXSTRINGLEN);
>-                  strlcpy (l->frames, l->__tmp224, MAXSTRINGLEN);
>-                  l->__tmp224;
>+                  strlcpy (l->frames, l->__tmp220, MAXSTRINGLEN);
>+                  l->__tmp220;
>                 });
>                 c->actionremaining -= 1;
>                 if (unlikely (c->actionremaining <= 0)) {
>@@ -4846,8 +4746,8 @@
>         goto out;
>       }
>       if ((({
>-          strlcpy (l->__tmp230, l->frame, MAXSTRINGLEN);
>-          strncmp (l->__tmp230, "", MAXSTRINGLEN) != 0;
>+          strlcpy (l->__tmp226, l->frame, MAXSTRINGLEN);
>+          strncmp (l->__tmp226, "", MAXSTRINGLEN) != 0;
>         }))) {
>         {
>           c->actionremaining -= 1;
>@@ -4860,24 +4760,24 @@
>             {
>               (void) 
>               ({
>-                strlcpy (l->__tmp231, (((((l->depth) != (((int64_t)0LL))))) ? (" ") : ("")), MAXSTRINGLEN);
>-                strlcpy (l->space, l->__tmp231, MAXSTRINGLEN);
>-                l->__tmp231;
>+                strlcpy (l->__tmp227, (((((l->depth) != (((int64_t)0LL))))) ? (" ") : ("")), MAXSTRINGLEN);
>+                strlcpy (l->space, l->__tmp227, MAXSTRINGLEN);
>+                l->__tmp227;
>               });
>               
>               (void) 
>               ({
>-                strlcpy (l->__tmp233, ({ 
>-                  strlcpy (l->__tmp235, ({ 
>-                    strlcpy (l->__tmp236, l->frames, MAXSTRINGLEN);
>-                    strlcat (l->__tmp236, l->space, MAXSTRINGLEN);
>-                    l->__tmp236;
>+                strlcpy (l->__tmp229, ({ 
>+                  strlcpy (l->__tmp231, ({ 
>+                    strlcpy (l->__tmp232, l->frames, MAXSTRINGLEN);
>+                    strlcat (l->__tmp232, l->space, MAXSTRINGLEN);
>+                    l->__tmp232;
>                   }), MAXSTRINGLEN);
>-                  strlcat (l->__tmp235, l->frame, MAXSTRINGLEN);
>-                  l->__tmp235;
>+                  strlcat (l->__tmp231, l->frame, MAXSTRINGLEN);
>+                  l->__tmp231;
>                 }), MAXSTRINGLEN);
>-                strlcpy (l->frames, l->__tmp233, MAXSTRINGLEN);
>-                l->__tmp233;
>+                strlcpy (l->frames, l->__tmp229, MAXSTRINGLEN);
>+                l->__tmp229;
>               });
>               
>             }
>@@ -4891,8 +4791,8 @@
>           else {
>             (void) 
>             ({
>-              strlcpy (l->__tmp237, l->frame, MAXSTRINGLEN);
>-              strlcpy (c->locals[c->nesting+1].function_log.msg, l->__tmp237, MAXSTRINGLEN);
>+              strlcpy (l->__tmp233, l->frame, MAXSTRINGLEN);
>+              strlcpy (c->locals[c->nesting+1].function_log.msg, l->__tmp233, MAXSTRINGLEN);
>               function_log (c);
>               if (unlikely(c->last_error)) goto out;
>               (void) 0;
>@@ -4907,9 +4807,9 @@
>           
>           (void) 
>           ({
>-            l->__tmp239 = l->depth;
>+            l->__tmp235 = l->depth;
>             l->depth += 1;
>-            l->__tmp239;
>+            l->__tmp235;
>           });
>           
>         }
>@@ -4950,17 +4850,17 @@
>         if ((! (l->print_frames))) {
>           (void) 
>           ({
>-            strlcpy (l->__tmp242, ({ 
>-              strlcpy (l->__tmp244, ({ 
>-                strlcpy (l->__tmp245, l->frames, MAXSTRINGLEN);
>-                strlcat (l->__tmp245, " ", MAXSTRINGLEN);
>-                l->__tmp245;
>+            strlcpy (l->__tmp238, ({ 
>+              strlcpy (l->__tmp240, ({ 
>+                strlcpy (l->__tmp241, l->frames, MAXSTRINGLEN);
>+                strlcat (l->__tmp241, " ", MAXSTRINGLEN);
>+                l->__tmp241;
>               }), MAXSTRINGLEN);
>-              strlcat (l->__tmp244, l->frame, MAXSTRINGLEN);
>-              l->__tmp244;
>+              strlcat (l->__tmp240, l->frame, MAXSTRINGLEN);
>+              l->__tmp240;
>             }), MAXSTRINGLEN);
>-            strlcpy (l->frames, l->__tmp242, MAXSTRINGLEN);
>-            l->__tmp242;
>+            strlcpy (l->frames, l->__tmp238, MAXSTRINGLEN);
>+            l->__tmp238;
>           });
>           c->actionremaining -= 1;
>           if (unlikely (c->actionremaining <= 0)) {
>@@ -4972,8 +4872,8 @@
>         else {
>           (void) 
>           ({
>-            strlcpy (l->__tmp246, l->frame, MAXSTRINGLEN);
>-            strlcpy (c->locals[c->nesting+1].function_log.msg, l->__tmp246, MAXSTRINGLEN);
>+            strlcpy (l->__tmp242, l->frame, MAXSTRINGLEN);
>+            strlcpy (c->locals[c->nesting+1].function_log.msg, l->__tmp242, MAXSTRINGLEN);
>             function_log (c);
>             if (unlikely(c->last_error)) goto out;
>             (void) 0;

Actions: View

Attachments on bug 825244: 586855 | 586938