Attachment 586855 Details for Bug 825244 – Generated C source file that shows the error

Generated C source file that shows the error

stap_20259_src.c (text/plain), 208.42 KB, created by Mark Wielaard on 2012-05-25 12:44:58 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Mark Wielaard

Created: 2012-05-25 12:44:58 UTC

Size: 208.42 KB

patch

obsolete

>
>#define STAP_MSG_RUNTIME_H_01 "myproc-unprivileged tapset function called without is_myproc checking for pid %d (euid %d)"
>#define STAP_MSG_LOC2C_01 "kernel read fault at 0x%p (%s)"
>#define STAP_MSG_LOC2C_02 "kernel write fault at 0x%p (%s)"
>#define STAP_MSG_LOC2C_03 "divide by zero in DWARF operand (%s)"
>#define STAP_VERSION(a, b) ( ((a) << 8) + (b) )
>#ifndef STAP_COMPAT_VERSION
>#define STAP_COMPAT_VERSION STAP_VERSION(1, 7)
>#endif
>#include "runtime_defines.h"
>#define STP_PR_STAPUSR 0x2
>#define STP_PR_STAPSYS 0x4
>#define STP_PR_STAPDEV 0x8
>#define STP_PRIVILEGE 0x8
>int stp_required_privilege __attribute__ ((section (".stap_privilege"))) = STP_PRIVILEGE;
>#ifndef MAXNESTING
>#define MAXNESTING 6
>#endif
>#define STP_SKIP_BADVARS 0
>#include "runtime.h"
>#include "stat.c"
>#include <linux/string.h>
>#include <linux/timer.h>
>#include <linux/sched.h>
>#include <linux/delay.h>
>#include <linux/profile.h>
>#include <linux/random.h>
>#include <linux/vermagic.h>
>#include <linux/utsname.h>
>#include <linux/version.h>
>#ifdef STAPCONF_GENERATED_COMPILE
>#include <generated/compile.h>
>#endif
>#include "loc2c-runtime.h" 
>#include "access_process_vm.h" 
>
>/* Set to include regparm field in probe context in translate.cxx. */
>#ifndef STAP_NEED_REGPARM
>#define STAP_NEED_REGPARM 1
>#endif
>
>
>
>#define __STP_GET_USER(t, warn)						\
>	do {								\
>		__label__ deref_fault;					\
>		t *_ptr = (t*) (intptr_t) THIS->addr;			\
>		assert_is_myproc();					\
>		if (! access_ok(VERIFY_READ, _ptr, sizeof(t)))		\
>			goto deref_fault;				\
>	   	if (__stp_get_user(THIS->__retvalue, _ptr)) {		\
>		deref_fault:						\
>			THIS->__retvalue = 0;				\
>			CONTEXT->last_error = NULL;			\
>			if (warn) {					\
>				snprintf(CONTEXT->error_buffer,		\
>				    sizeof(CONTEXT->error_buffer),	\
>				    "user %s copy fault %p", #t, _ptr);	\
>				_stp_warn(CONTEXT->error_buffer);	\
>			}						\
>		}							\
>	} while (0)
>
>#define STP_GET_USER(t) __STP_GET_USER(t, 0)
>#define STP_GET_USER_WARN(t) __STP_GET_USER(t, 1)
>
>
>
>#include <linux/version.h>
>#include <linux/file.h>
>#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,25)
>#include <linux/fdtable.h>
>#endif
>#ifndef STAPCONF_TASK_UID
>#include <linux/cred.h>
>#endif
>
>
>
>#include "common_session_state.h"
>struct context {
>  #include "common_probe_context.h"
>  union {
>    struct probe_2500_locals {
>    } probe_2500;
>    struct probe_2504_locals {
>      union {
>        struct {
>          int64_t __tmp0;
>          int64_t __tmp1;
>          int64_t __tmp2;
>        };
>        struct {
>          int64_t __tmp4;
>          int64_t __tmp5;
>          int64_t __tmp6;
>        };
>        struct {
>          int64_t __tmp8;
>          int64_t __tmp9;
>          int64_t __tmp10;
>        };
>        struct {
>          int64_t __tmp12;
>          int64_t __tmp13;
>          int64_t __tmp14;
>        };
>        struct {
>          int64_t __tmp26;
>        };
>        struct {
>          int64_t __tmp29;
>        };
>        struct {
>          int64_t __tmp31;
>        };
>        struct {
>          int64_t __tmp33;
>          int64_t __tmp35;
>        };
>      };
>    } probe_2504;
>    struct probe_2508_locals {
>      union {
>        struct {
>          int64_t __tmp0;
>        };
>        struct {
>          int64_t __tmp1;
>        };
>        struct {
>          int64_t __tmp2;
>        };
>        struct {
>          int64_t __tmp3;
>        };
>        struct {
>          int64_t __tmp4;
>        };
>      };
>    } probe_2508;
>  } probe_locals;
>  union {
>    struct function__dwarf_cast_get_cast_0_locals {
>      int64_t pointer;
>      int64_t __retvalue;
>    } function__dwarf_cast_get_cast_0;
>    struct function__dwarf_cast_get_cast_1_locals {
>      int64_t pointer;
>      int64_t __retvalue;
>    } function__dwarf_cast_get_cast_1;
>    struct function__dwarf_cast_get_cast_10_locals {
>      int64_t pointer;
>      int64_t __retvalue;
>    } function__dwarf_cast_get_cast_10;
>    struct function__dwarf_cast_get_cast_11_locals {
>      int64_t pointer;
>      int64_t __retvalue;
>    } function__dwarf_cast_get_cast_11;
>    struct function__dwarf_cast_get_cast_12_locals {
>      int64_t pointer;
>      int64_t __retvalue;
>    } function__dwarf_cast_get_cast_12;
>    struct function__dwarf_cast_get_cast_13_locals {
>      int64_t pointer;
>      int64_t __retvalue;
>    } function__dwarf_cast_get_cast_13;
>    struct function__dwarf_cast_get_cast_14_locals {
>      int64_t pointer;
>      int64_t __retvalue;
>    } function__dwarf_cast_get_cast_14;
>    struct function__dwarf_cast_get_cast_15_locals {
>      int64_t pointer;
>      int64_t __retvalue;
>    } function__dwarf_cast_get_cast_15;
>    struct function__dwarf_cast_get_cast_16_locals {
>      int64_t pointer;
>      int64_t __retvalue;
>    } function__dwarf_cast_get_cast_16;
>    struct function__dwarf_cast_get_cast_19_locals {
>      int64_t pointer;
>      int64_t __retvalue;
>    } function__dwarf_cast_get_cast_19;
>    struct function__dwarf_cast_get_cast_2_locals {
>      int64_t pointer;
>      int64_t __retvalue;
>    } function__dwarf_cast_get_cast_2;
>    struct function__dwarf_cast_get_cast_22_locals {
>      int64_t pointer;
>      int64_t __retvalue;
>    } function__dwarf_cast_get_cast_22;
>    struct function__dwarf_cast_get_cast_3_locals {
>      int64_t pointer;
>      int64_t __retvalue;
>    } function__dwarf_cast_get_cast_3;
>    struct function__dwarf_cast_get_cast_4_locals {
>      int64_t pointer;
>      int64_t __retvalue;
>    } function__dwarf_cast_get_cast_4;
>    struct function__dwarf_cast_get_cast_5_locals {
>      int64_t pointer;
>      int64_t __retvalue;
>    } function__dwarf_cast_get_cast_5;
>    struct function__dwarf_cast_get_cast_6_locals {
>      int64_t pointer;
>      int64_t __retvalue;
>    } function__dwarf_cast_get_cast_6;
>    struct function__dwarf_cast_get_cast_7_locals {
>      int64_t pointer;
>      int64_t __retvalue;
>    } function__dwarf_cast_get_cast_7;
>    struct function__dwarf_cast_get_cast_9_locals {
>      int64_t pointer;
>      int64_t __retvalue;
>    } function__dwarf_cast_get_cast_9;
>    struct function__dwarf_tvar_get_HeapWordSize_2_locals {
>      int64_t __retvalue;
>    } function__dwarf_tvar_get_HeapWordSize_2;
>    struct function__dwarf_tvar_get__collectedHeap_1_locals {
>      int64_t __retvalue;
>    } function__dwarf_tvar_get__collectedHeap_1;
>    struct function__dwarf_tvar_get__heap_3_locals {
>      int64_t __retvalue;
>    } function__dwarf_tvar_get__heap_3;
>    struct function__dwarf_tvar_get__methodKlassObj_0_locals {
>      int64_t __retvalue;
>    } function__dwarf_tvar_get__methodKlassObj_0;
>    struct function__stp_get_register_by_offset_locals {
>      int64_t offset;
>      int64_t __retvalue;
>    } function__stp_get_register_by_offset;
>    struct function__stp_register_locals {
>      int64_t reg32;
>      int64_t offset;
>      int64_t value;
>      string_t name;
>      int64_t sign_extend;
>      union {
>        struct {
>          union {
>          };
>        };
>        struct {
>          int64_t __tmp3;
>          string_t __tmp5;
>          int64_t __tmp6;
>        };
>        struct {
>          string_t __tmp7;
>          int64_t __tmp8;
>          union {
>            struct {
>              int64_t __tmp9;
>              string_t __tmp11;
>              int64_t __tmp12;
>            };
>            struct {
>              string_t __tmp13;
>              int64_t __tmp14;
>              union {
>                struct {
>                  string_t __tmp15;
>                  string_t __tmp16;
>                };
>              };
>            };
>          };
>        };
>        struct {
>          int64_t __tmp19;
>          int64_t __tmp21;
>        };
>        struct {
>          int64_t __tmp22;
>          int64_t __tmp24;
>        };
>      };
>      int64_t __retvalue;
>    } function__stp_register;
>    struct function__stp_register_regs_locals {
>      union {
>        struct {
>          int64_t __tmp2;
>        };
>        struct {
>          int64_t __tmp6;
>        };
>        struct {
>          int64_t __tmp10;
>        };
>        struct {
>          int64_t __tmp14;
>        };
>        struct {
>          int64_t __tmp18;
>        };
>        struct {
>          int64_t __tmp22;
>        };
>        struct {
>          int64_t __tmp26;
>        };
>        struct {
>          int64_t __tmp30;
>        };
>        struct {
>          int64_t __tmp34;
>        };
>        struct {
>          int64_t __tmp38;
>        };
>        struct {
>          int64_t __tmp42;
>        };
>        struct {
>          int64_t __tmp46;
>        };
>        struct {
>          int64_t __tmp50;
>        };
>        struct {
>          int64_t __tmp54;
>        };
>        struct {
>          int64_t __tmp58;
>        };
>        struct {
>          int64_t __tmp62;
>        };
>        struct {
>          int64_t __tmp66;
>        };
>        struct {
>          int64_t __tmp70;
>        };
>        struct {
>          int64_t __tmp74;
>        };
>        struct {
>          int64_t __tmp78;
>        };
>        struct {
>          int64_t __tmp82;
>        };
>        struct {
>          int64_t __tmp86;
>        };
>        struct {
>          int64_t __tmp90;
>        };
>        struct {
>          int64_t __tmp94;
>        };
>        struct {
>          int64_t __tmp98;
>        };
>        struct {
>          int64_t __tmp102;
>        };
>        struct {
>          int64_t __tmp106;
>        };
>        struct {
>          int64_t __tmp110;
>        };
>        struct {
>          int64_t __tmp114;
>        };
>        struct {
>          int64_t __tmp118;
>        };
>        struct {
>          int64_t __tmp122;
>        };
>        struct {
>          int64_t __tmp126;
>        };
>        struct {
>          int64_t __tmp130;
>        };
>        struct {
>          int64_t __tmp134;
>        };
>        struct {
>          int64_t __tmp138;
>        };
>        struct {
>          int64_t __tmp142;
>        };
>        struct {
>          int64_t __tmp146;
>        };
>        struct {
>          int64_t __tmp150;
>        };
>        struct {
>          int64_t __tmp154;
>        };
>        struct {
>          int64_t __tmp158;
>        };
>        struct {
>          int64_t __tmp162;
>        };
>        struct {
>          int64_t __tmp166;
>        };
>        struct {
>          int64_t __tmp170;
>        };
>        struct {
>          int64_t __tmp174;
>        };
>      };
>      /* no return value */
>    } function__stp_register_regs;
>    struct function__stp_sign_extend32_locals {
>      int64_t value;
>      int64_t __retvalue;
>    } function__stp_sign_extend32;
>    struct function_error_locals {
>      string_t msg;
>      /* no return value */
>    } function_error;
>    struct function_jstack_call_locals {
>      string_t frame;
>      int64_t heap_start;
>      int64_t heap_size;
>      int64_t heap_end;
>      int64_t CodeCache_low;
>      int64_t CodeCache_high;
>      int64_t CodeHeap_log2_segment_size;
>      int64_t CodeCache_segmap_low;
>      string_t frames;
>      int64_t sp;
>      int64_t fp;
>      int64_t pc;
>      int64_t depth;
>      int64_t trust_fp;
>      int64_t segments;
>      int64_t segment;
>      int64_t tag;
>      int64_t block;
>      int64_t used;
>      string_t blob_name;
>      int64_t frame_size;
>      int64_t blob;
>      int64_t blob_name_ptr;
>      int64_t methodOopPtr;
>      int64_t isMethodOop;
>      int64_t methodOopKlass;
>      int64_t constantPoolOopDesc;
>      int64_t constantPoolOop_base;
>      int64_t klassPtr;
>      int64_t klassSymbol;
>      int64_t klassName;
>      int64_t klassLength;
>      int64_t methodIndex;
>      int64_t methodOopDesc;
>      int64_t methodName;
>      int64_t methodLength;
>      int64_t sigIndex;
>      int64_t sigOopDesc;
>      int64_t sigName;
>      int64_t sigLength;
>      string_t sig;
>      string_t code_name;
>      int64_t old_fp;
>      int64_t old_sp;
>      int64_t max_stack_scan;
>      int64_t i;
>      string_t space;
>      int64_t max_depth;
>      int64_t log_sig;
>      int64_t log_native;
>      int64_t print_frames;
>      union {
>        struct {
>          int64_t __tmp0;
>          int64_t __tmp1;
>          union {
>            struct {
>              union {
>                struct {
>                  string_t __tmp4;
>                };
>              };
>            };
>          };
>        };
>        struct {
>          int64_t __tmp5;
>          int64_t __tmp7;
>          int64_t __tmp8;
>          int64_t __tmp9;
>        };
>        struct {
>          int64_t __tmp10;
>          int64_t __tmp12;
>          int64_t __tmp13;
>          int64_t __tmp14;
>          int64_t __tmp15;
>          int64_t __tmp16;
>        };
>        struct {
>          int64_t __tmp17;
>        };
>        struct {
>          int64_t __tmp19;
>          int64_t __tmp21;
>          int64_t __tmp22;
>          int64_t __tmp23;
>        };
>        struct {
>          int64_t __tmp24;
>          int64_t __tmp26;
>          int64_t __tmp27;
>          int64_t __tmp28;
>        };
>        struct {
>          int64_t __tmp29;
>          int64_t __tmp31;
>          int64_t __tmp32;
>          int64_t __tmp33;
>        };
>        struct {
>          int64_t __tmp34;
>          int64_t __tmp36;
>          int64_t __tmp37;
>          int64_t __tmp38;
>        };
>        struct {
>          int64_t __tmp41;
>          string_t __tmp43;
>        };
>        struct {
>          int64_t __tmp44;
>          string_t __tmp46;
>        };
>        struct {
>          int64_t __tmp47;
>          string_t __tmp49;
>        };
>        struct {
>          union {
>            struct {
>              union {
>                struct {
>                  int64_t __tmp58;
>                };
>                struct {
>                  int64_t __tmp60;
>                  int64_t __tmp62;
>                };
>                struct {
>                  union {
>                    struct {
>                      int64_t __tmp63;
>                    };
>                    struct {
>                      int64_t __tmp65;
>                      int64_t __tmp67;
>                    };
>                    struct {
>                      int64_t __tmp69;
>                    };
>                  };
>                };
>                struct {
>                  int64_t __tmp70;
>                };
>                struct {
>                  union {
>                    struct {
>                      int64_t __tmp72;
>                      int64_t __tmp74;
>                    };
>                    struct {
>                      union {
>                        struct {
>                          string_t __tmp75;
>                          int64_t __tmp77;
>                          string_t __tmp78;
>                        };
>                      };
>                      union {
>                        struct {
>                          int64_t __tmp85;
>                        };
>                        struct {
>                          int64_t __tmp87;
>                          int64_t __tmp89;
>                        };
>                        struct {
>                          string_t __tmp90;
>                          int64_t __tmp92;
>                        };
>                      };
>                    };
>                    struct {
>                      string_t __tmp93;
>                      int64_t __tmp94;
>                      int64_t __tmp96;
>                      int64_t __tmp97;
>                      int64_t __tmp99;
>                    };
>                    struct {
>                      union {
>                        struct {
>                          int64_t __tmp102;
>                          int64_t __tmp104;
>                        };
>                        struct {
>                          int64_t __tmp105;
>                          int64_t __tmp107;
>                          int64_t __tmp108;
>                        };
>                      };
>                    };
>                    struct {
>                      union {
>                        struct {
>                          int64_t __tmp109;
>                          int64_t __tmp111;
>                        };
>                        struct {
>                          int64_t __tmp112;
>                        };
>                        struct {
>                          int64_t __tmp114;
>                          int64_t __tmp116;
>                        };
>                        struct {
>                          int64_t __tmp117;
>                          int64_t __tmp119;
>                        };
>                        struct {
>                          int64_t __tmp120;
>                          int64_t __tmp122;
>                        };
>                        struct {
>                          int64_t __tmp123;
>                          int64_t __tmp125;
>                        };
>                        struct {
>                          int64_t __tmp126;
>                          int64_t __tmp128;
>                        };
>                        struct {
>                          int64_t __tmp129;
>                          int64_t __tmp131;
>                        };
>                        struct {
>                          int64_t __tmp132;
>                          int64_t __tmp134;
>                        };
>                        struct {
>                          int64_t __tmp135;
>                          int64_t __tmp137;
>                        };
>                        struct {
>                          union {
>                            struct {
>                              int64_t __tmp138;
>                              int64_t __tmp140;
>                            };
>                            struct {
>                              int64_t __tmp141;
>                              int64_t __tmp143;
>                            };
>                            struct {
>                              int64_t __tmp144;
>                              int64_t __tmp146;
>                            };
>                            struct {
>                              int64_t __tmp147;
>                              int64_t __tmp149;
>                            };
>                            struct {
>                              string_t __tmp150;
>                              int64_t __tmp152;
>                              int64_t __tmp153;
>                            };
>                          };
>                        };
>                        struct {
>                          string_t __tmp156;
>                          string_t __tmp158;
>                          string_t __tmp159;
>                          int64_t __tmp162;
>                          string_t __tmp163;
>                        };
>                        struct {
>                          string_t __tmp164;
>                          string_t __tmp166;
>                          int64_t __tmp167;
>                          int64_t __tmp168;
>                          string_t __tmp169;
>                          int64_t __tmp170;
>                          int64_t __tmp171;
>                          string_t __tmp172;
>                          string_t __tmp173;
>                          string_t __tmp174;
>                        };
>                      };
>                      string_t __tmp175;
>                      string_t __tmp177;
>                      string_t __tmp178;
>                      int64_t __tmp181;
>                      string_t __tmp182;
>                    };
>                    struct {
>                      string_t __tmp183;
>                      union {
>                        struct {
>                          int64_t __tmp186;
>                          int64_t __tmp188;
>                        };
>                      };
>                    };
>                  };
>                  union {
>                    struct {
>                      string_t __tmp189;
>                      int64_t __tmp191;
>                      string_t __tmp192;
>                    };
>                  };
>                };
>              };
>              string_t __tmp195;
>              int64_t __tmp197;
>            };
>            struct {
>              int64_t __tmp198;
>            };
>            struct {
>              int64_t __tmp200;
>            };
>            struct {
>              int64_t __tmp202;
>            };
>            struct {
>              int64_t __tmp204;
>              int64_t __tmp206;
>            };
>            struct {
>              int64_t __tmp207;
>              int64_t __tmp209;
>            };
>            struct {
>              union {
>                struct {
>                  union {
>                    struct {
>                      int64_t __tmp214;
>                    };
>                    struct {
>                      int64_t __tmp216;
>                      int64_t __tmp218;
>                    };
>                    struct {
>                      int64_t __tmp219;
>                      int64_t __tmp221;
>                    };
>                    struct {
>                      int64_t __tmp223;
>                    };
>                  };
>                };
>                struct {
>                  union {
>                    struct {
>                      string_t __tmp224;
>                      string_t __tmp226;
>                    };
>                  };
>                };
>              };
>            };
>            struct {
>              string_t __tmp230;
>              union {
>                struct {
>                  union {
>                    struct {
>                      string_t __tmp231;
>                    };
>                    struct {
>                      string_t __tmp233;
>                      string_t __tmp235;
>                      string_t __tmp236;
>                    };
>                  };
>                  string_t __tmp237;
>                };
>                struct {
>                  int64_t __tmp239;
>                };
>              };
>            };
>          };
>        };
>        struct {
>          union {
>            struct {
>              string_t __tmp242;
>              string_t __tmp244;
>              string_t __tmp245;
>              string_t __tmp246;
>            };
>          };
>        };
>      };
>      string_t __retvalue;
>    } function_jstack_call;
>    struct function_log_locals {
>      string_t msg;
>      /* no return value */
>    } function_log;
>    struct function_pid_locals {
>      int64_t __retvalue;
>    } function_pid;
>    struct function_print_jstack_locals {
>      int64_t max_depth;
>      union {
>        struct {
>          int64_t __tmp2;
>        };
>      };
>      string_t __retvalue;
>    } function_print_jstack;
>    struct function_print_jstack_n_locals {
>      int64_t log_sig;
>      int64_t log_native;
>      int64_t print_frames;
>      int64_t max_depth;
>      union {
>        struct {
>          int64_t __tmp6;
>          int64_t __tmp7;
>          int64_t __tmp8;
>          int64_t __tmp9;
>        };
>      };
>      string_t __retvalue;
>    } function_print_jstack_n;
>    struct function_register_locals {
>      string_t name;
>      string_t __tmp0;
>      int64_t __retvalue;
>    } function_register;
>    struct function_registers_valid_locals {
>      int64_t __retvalue;
>    } function_registers_valid;
>    struct function_str_replace_locals {
>      string_t prnt_str;
>      string_t srch_str;
>      string_t rplc_str;
>      string_t __retvalue;
>    } function_str_replace;
>    struct function_user_char_locals {
>      int64_t addr;
>      int64_t __retvalue;
>    } function_user_char;
>    struct function_user_long_locals {
>      int64_t addr;
>      int64_t __retvalue;
>    } function_user_long;
>    struct function_user_string_locals {
>      int64_t addr;
>      int64_t __tmp0;
>      string_t __retvalue;
>    } function_user_string;
>    struct function_user_string2_locals {
>      int64_t addr;
>      string_t err_msg;
>      string_t __retvalue;
>    } function_user_string2;
>    struct function_user_string_n_locals {
>      int64_t addr;
>      int64_t n;
>      int64_t __tmp0;
>      int64_t __tmp1;
>      string_t __retvalue;
>    } function_user_string_n;
>    struct function_user_string_n2_locals {
>      int64_t addr;
>      int64_t n;
>      string_t err_msg;
>      string_t __retvalue;
>    } function_user_string_n2;
>    struct function_usymname_locals {
>      int64_t addr;
>      string_t __retvalue;
>    } function_usymname;
>  } locals [MAXNESTING+1];
>  #if MAXNESTING < 0
>  #error "MAXNESTING must be positive"
>  #endif
>  #ifndef STP_LEGACY_PRINT
>  union {
>    struct stp_sprintf_3_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;
>      char * __retvalue;
>    } stp_sprintf_1;
>  } printf_locals;
>  #endif // STP_LEGACY_PRINT
>};
>
>static struct context *contexts[NR_CPUS] = { NULL };
>
>#include "alloc.c"
>#define VALUE_TYPE INT64
>#define KEY1_TYPE INT64
>#include "map-gen.c"
>#undef VALUE_TYPE
>#undef KEY1_TYPE
>#define VALUE_TYPE INT64
>#define KEY1_TYPE STRING
>#include "map-gen.c"
>#undef VALUE_TYPE
>#undef KEY1_TYPE
>#include "map.c"
>#ifdef STAP_NEED_GETTIMEOFDAY
>#include "time.c"
>#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;
>  char *str = NULL, *end = NULL;
>  str = l->__retvalue;
>  end = str + MAXSTRINGLEN - 1;
>  if (str && str <= end) {
>    {
>      int width = -1;
>      int precision = -1;
>      str = _stp_vsprint_memory(str, end, l->arg0, width, precision, 's', 0);
>    }
>    {
>      const char *src = ".";
>      while (*src && str <= end)
>        *str++ = *src++;
>    }
>    {
>      int width = -1;
>      int precision = -1;
>      str = _stp_vsprint_memory(str, end, l->arg1, width, precision, 's', 0);
>    }
>    {
>      int width = -1;
>      int precision = -1;
>      str = _stp_vsprint_memory(str, end, l->arg2, width, precision, 's', 0);
>    }
>    {
>      int width = -1;
>      int precision = -1;
>      str = _stp_vsprint_memory(str, end, l->arg3, width, precision, 's', 0);
>    }
>    if (str <= end)
>      *str = '\0';
>    else
>      *end = '\0';
>  }
>}
>
>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;
>  if (str && str <= end) {
>    {
>      const char *src = "<";
>      while (*src && str <= end)
>        *str++ = *src++;
>    }
>    {
>      int width = -1;
>      int precision = -1;
>      str = _stp_vsprint_memory(str, end, l->arg0, width, precision, 's', 0);
>    }
>    {
>      const char *src = "@0x";
>      while (*src && str <= end)
>        *str++ = *src++;
>    }
>    {
>      int width = -1;
>      int precision = -1;
>      str = number(str, end, l->arg1, 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_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"
>#include "probe_lock.h" 
>static struct {
>  MAP s_Universe_methodKlassObj;
>  rwlock_t s_Universe_methodKlassObj_lock;
>  #ifdef STP_TIMING
>  atomic_t s_Universe_methodKlassObj_lock_skip_count;
>  #endif
>
>  MAP s_Universe_collectedHeap;
>  rwlock_t s_Universe_collectedHeap_lock;
>  #ifdef STP_TIMING
>  atomic_t s_Universe_collectedHeap_lock_skip_count;
>  #endif
>
>  MAP s_HeapWordSize;
>  rwlock_t s_HeapWordSize_lock;
>  #ifdef STP_TIMING
>  atomic_t s_HeapWordSize_lock_skip_count;
>  #endif
>
>  MAP s_CodeCache_heap;
>  rwlock_t s_CodeCache_heap_lock;
>  #ifdef STP_TIMING
>  atomic_t s_CodeCache_heap_lock_skip_count;
>  #endif
>
>  string_t s_sp_register;
>  rwlock_t s_sp_register_lock;
>  #ifdef STP_TIMING
>  atomic_t s_sp_register_lock_skip_count;
>  #endif
>
>  string_t s_fp_register;
>  rwlock_t s_fp_register_lock;
>  #ifdef STP_TIMING
>  atomic_t s_fp_register_lock_skip_count;
>  #endif
>
>  string_t s_pc_register;
>  rwlock_t s_pc_register_lock;
>  #ifdef STP_TIMING
>  atomic_t s_pc_register_lock_skip_count;
>  #endif
>
>  int64_t s_ptr_size;
>  rwlock_t s_ptr_size_lock;
>  #ifdef STP_TIMING
>  atomic_t s_ptr_size_lock_skip_count;
>  #endif
>
>  int64_t s_ptr_mask;
>  rwlock_t s_ptr_mask_lock;
>  #ifdef STP_TIMING
>  atomic_t s_ptr_mask_lock_skip_count;
>  #endif
>
>  int64_t s_constantPoolOopDesc_size;
>  rwlock_t s_constantPoolOopDesc_size_lock;
>  #ifdef STP_TIMING
>  atomic_t s_constantPoolOopDesc_size_lock_skip_count;
>  #endif
>
>  int64_t s_HeapBlock_Header_size;
>  rwlock_t s_HeapBlock_Header_size_lock;
>  #ifdef STP_TIMING
>  atomic_t s_HeapBlock_Header_size_lock_skip_count;
>  #endif
>
>  int64_t s_oopDesc_size;
>  rwlock_t s_oopDesc_size_lock;
>  #ifdef STP_TIMING
>  atomic_t s_oopDesc_size_lock_skip_count;
>  #endif
>
>  MAP s_vm_inited;
>  rwlock_t s_vm_inited_lock;
>  #ifdef STP_TIMING
>  atomic_t s_vm_inited_lock_skip_count;
>  #endif
>
>  MAP s__reg_offsets;
>  rwlock_t s__reg_offsets_lock;
>  #ifdef STP_TIMING
>  atomic_t s__reg_offsets_lock_skip_count;
>  #endif
>
>  MAP s__r32_offsets;
>  rwlock_t s__r32_offsets_lock;
>  #ifdef STP_TIMING
>  atomic_t s__r32_offsets_lock_skip_count;
>  #endif
>
>  int64_t s__stp_regs_registered;
>  rwlock_t s__stp_regs_registered_lock;
>  #ifdef STP_TIMING
>  atomic_t s__stp_regs_registered_lock_skip_count;
>  #endif
>
>} global = {
>  
>  #ifdef STP_TIMING
>  .s_Universe_methodKlassObj_lock_skip_count = ATOMIC_INIT(0),
>  #endif
>  #ifdef STP_TIMING
>  .s_Universe_collectedHeap_lock_skip_count = ATOMIC_INIT(0),
>  #endif
>  #ifdef STP_TIMING
>  .s_HeapWordSize_lock_skip_count = ATOMIC_INIT(0),
>  #endif
>  #ifdef STP_TIMING
>  .s_CodeCache_heap_lock_skip_count = ATOMIC_INIT(0),
>  #endif
>  #ifdef STP_TIMING
>  .s_sp_register_lock_skip_count = ATOMIC_INIT(0),
>  #endif
>  #ifdef STP_TIMING
>  .s_fp_register_lock_skip_count = ATOMIC_INIT(0),
>  #endif
>  #ifdef STP_TIMING
>  .s_pc_register_lock_skip_count = ATOMIC_INIT(0),
>  #endif
>  #ifdef STP_TIMING
>  .s_ptr_size_lock_skip_count = ATOMIC_INIT(0),
>  #endif
>  #ifdef STP_TIMING
>  .s_ptr_mask_lock_skip_count = ATOMIC_INIT(0),
>  #endif
>  #ifdef STP_TIMING
>  .s_constantPoolOopDesc_size_lock_skip_count = ATOMIC_INIT(0),
>  #endif
>  #ifdef STP_TIMING
>  .s_HeapBlock_Header_size_lock_skip_count = ATOMIC_INIT(0),
>  #endif
>  #ifdef STP_TIMING
>  .s_oopDesc_size_lock_skip_count = ATOMIC_INIT(0),
>  #endif
>  #ifdef STP_TIMING
>  .s_vm_inited_lock_skip_count = ATOMIC_INIT(0),
>  #endif
>  #ifdef STP_TIMING
>  .s__reg_offsets_lock_skip_count = ATOMIC_INIT(0),
>  #endif
>  #ifdef STP_TIMING
>  .s__r32_offsets_lock_skip_count = ATOMIC_INIT(0),
>  #endif
>  #ifdef STP_TIMING
>  .s__stp_regs_registered_lock_skip_count = ATOMIC_INIT(0),
>  #endif
>};
>
>static void function__dwarf_cast_get_cast_0 (struct context * __restrict__ c);
>
>static void function__dwarf_cast_get_cast_1 (struct context * __restrict__ c);
>
>static void function__dwarf_cast_get_cast_10 (struct context * __restrict__ c);
>
>static void function__dwarf_cast_get_cast_11 (struct context * __restrict__ c);
>
>static void function__dwarf_cast_get_cast_12 (struct context * __restrict__ c);
>
>static void function__dwarf_cast_get_cast_13 (struct context * __restrict__ c);
>
>static void function__dwarf_cast_get_cast_14 (struct context * __restrict__ c);
>
>static void function__dwarf_cast_get_cast_15 (struct context * __restrict__ c);
>
>static void function__dwarf_cast_get_cast_16 (struct context * __restrict__ c);
>
>static void function__dwarf_cast_get_cast_19 (struct context * __restrict__ c);
>
>static void function__dwarf_cast_get_cast_2 (struct context * __restrict__ c);
>
>static void function__dwarf_cast_get_cast_22 (struct context * __restrict__ c);
>
>static void function__dwarf_cast_get_cast_3 (struct context * __restrict__ c);
>
>static void function__dwarf_cast_get_cast_4 (struct context * __restrict__ c);
>
>static void function__dwarf_cast_get_cast_5 (struct context * __restrict__ c);
>
>static void function__dwarf_cast_get_cast_6 (struct context * __restrict__ c);
>
>static void function__dwarf_cast_get_cast_7 (struct context * __restrict__ c);
>
>static void function__dwarf_cast_get_cast_9 (struct context * __restrict__ c);
>
>static void function__dwarf_tvar_get_HeapWordSize_2 (struct context * __restrict__ c);
>
>static void function__dwarf_tvar_get__collectedHeap_1 (struct context * __restrict__ c);
>
>static void function__dwarf_tvar_get__heap_3 (struct context * __restrict__ c);
>
>static void function__dwarf_tvar_get__methodKlassObj_0 (struct context * __restrict__ c);
>
>static void function__stp_get_register_by_offset (struct context * __restrict__ c);
>
>static void function__stp_register (struct context * __restrict__ c);
>
>static void function__stp_register_regs (struct context * __restrict__ c);
>
>static void function__stp_sign_extend32 (struct context * __restrict__ c);
>
>static void function_error (struct context * __restrict__ c);
>
>static void function_jstack_call (struct context * __restrict__ c);
>
>static void function_log (struct context * __restrict__ c);
>
>static void function_pid (struct context * __restrict__ c);
>
>static void function_print_jstack (struct context * __restrict__ c);
>
>static void function_print_jstack_n (struct context * __restrict__ c);
>
>static void function_register (struct context * __restrict__ c);
>
>static void function_registers_valid (struct context * __restrict__ c);
>
>static void function_str_replace (struct context * __restrict__ c);
>
>static void function_user_char (struct context * __restrict__ c);
>
>static void function_user_long (struct context * __restrict__ c);
>
>static void function_user_string (struct context * __restrict__ c);
>
>static void function_user_string2 (struct context * __restrict__ c);
>
>static void function_user_string_n (struct context * __restrict__ c);
>
>static void function_user_string_n2 (struct context * __restrict__ c);
>
>static void function_usymname (struct context * __restrict__ c);
>
>static void function__dwarf_cast_get_cast_0 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__dwarf_cast_get_cast_0_locals *  __restrict__ l = & c->locals[c->nesting+1].function__dwarf_cast_get_cast_0;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '@cast' at /usr/share/systemtap/tapset/x86_64/jstack.stp:130:31";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>    
>#define fetch_register u_fetch_register
>#define store_register u_store_register
>#define deref uderef
>#define store_deref store_uderef
>{
>  {
>    uintptr_t addr;
>    { // synthesized
>      addr = THIS->pointer;
>    }
>    { // synthesized
>      addr += 1UL * 64UL;
>    }
>    THIS->__retvalue = addr;
>  }
>  goto out;
>if (0) goto deref_fault;
>deref_fault:
>  goto out;
>}
>/* pure *//* unprivileged */
>#undef fetch_register
>#undef store_register
>#undef deref
>#undef store_deref
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__dwarf_cast_get_cast_1 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__dwarf_cast_get_cast_1_locals *  __restrict__ l = & c->locals[c->nesting+1].function__dwarf_cast_get_cast_1;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '@cast' at /usr/share/systemtap/tapset/x86_64/jstack.stp:256:16";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>    
>#define fetch_register u_fetch_register
>#define store_register u_store_register
>#define deref uderef
>#define store_deref store_uderef
>{
>  {
>    uintptr_t addr;
>    { // synthesized
>      addr = THIS->pointer;
>    }
>    { // DWARF expression: 0x23(16)
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 16UL;
>        addr = s0;
>      }
>    }
>    { // DWARF expression: 0x23
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 0UL;
>        addr = s0;
>      }
>    }
>    { // synthesized
>    { uint64_t value = deref (8, addr); addr = value; }
>    }
>    THIS->__retvalue = addr;
>  }
>  goto out;
>if (0) goto deref_fault;
>deref_fault:
>  goto out;
>}
>/* pure *//* unprivileged */
>#undef fetch_register
>#undef store_register
>#undef deref
>#undef store_deref
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__dwarf_cast_get_cast_10 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__dwarf_cast_get_cast_10_locals *  __restrict__ l = & c->locals[c->nesting+1].function__dwarf_cast_get_cast_10;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '@cast' at /usr/share/systemtap/tapset/x86_64/jstack.stp:356:36";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>    
>#define fetch_register u_fetch_register
>#define store_register u_store_register
>#define deref uderef
>#define store_deref store_uderef
>{
>  {
>    uintptr_t addr;
>    { // synthesized
>      addr = THIS->pointer;
>    }
>    { // DWARF expression: 0x23(8)
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 8UL;
>        addr = s0;
>      }
>    }
>    { // synthesized
>    { uint64_t value = deref (8, addr); addr = value; }
>    }
>    THIS->__retvalue = addr;
>  }
>  goto out;
>if (0) goto deref_fault;
>deref_fault:
>  goto out;
>}
>/* pure *//* unprivileged */
>#undef fetch_register
>#undef store_register
>#undef deref
>#undef store_deref
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__dwarf_cast_get_cast_11 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__dwarf_cast_get_cast_11_locals *  __restrict__ l = & c->locals[c->nesting+1].function__dwarf_cast_get_cast_11;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '@cast' at /usr/share/systemtap/tapset/x86_64/jstack.stp:374:41";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>    
>#define fetch_register u_fetch_register
>#define store_register u_store_register
>#define deref uderef
>#define store_deref store_uderef
>{
>  {
>    uintptr_t addr;
>    { // synthesized
>      addr = THIS->pointer;
>    }
>    { // DWARF expression: 0x23(24)
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 24UL;
>        addr = s0;
>      }
>    }
>    { // synthesized
>    { uint64_t value = deref (8, addr); addr = value; }
>    }
>    THIS->__retvalue = addr;
>  }
>  goto out;
>if (0) goto deref_fault;
>deref_fault:
>  goto out;
>}
>/* pure *//* unprivileged */
>#undef fetch_register
>#undef store_register
>#undef deref
>#undef store_deref
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__dwarf_cast_get_cast_12 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__dwarf_cast_get_cast_12_locals *  __restrict__ l = & c->locals[c->nesting+1].function__dwarf_cast_get_cast_12;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '@cast' at /usr/share/systemtap/tapset/x86_64/jstack.stp:378:30";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>    
>#define fetch_register u_fetch_register
>#define store_register u_store_register
>#define deref uderef
>#define store_deref store_uderef
>{
>  {
>    uintptr_t addr;
>    { // synthesized
>      addr = THIS->pointer;
>    }
>    { // DWARF expression: 0x23(32)
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 32UL;
>        addr = s0;
>      }
>    }
>    { // synthesized
>    { uint64_t value = deref (8, addr); addr = value; }
>    }
>    THIS->__retvalue = addr;
>  }
>  goto out;
>if (0) goto deref_fault;
>deref_fault:
>  goto out;
>}
>/* pure *//* unprivileged */
>#undef fetch_register
>#undef store_register
>#undef deref
>#undef store_deref
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__dwarf_cast_get_cast_13 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__dwarf_cast_get_cast_13_locals *  __restrict__ l = & c->locals[c->nesting+1].function__dwarf_cast_get_cast_13;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '@cast' at /usr/share/systemtap/tapset/x86_64/jstack.stp:380:33";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>    
>#define fetch_register u_fetch_register
>#define store_register u_store_register
>#define deref uderef
>#define store_deref store_uderef
>{
>  {
>    uintptr_t addr;
>    { // synthesized
>      addr = THIS->pointer;
>    }
>    { // DWARF expression: 0x23(112)
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 112UL;
>        addr = s0;
>      }
>    }
>    { // synthesized
>    { uint64_t value = deref (8, addr); addr = value; }
>    }
>    THIS->__retvalue = addr;
>  }
>  goto out;
>if (0) goto deref_fault;
>deref_fault:
>  goto out;
>}
>/* pure *//* unprivileged */
>#undef fetch_register
>#undef store_register
>#undef deref
>#undef store_deref
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__dwarf_cast_get_cast_14 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__dwarf_cast_get_cast_14_locals *  __restrict__ l = & c->locals[c->nesting+1].function__dwarf_cast_get_cast_14;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '@cast' at /usr/share/systemtap/tapset/x86_64/jstack.stp:382:32";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>    
>#define fetch_register u_fetch_register
>#define store_register u_store_register
>#define deref uderef
>#define store_deref store_uderef
>{
>  {
>    uintptr_t addr;
>    { // synthesized
>      addr = THIS->pointer;
>    }
>    { // DWARF expression: 0x23(18)
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 18UL;
>        addr = s0;
>      }
>    }
>    { // synthesized
>      addr += 0UL * 1UL;
>    }
>    THIS->__retvalue = addr;
>  }
>  goto out;
>if (0) goto deref_fault;
>deref_fault:
>  goto out;
>}
>/* pure *//* unprivileged */
>#undef fetch_register
>#undef store_register
>#undef deref
>#undef store_deref
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__dwarf_cast_get_cast_15 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__dwarf_cast_get_cast_15_locals *  __restrict__ l = & c->locals[c->nesting+1].function__dwarf_cast_get_cast_15;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '@cast' at /usr/share/systemtap/tapset/x86_64/jstack.stp:384:33";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>    
>#define fetch_register u_fetch_register
>#define store_register u_store_register
>#define deref uderef
>#define store_deref store_uderef
>{
>  {
>    uintptr_t addr;
>    { // synthesized
>      addr = THIS->pointer;
>    }
>    { // DWARF expression: 0x23(16)
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 16UL;
>        addr = s0;
>      }
>    }
>    { uint16_t value = deref (2, addr); THIS->__retvalue = value; }
>  }
>  goto out;
>if (0) goto deref_fault;
>deref_fault:
>  goto out;
>}
>/* pure *//* unprivileged */
>#undef fetch_register
>#undef store_register
>#undef deref
>#undef store_deref
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__dwarf_cast_get_cast_16 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__dwarf_cast_get_cast_16_locals *  __restrict__ l = & c->locals[c->nesting+1].function__dwarf_cast_get_cast_16;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '@cast' at /usr/share/systemtap/tapset/x86_64/jstack.stp:387:33";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>    
>#define fetch_register u_fetch_register
>#define store_register u_store_register
>#define deref uderef
>#define store_deref store_uderef
>{
>  {
>    uintptr_t addr;
>    { // synthesized
>      addr = THIS->pointer;
>    }
>    { // DWARF expression: 0x23(16)
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 16UL;
>        addr = s0;
>      }
>    }
>    { // synthesized
>    { uint64_t value = deref (8, addr); addr = value; }
>    }
>    { // DWARF expression: 0x23(64)
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 64UL;
>        addr = s0;
>      }
>    }
>    { uint16_t value = deref (2, addr); THIS->__retvalue = value; }
>  }
>  goto out;
>if (0) goto deref_fault;
>deref_fault:
>  goto out;
>}
>/* pure *//* unprivileged */
>#undef fetch_register
>#undef store_register
>#undef deref
>#undef store_deref
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__dwarf_cast_get_cast_19 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__dwarf_cast_get_cast_19_locals *  __restrict__ l = & c->locals[c->nesting+1].function__dwarf_cast_get_cast_19;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '@cast' at /usr/share/systemtap/tapset/x86_64/jstack.stp:397:34";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>    
>#define fetch_register u_fetch_register
>#define store_register u_store_register
>#define deref uderef
>#define store_deref store_uderef
>{
>  {
>    uintptr_t addr;
>    { // synthesized
>      addr = THIS->pointer;
>    }
>    { // DWARF expression: 0x23(16)
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 16UL;
>        addr = s0;
>      }
>    }
>    { // synthesized
>    { uint64_t value = deref (8, addr); addr = value; }
>    }
>    { // DWARF expression: 0x23(66)
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 66UL;
>        addr = s0;
>      }
>    }
>    { uint16_t value = deref (2, addr); THIS->__retvalue = value; }
>  }
>  goto out;
>if (0) goto deref_fault;
>deref_fault:
>  goto out;
>}
>/* pure *//* unprivileged */
>#undef fetch_register
>#undef store_register
>#undef deref
>#undef store_deref
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__dwarf_cast_get_cast_2 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__dwarf_cast_get_cast_2_locals *  __restrict__ l = & c->locals[c->nesting+1].function__dwarf_cast_get_cast_2;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '@cast' at /usr/share/systemtap/tapset/x86_64/jstack.stp:259:37";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>    
>#define fetch_register u_fetch_register
>#define store_register u_store_register
>#define deref uderef
>#define store_deref store_uderef
>{
>  {
>    uintptr_t addr;
>    { // synthesized
>      addr = THIS->pointer;
>    }
>    { // DWARF expression: 0x23(16)
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 16UL;
>        addr = s0;
>      }
>    }
>    { // DWARF expression: 0x23(8)
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 8UL;
>        addr = s0;
>      }
>    }
>    { uint64_t value = deref (8, addr); THIS->__retvalue = value; }
>  }
>  goto out;
>if (0) goto deref_fault;
>deref_fault:
>  goto out;
>}
>/* pure *//* unprivileged */
>#undef fetch_register
>#undef store_register
>#undef deref
>#undef store_deref
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__dwarf_cast_get_cast_22 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__dwarf_cast_get_cast_22_locals *  __restrict__ l = & c->locals[c->nesting+1].function__dwarf_cast_get_cast_22;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '@cast' at /usr/share/systemtap/tapset/x86_64/jstack.stp:438:32";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>    
>#define fetch_register u_fetch_register
>#define store_register u_store_register
>#define deref uderef
>#define store_deref store_uderef
>{
>  {
>    uintptr_t addr;
>    { // synthesized
>      addr = THIS->pointer;
>    }
>    { // DWARF expression: 0x23(44)
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 44UL;
>        addr = s0;
>      }
>    }
>    { int32_t value = deref (4, addr); THIS->__retvalue = value; }
>  }
>  goto out;
>if (0) goto deref_fault;
>deref_fault:
>  goto out;
>}
>/* pure *//* unprivileged */
>#undef fetch_register
>#undef store_register
>#undef deref
>#undef store_deref
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__dwarf_cast_get_cast_3 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__dwarf_cast_get_cast_3_locals *  __restrict__ l = & c->locals[c->nesting+1].function__dwarf_cast_get_cast_3;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '@cast' at /usr/share/systemtap/tapset/x86_64/jstack.stp:264:19";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>    
>#define fetch_register u_fetch_register
>#define store_register u_store_register
>#define deref uderef
>#define store_deref store_uderef
>{
>  {
>    uintptr_t addr;
>    { // synthesized
>      addr = THIS->pointer;
>    }
>    { // DWARF expression: 0x23
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 0UL;
>        addr = s0;
>      }
>    }
>    { // DWARF expression: 0x23(16)
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 16UL;
>        addr = s0;
>      }
>    }
>    { // synthesized
>    { uint64_t value = deref (8, addr); addr = value; }
>    }
>    THIS->__retvalue = addr;
>  }
>  goto out;
>if (0) goto deref_fault;
>deref_fault:
>  goto out;
>}
>/* pure *//* unprivileged */
>#undef fetch_register
>#undef store_register
>#undef deref
>#undef store_deref
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__dwarf_cast_get_cast_4 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__dwarf_cast_get_cast_4_locals *  __restrict__ l = & c->locals[c->nesting+1].function__dwarf_cast_get_cast_4;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '@cast' at /usr/share/systemtap/tapset/x86_64/jstack.stp:266:21";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>    
>#define fetch_register u_fetch_register
>#define store_register u_store_register
>#define deref uderef
>#define store_deref store_uderef
>{
>  {
>    uintptr_t addr;
>    { // synthesized
>      addr = THIS->pointer;
>    }
>    { // DWARF expression: 0x23
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 0UL;
>        addr = s0;
>      }
>    }
>    { // DWARF expression: 0x23(24)
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 24UL;
>        addr = s0;
>      }
>    }
>    { // synthesized
>    { uint64_t value = deref (8, addr); addr = value; }
>    }
>    THIS->__retvalue = addr;
>  }
>  goto out;
>if (0) goto deref_fault;
>deref_fault:
>  goto out;
>}
>/* pure *//* unprivileged */
>#undef fetch_register
>#undef store_register
>#undef deref
>#undef store_deref
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__dwarf_cast_get_cast_5 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__dwarf_cast_get_cast_5_locals *  __restrict__ l = & c->locals[c->nesting+1].function__dwarf_cast_get_cast_5;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '@cast' at /usr/share/systemtap/tapset/x86_64/jstack.stp:269:32";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>    
>#define fetch_register u_fetch_register
>#define store_register u_store_register
>#define deref uderef
>#define store_deref store_uderef
>{
>  {
>    uintptr_t addr;
>    { // synthesized
>      addr = THIS->pointer;
>    }
>    { // DWARF expression: 0x23(248)
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 248UL;
>        addr = s0;
>      }
>    }
>    { int32_t value = deref (4, addr); THIS->__retvalue = value; }
>  }
>  goto out;
>if (0) goto deref_fault;
>deref_fault:
>  goto out;
>}
>/* pure *//* unprivileged */
>#undef fetch_register
>#undef store_register
>#undef deref
>#undef store_deref
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__dwarf_cast_get_cast_6 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__dwarf_cast_get_cast_6_locals *  __restrict__ l = & c->locals[c->nesting+1].function__dwarf_cast_get_cast_6;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '@cast' at /usr/share/systemtap/tapset/x86_64/jstack.stp:272:26";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>    
>#define fetch_register u_fetch_register
>#define store_register u_store_register
>#define deref uderef
>#define store_deref store_uderef
>{
>  {
>    uintptr_t addr;
>    { // synthesized
>      addr = THIS->pointer;
>    }
>    { // DWARF expression: 0x23(112)
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 112UL;
>        addr = s0;
>      }
>    }
>    { // DWARF expression: 0x23(16)
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 16UL;
>        addr = s0;
>      }
>    }
>    { // synthesized
>    { uint64_t value = deref (8, addr); addr = value; }
>    }
>    THIS->__retvalue = addr;
>  }
>  goto out;
>if (0) goto deref_fault;
>deref_fault:
>  goto out;
>}
>/* pure *//* unprivileged */
>#undef fetch_register
>#undef store_register
>#undef deref
>#undef store_deref
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__dwarf_cast_get_cast_7 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__dwarf_cast_get_cast_7_locals *  __restrict__ l = & c->locals[c->nesting+1].function__dwarf_cast_get_cast_7;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '@cast' at /usr/share/systemtap/tapset/x86_64/jstack.stp:318:22";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>    
>#define fetch_register u_fetch_register
>#define store_register u_store_register
>#define deref uderef
>#define store_deref store_uderef
>{
>  {
>    uintptr_t addr;
>    { // synthesized
>      addr = THIS->pointer;
>    }
>    { // DWARF expression: 0x23
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 0UL;
>        addr = s0;
>      }
>    }
>    { // DWARF expression: 0x23(8)
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 8UL;
>        addr = s0;
>      }
>    }
>    { uint8_t value = deref (1, addr); THIS->__retvalue = value; }
>  }
>  goto out;
>if (0) goto deref_fault;
>deref_fault:
>  goto out;
>}
>/* pure *//* unprivileged */
>#undef fetch_register
>#undef store_register
>#undef deref
>#undef store_deref
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__dwarf_cast_get_cast_9 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__dwarf_cast_get_cast_9_locals *  __restrict__ l = & c->locals[c->nesting+1].function__dwarf_cast_get_cast_9;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '@cast' at /usr/share/systemtap/tapset/x86_64/jstack.stp:344:32";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>    
>#define fetch_register u_fetch_register
>#define store_register u_store_register
>#define deref uderef
>#define store_deref store_uderef
>{
>  {
>    uintptr_t addr;
>    { // synthesized
>      addr = THIS->pointer;
>    }
>    { // DWARF expression: 0x23(64)
>      {
>        uintptr_t s0;
>        s0 = addr;
>        s0 = s0 + 64UL;
>        addr = s0;
>      }
>    }
>    { // synthesized
>    { uint64_t value = deref (8, addr); addr = value; }
>    }
>    THIS->__retvalue = addr;
>  }
>  goto out;
>if (0) goto deref_fault;
>deref_fault:
>  goto out;
>}
>/* pure *//* unprivileged */
>#undef fetch_register
>#undef store_register
>#undef deref
>#undef store_deref
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__dwarf_tvar_get_HeapWordSize_2 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__dwarf_tvar_get_HeapWordSize_2_locals *  __restrict__ l = & c->locals[c->nesting+1].function__dwarf_tvar_get_HeapWordSize_2;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '$HeapWordSize' at /usr/share/systemtap/tapset/x86_64/jstack.stp:90:25";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>    
>#define fetch_register u_fetch_register
>#define store_register u_store_register
>#define deref uderef
>#define store_deref store_uderef
>{
>  {
>    uintptr_t addr;
>    { // synthesized
>    addr = 8L;
>    }
>    { int32_t value = addr; THIS->__retvalue = value; }
>  }
>  goto out;
>if (0) goto deref_fault;
>deref_fault:
>  goto out;
>}
>/* pure *//* unprivileged */
>#undef fetch_register
>#undef store_register
>#undef deref
>#undef store_deref
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__dwarf_tvar_get__collectedHeap_1 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__dwarf_tvar_get__collectedHeap_1_locals *  __restrict__ l = & c->locals[c->nesting+1].function__dwarf_tvar_get__collectedHeap_1;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '$_collectedHeap' at /usr/share/systemtap/tapset/x86_64/jstack.stp:89:40";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>    
>#define fetch_register u_fetch_register
>#define store_register u_store_register
>#define deref uderef
>#define store_deref store_uderef
>{
>  {
>    uintptr_t addr;
>    { // DWARF expression: 0x3(12448984)
>      {
>        uintptr_t s0;
>        s0 = ({ unsigned long addr = 0; addr = _stp_umodule_relocate ("/usr/lib/jvm/java-1.6.0-openjdk-1.6.0.0.x86_64/jre/lib/amd64/server/libjvm.so",0xbdf4d8, current); addr; });
>        addr = s0;
>      }
>    }
>    { // synthesized
>    { uint64_t value = deref (8, addr); addr = value; }
>    }
>    THIS->__retvalue = addr;
>  }
>  goto out;
>if (0) goto deref_fault;
>deref_fault:
>  goto out;
>}
>/* pure *//* unprivileged */
>#undef fetch_register
>#undef store_register
>#undef deref
>#undef store_deref
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__dwarf_tvar_get__heap_3 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__dwarf_tvar_get__heap_3_locals *  __restrict__ l = & c->locals[c->nesting+1].function__dwarf_tvar_get__heap_3;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '$_heap' at /usr/share/systemtap/tapset/x86_64/jstack.stp:110:32";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>    
>#define fetch_register u_fetch_register
>#define store_register u_store_register
>#define deref uderef
>#define store_deref store_uderef
>{
>  {
>    uintptr_t addr;
>    { // DWARF expression: 0x3(12326312)
>      {
>        uintptr_t s0;
>        s0 = ({ unsigned long addr = 0; addr = _stp_umodule_relocate ("/usr/lib/jvm/java-1.6.0-openjdk-1.6.0.0.x86_64/jre/lib/amd64/server/libjvm.so",0xbc15a8, current); addr; });
>        addr = s0;
>      }
>    }
>    { // synthesized
>    { uint64_t value = deref (8, addr); addr = value; }
>    }
>    THIS->__retvalue = addr;
>  }
>  goto out;
>if (0) goto deref_fault;
>deref_fault:
>  goto out;
>}
>/* pure *//* unprivileged */
>#undef fetch_register
>#undef store_register
>#undef deref
>#undef store_deref
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__dwarf_tvar_get__methodKlassObj_0 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__dwarf_tvar_get__methodKlassObj_0_locals *  __restrict__ l = & c->locals[c->nesting+1].function__dwarf_tvar_get__methodKlassObj_0;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '$_methodKlassObj' at /usr/share/systemtap/tapset/x86_64/jstack.stp:72:41";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>    
>#define fetch_register u_fetch_register
>#define store_register u_store_register
>#define deref uderef
>#define store_deref store_uderef
>{
>  {
>    uintptr_t addr;
>    { // DWARF expression: 0x3(12448456)
>      {
>        uintptr_t s0;
>        s0 = ({ unsigned long addr = 0; addr = _stp_umodule_relocate ("/usr/lib/jvm/java-1.6.0-openjdk-1.6.0.0.x86_64/jre/lib/amd64/server/libjvm.so",0xbdf2c8, current); addr; });
>        addr = s0;
>      }
>    }
>    { // synthesized
>    { uint64_t value = deref (8, addr); addr = value; }
>    }
>    THIS->__retvalue = addr;
>  }
>  goto out;
>if (0) goto deref_fault;
>deref_fault:
>  goto out;
>}
>/* pure *//* unprivileged */
>#undef fetch_register
>#undef store_register
>#undef deref
>#undef store_deref
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__stp_get_register_by_offset (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__stp_get_register_by_offset_locals *  __restrict__ l = & c->locals[c->nesting+1].function__stp_get_register_by_offset;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '_stp_get_register_by_offset' at /usr/share/systemtap/tapset/x86_64/registers.stp:48:10";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>     /* pure */
>	long value;
>	struct pt_regs *regs;
>	regs = ((CONTEXT->probe_flags & _STP_PROBE_STATE_USER_MODE)
>		? CONTEXT->uregs : CONTEXT->kregs);
>	if (!regs) {
>		CONTEXT->last_error = "No registers available in this context";
>		return;
>	}
>	if (THIS->offset < 0 || THIS->offset > sizeof(struct pt_regs) - sizeof(long)) {
>		snprintf(CONTEXT->error_buffer, sizeof(CONTEXT->error_buffer),
>				"Bad register offset: %lld", THIS->offset);
>		CONTEXT->last_error = CONTEXT->error_buffer;
>		return;
>	}
>	memcpy(&value, ((char *)regs) + THIS->offset, sizeof(value));
>	THIS->__retvalue = value;
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__stp_register (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__stp_register_locals *  __restrict__ l = & c->locals[c->nesting+1].function__stp_register;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '_stp_register' at /usr/share/systemtap/tapset/x86_64/registers.stp:75:10";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->reg32 = 0;
>  l->offset = 0;
>  l->value = 0;
>  l->__retvalue = 0;
>  #define return goto out
>  {
>    (void) 
>    ({
>      l->reg32 = ((int64_t)0LL);
>      ((int64_t)0LL);
>    });
>    
>    c->actionremaining -= 2;
>    if (unlikely (c->actionremaining <= 0)) {
>      c->last_error = "MAXACTION exceeded";
>      c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/registers.stp:77:2";
>      goto out;
>    }
>    if ((! (
>      ({
>        function_registers_valid (c);
>        if (unlikely(c->last_error)) goto out;
>        c->locals[c->nesting+1].function_registers_valid.__retvalue;
>      })))) {
>      {
>        (void) 
>        ({
>          strlcpy (c->locals[c->nesting+1].function_error.msg, "cannot access CPU registers in this context", MAXSTRINGLEN);
>          function_error (c);
>          if (unlikely(c->last_error)) goto out;
>          (void) 0;
>        });
>        
>        l->__retvalue = ((int64_t)0LL);
>        c->actionremaining -= 2;
>        if (unlikely (c->actionremaining <= 0)) {
>          c->last_error = "MAXACTION exceeded";
>          c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/registers.stp:79:3";
>          goto out;
>        }
>        goto out;
>        
>      }
>    }
>    
>    c->actionremaining -= 1;
>    if (unlikely (c->actionremaining <= 0)) {
>      c->last_error = "MAXACTION exceeded";
>      c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/registers.stp:81:2";
>      goto out;
>    }
>    if ((! (global.s__stp_regs_registered))) {
>      (void) 
>      ({
>        function__stp_register_regs (c);
>        if (unlikely(c->last_error)) goto out;
>        (void) 0;
>      });
>      c->actionremaining -= 1;
>      if (unlikely (c->actionremaining <= 0)) {
>        c->last_error = "MAXACTION exceeded";
>        c->last_stmt = "identifier '_stp_register_regs' at /usr/share/systemtap/tapset/x86_64/registers.stp:82:3";
>        goto out;
>      }
>    }
>    
>    (void) 
>    ({
>      l->__tmp3 = 
>      ({
>        strlcpy (l->__tmp5, l->name, MAXSTRINGLEN);
>        l->__tmp6 = _stp_map_get_si (global.s__reg_offsets, l->__tmp5);
>        l->__tmp6;
>      });
>      l->offset = l->__tmp3;
>      l->__tmp3;
>    });
>    
>    c->actionremaining -= 2;
>    if (unlikely (c->actionremaining <= 0)) {
>      c->last_error = "MAXACTION exceeded";
>      c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/registers.stp:84:2";
>      goto out;
>    }
>    if ((((((l->offset) == (((int64_t)0LL))))) && ((! (
>      ({
>        strlcpy (l->__tmp7, l->name, MAXSTRINGLEN);
>        l->__tmp8 = _stp_map_exists_si (global.s__reg_offsets, l->__tmp7);
>        l->__tmp8;
>      })))))) {
>      {
>        (void) 
>        ({
>          l->__tmp9 = 
>          ({
>            strlcpy (l->__tmp11, l->name, MAXSTRINGLEN);
>            l->__tmp12 = _stp_map_get_si (global.s__r32_offsets, l->__tmp11);
>            l->__tmp12;
>          });
>          l->offset = l->__tmp9;
>          l->__tmp9;
>        });
>        
>        c->actionremaining -= 2;
>        if (unlikely (c->actionremaining <= 0)) {
>          c->last_error = "MAXACTION exceeded";
>          c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/registers.stp:86:3";
>          goto out;
>        }
>        if ((((((l->offset) == (((int64_t)0LL))))) && ((! (
>          ({
>            strlcpy (l->__tmp13, l->name, MAXSTRINGLEN);
>            l->__tmp14 = _stp_map_exists_si (global.s__r32_offsets, l->__tmp13);
>            l->__tmp14;
>          })))))) {
>          {
>            (void) 
>            ({
>              strlcpy (l->__tmp15, ({ 
>                strlcpy (l->__tmp16, "Unknown register: ", MAXSTRINGLEN);
>                strlcat (l->__tmp16, l->name, MAXSTRINGLEN);
>                l->__tmp16;
>              }), MAXSTRINGLEN);
>              strlcpy (c->locals[c->nesting+1].function_error.msg, l->__tmp15, MAXSTRINGLEN);
>              function_error (c);
>              if (unlikely(c->last_error)) goto out;
>              (void) 0;
>            });
>            
>            l->__retvalue = ((int64_t)0LL);
>            c->actionremaining -= 2;
>            if (unlikely (c->actionremaining <= 0)) {
>              c->last_error = "MAXACTION exceeded";
>              c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/registers.stp:88:4";
>              goto out;
>            }
>            goto out;
>            
>          }
>        }
>        
>        (void) 
>        ({
>          l->reg32 = ((int64_t)1LL);
>          ((int64_t)1LL);
>        });
>        
>      }
>      c->actionremaining -= 1;
>      if (unlikely (c->actionremaining <= 0)) {
>        c->last_error = "MAXACTION exceeded";
>        c->last_stmt = "operator '{' at /usr/share/systemtap/tapset/x86_64/registers.stp:84:46";
>        goto out;
>      }
>    }
>    
>    (void) 
>    ({
>      l->__tmp19 = 
>      ({
>        l->__tmp21 = l->offset;
>        c->locals[c->nesting+1].function__stp_get_register_by_offset.offset = l->__tmp21;
>        function__stp_get_register_by_offset (c);
>        if (unlikely(c->last_error)) goto out;
>        c->locals[c->nesting+1].function__stp_get_register_by_offset.__retvalue;
>      });
>      l->value = l->__tmp19;
>      l->__tmp19;
>    });
>    
>    c->actionremaining -= 2;
>    if (unlikely (c->actionremaining <= 0)) {
>      c->last_error = "MAXACTION exceeded";
>      c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/registers.stp:93:2";
>      goto out;
>    }
>    if (l->reg32) {
>      c->actionremaining -= 1;
>      if (unlikely (c->actionremaining <= 0)) {
>        c->last_error = "MAXACTION exceeded";
>        c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/registers.stp:94:3";
>        goto out;
>      }
>      if (l->sign_extend) {
>        (void) 
>        ({
>          l->__tmp22 = 
>          ({
>            l->__tmp24 = l->value;
>            c->locals[c->nesting+1].function__stp_sign_extend32.value = l->__tmp24;
>            function__stp_sign_extend32 (c);
>            if (unlikely(c->last_error)) goto out;
>            c->locals[c->nesting+1].function__stp_sign_extend32.__retvalue;
>          });
>          l->value = l->__tmp22;
>          l->__tmp22;
>        });
>        c->actionremaining -= 1;
>        if (unlikely (c->actionremaining <= 0)) {
>          c->last_error = "MAXACTION exceeded";
>          c->last_stmt = "identifier 'value' at /usr/share/systemtap/tapset/x86_64/registers.stp:95:4";
>          goto out;
>        }
>      }
>      else {
>        (void) 
>        ({
>          l->value &= ((int64_t)4294967295LL);
>          l->value;
>        });
>        c->actionremaining -= 1;
>        if (unlikely (c->actionremaining <= 0)) {
>          c->last_error = "MAXACTION exceeded";
>          c->last_stmt = "identifier 'value' at /usr/share/systemtap/tapset/x86_64/registers.stp:97:4";
>          goto out;
>        }
>      }
>    }
>    
>    l->__retvalue = l->value;
>    c->actionremaining -= 1;
>    if (unlikely (c->actionremaining <= 0)) {
>      c->last_error = "MAXACTION exceeded";
>      c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/registers.stp:99:2";
>      goto out;
>    }
>    goto out;
>    
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__stp_register_regs (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__stp_register_regs_locals *  __restrict__ l = & c->locals[c->nesting+1].function__stp_register_regs;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '_stp_register_regs' at /usr/share/systemtap/tapset/x86_64/registers.stp:10:10";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  #define return goto out
>  {
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:12:2";
>      l->__tmp2 = ((int64_t)0LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "r15", l->__tmp2); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)0LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:13:2";
>      l->__tmp6 = ((int64_t)8LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "r14", l->__tmp6); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)8LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:14:2";
>      l->__tmp10 = ((int64_t)16LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "r13", l->__tmp10); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)16LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:15:2";
>      l->__tmp14 = ((int64_t)24LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "r12", l->__tmp14); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)24LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:16:2";
>      l->__tmp18 = ((int64_t)32LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "rbp", l->__tmp18); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)32LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:16:27";
>      l->__tmp22 = ((int64_t)32LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "bp", l->__tmp22); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)32LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:17:2";
>      l->__tmp26 = ((int64_t)40LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "rbx", l->__tmp26); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)40LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:17:27";
>      l->__tmp30 = ((int64_t)40LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "bx", l->__tmp30); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)40LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:18:2";
>      l->__tmp34 = ((int64_t)48LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "r11", l->__tmp34); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)48LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:19:2";
>      l->__tmp38 = ((int64_t)56LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "r10", l->__tmp38); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)56LL);
>    });
>    c->actionremaining -= 10;
>    if (unlikely (c->actionremaining <= 0)) {
>      c->last_error = "MAXACTION exceeded";
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:19:2";
>      goto out;
>    }
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:20:2";
>      l->__tmp42 = ((int64_t)64LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "r9", l->__tmp42); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)64LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:21:2";
>      l->__tmp46 = ((int64_t)72LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "r8", l->__tmp46); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)72LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:22:2";
>      l->__tmp50 = ((int64_t)80LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "rax", l->__tmp50); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)80LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:22:27";
>      l->__tmp54 = ((int64_t)80LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "ax", l->__tmp54); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)80LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:23:2";
>      l->__tmp58 = ((int64_t)88LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "rcx", l->__tmp58); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)88LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:23:27";
>      l->__tmp62 = ((int64_t)88LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "cx", l->__tmp62); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)88LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:24:2";
>      l->__tmp66 = ((int64_t)96LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "rdx", l->__tmp66); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)96LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:24:27";
>      l->__tmp70 = ((int64_t)96LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "dx", l->__tmp70); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)96LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:25:2";
>      l->__tmp74 = ((int64_t)104LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "rsi", l->__tmp74); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)104LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:25:28";
>      l->__tmp78 = ((int64_t)104LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "si", l->__tmp78); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)104LL);
>    });
>    c->actionremaining -= 10;
>    if (unlikely (c->actionremaining <= 0)) {
>      c->last_error = "MAXACTION exceeded";
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:25:28";
>      goto out;
>    }
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:26:2";
>      l->__tmp82 = ((int64_t)112LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "rdi", l->__tmp82); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)112LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:26:28";
>      l->__tmp86 = ((int64_t)112LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "di", l->__tmp86); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)112LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:27:2";
>      l->__tmp90 = ((int64_t)120LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "orig_rax", l->__tmp90); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)120LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:27:33";
>      l->__tmp94 = ((int64_t)120LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "orig_ax", l->__tmp94); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)120LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:28:2";
>      l->__tmp98 = ((int64_t)128LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "rip", l->__tmp98); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)128LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:28:28";
>      l->__tmp102 = ((int64_t)128LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "ip", l->__tmp102); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)128LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:29:2";
>      l->__tmp106 = ((int64_t)136LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "xcs", l->__tmp106); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)136LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:29:28";
>      l->__tmp110 = ((int64_t)136LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "cs", l->__tmp110); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)136LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:30:2";
>      l->__tmp114 = ((int64_t)144LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "eflags", l->__tmp114); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)144LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:30:31";
>      l->__tmp118 = ((int64_t)144LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "flags", l->__tmp118); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)144LL);
>    });
>    c->actionremaining -= 10;
>    if (unlikely (c->actionremaining <= 0)) {
>      c->last_error = "MAXACTION exceeded";
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:30:31";
>      goto out;
>    }
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:31:2";
>      l->__tmp122 = ((int64_t)152LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "rsp", l->__tmp122); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)152LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:31:28";
>      l->__tmp126 = ((int64_t)152LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "sp", l->__tmp126); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)152LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:32:2";
>      l->__tmp130 = ((int64_t)160LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "xss", l->__tmp130); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)160LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_reg_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:32:28";
>      l->__tmp134 = ((int64_t)160LL);
>      { int rc = _stp_map_set_si (global.s__reg_offsets, "ss", l->__tmp134); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)160LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_r32_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:34:2";
>      l->__tmp138 = ((int64_t)32LL);
>      { int rc = _stp_map_set_si (global.s__r32_offsets, "ebp", l->__tmp138); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)32LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_r32_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:35:2";
>      l->__tmp142 = ((int64_t)40LL);
>      { int rc = _stp_map_set_si (global.s__r32_offsets, "ebx", l->__tmp142); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)40LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_r32_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:36:2";
>      l->__tmp146 = ((int64_t)80LL);
>      { int rc = _stp_map_set_si (global.s__r32_offsets, "eax", l->__tmp146); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)80LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_r32_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:37:2";
>      l->__tmp150 = ((int64_t)88LL);
>      { int rc = _stp_map_set_si (global.s__r32_offsets, "ecx", l->__tmp150); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)88LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_r32_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:38:2";
>      l->__tmp154 = ((int64_t)96LL);
>      { int rc = _stp_map_set_si (global.s__r32_offsets, "edx", l->__tmp154); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)96LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_r32_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:39:2";
>      l->__tmp158 = ((int64_t)104LL);
>      { int rc = _stp_map_set_si (global.s__r32_offsets, "esi", l->__tmp158); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)104LL);
>    });
>    c->actionremaining -= 10;
>    if (unlikely (c->actionremaining <= 0)) {
>      c->last_error = "MAXACTION exceeded";
>      c->last_stmt = "identifier '_r32_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:39:2";
>      goto out;
>    }
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_r32_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:40:2";
>      l->__tmp162 = ((int64_t)112LL);
>      { int rc = _stp_map_set_si (global.s__r32_offsets, "edi", l->__tmp162); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)112LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_r32_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:41:2";
>      l->__tmp166 = ((int64_t)120LL);
>      { int rc = _stp_map_set_si (global.s__r32_offsets, "orig_eax", l->__tmp166); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)120LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_r32_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:42:2";
>      l->__tmp170 = ((int64_t)128LL);
>      { int rc = _stp_map_set_si (global.s__r32_offsets, "eip", l->__tmp170); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)128LL);
>    });
>    
>    (void) 
>    ({
>      c->last_stmt = "identifier '_r32_offsets' at /usr/share/systemtap/tapset/x86_64/registers.stp:43:2";
>      l->__tmp174 = ((int64_t)152LL);
>      { int rc = _stp_map_set_si (global.s__r32_offsets, "esp", l->__tmp174); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)152LL);
>    });
>    
>    (void) 
>    ({
>      global.s__stp_regs_registered = ((int64_t)1LL);
>      ((int64_t)1LL);
>    });
>    
>  }
>  #undef return
>  c->actionremaining -= 5;
>  if (unlikely (c->actionremaining <= 0)) {
>    c->last_error = "MAXACTION exceeded";
>    c->last_stmt = "operator '{' at /usr/share/systemtap/tapset/x86_64/registers.stp:10:31";
>    goto out;
>  }
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function__stp_sign_extend32 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function__stp_sign_extend32_locals *  __restrict__ l = & c->locals[c->nesting+1].function__stp_sign_extend32;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier '_stp_sign_extend32' at /usr/share/systemtap/tapset/x86_64/registers.stp:71:10";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>     /* pure */
>	THIS->__retvalue = __stp_sign_extend32(THIS->value);
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function_error (struct context* __restrict__ c) {
>  __label__ out;
>  struct function_error_locals *  __restrict__ l = & c->locals[c->nesting+1].function_error;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier 'error' at /usr/share/systemtap/tapset/logging.stp:65:10";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  #define return goto out
>  {
>     /* unprivileged */
>    /* This is an assignment of a local char[] to a global char*.
>       It would normally be just as unsafe as returning a pointer to
>       a local variable from a function.  However, the translated
>       code ensures that upon an error (last_error != NULL), the
>       context stack is only ever unwound, and not reused, before
>       the probe-level stp-error call.  */
>    CONTEXT->last_error = THIS->msg;
>    CONTEXT->last_stmt = NULL;
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function_jstack_call (struct context* __restrict__ c) {
>  __label__ out;
>  struct function_jstack_call_locals *  __restrict__ l = & c->locals[c->nesting+1].function_jstack_call;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier 'jstack_call' at /usr/share/systemtap/tapset/x86_64/jstack.stp:240:10";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->frame[0] = '\0';
>  l->heap_start = 0;
>  l->heap_size = 0;
>  l->heap_end = 0;
>  l->CodeCache_low = 0;
>  l->CodeCache_high = 0;
>  l->CodeHeap_log2_segment_size = 0;
>  l->CodeCache_segmap_low = 0;
>  l->frames[0] = '\0';
>  l->sp = 0;
>  l->fp = 0;
>  l->pc = 0;
>  l->depth = 0;
>  l->trust_fp = 0;
>  l->segments = 0;
>  l->segment = 0;
>  l->tag = 0;
>  l->block = 0;
>  l->used = 0;
>  l->blob_name[0] = '\0';
>  l->frame_size = 0;
>  l->blob = 0;
>  l->blob_name_ptr = 0;
>  l->methodOopPtr = 0;
>  l->isMethodOop = 0;
>  l->methodOopKlass = 0;
>  l->constantPoolOopDesc = 0;
>  l->constantPoolOop_base = 0;
>  l->klassPtr = 0;
>  l->klassSymbol = 0;
>  l->klassName = 0;
>  l->klassLength = 0;
>  l->methodIndex = 0;
>  l->methodOopDesc = 0;
>  l->methodName = 0;
>  l->methodLength = 0;
>  l->sigIndex = 0;
>  l->sigOopDesc = 0;
>  l->sigName = 0;
>  l->sigLength = 0;
>  l->sig[0] = '\0';
>  l->code_name[0] = '\0';
>  l->old_fp = 0;
>  l->old_sp = 0;
>  l->max_stack_scan = 0;
>  l->i = 0;
>  l->space[0] = '\0';
>  l->__retvalue[0] = '\0';
>  #define return goto out
>  {
>    c->actionremaining -= 1;
>    if (unlikely (c->actionremaining <= 0)) {
>      c->last_error = "MAXACTION exceeded";
>      c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:243:3";
>      goto out;
>    }
>    if ((! (
>      ({
>        l->__tmp0 = 
>        ({
>          function_pid (c);
>          if (unlikely(c->last_error)) goto out;
>          c->locals[c->nesting+1].function_pid.__retvalue;
>        });
>        l->__tmp1 = _stp_map_get_ii (global.s_vm_inited, l->__tmp0);
>        l->__tmp1;
>      })))) {
>      {
>        (void) 
>        ({
>          strlcpy (l->frame, "<vm-not-inited>", MAXSTRINGLEN);
>          "<vm-not-inited>";
>        });
>        
>        c->actionremaining -= 2;
>        if (unlikely (c->actionremaining <= 0)) {
>          c->last_error = "MAXACTION exceeded";
>          c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:246:7";
>          goto out;
>        }
>        if (l->print_frames) {
>          {
>            (void) 
>            ({
>              strlcpy (l->__tmp4, l->frame, MAXSTRINGLEN);
>              strlcpy (c->locals[c->nesting+1].function_log.msg, l->__tmp4, MAXSTRINGLEN);
>              function_log (c);
>              if (unlikely(c->last_error)) goto out;
>              (void) 0;
>            });
>            
>            strlcpy (l->__retvalue, "", MAXSTRINGLEN);
>            c->actionremaining -= 2;
>            if (unlikely (c->actionremaining <= 0)) {
>              c->last_error = "MAXACTION exceeded";
>              c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:249:11";
>              goto out;
>            }
>            goto out;
>            
>          }
>        }
>        else {
>          strlcpy (l->__retvalue, l->frame, MAXSTRINGLEN);
>          c->actionremaining -= 1;
>          if (unlikely (c->actionremaining <= 0)) {
>            c->last_error = "MAXACTION exceeded";
>            c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:252:9";
>            goto out;
>          }
>          goto out;
>        }
>        
>      }
>    }
>    
>    (void) 
>    ({
>      l->__tmp5 = 
>      ({
>        l->__tmp7 = 
>        ({
>          l->__tmp8 = 
>          ({
>            function_pid (c);
>            if (unlikely(c->last_error)) goto out;
>            c->locals[c->nesting+1].function_pid.__retvalue;
>          });
>          l->__tmp9 = _stp_map_get_ii (global.s_Universe_collectedHeap, l->__tmp8);
>          l->__tmp9;
>        });
>        c->locals[c->nesting+1].function__dwarf_cast_get_cast_1.pointer = l->__tmp7;
>        function__dwarf_cast_get_cast_1 (c);
>        if (unlikely(c->last_error)) goto out;
>        c->locals[c->nesting+1].function__dwarf_cast_get_cast_1.__retvalue;
>      });
>      l->heap_start = l->__tmp5;
>      l->__tmp5;
>    });
>    
>    (void) 
>    ({
>      l->__tmp10 = ((
>      ({
>        l->__tmp12 = 
>        ({
>          function_pid (c);
>          if (unlikely(c->last_error)) goto out;
>          c->locals[c->nesting+1].function_pid.__retvalue;
>        });
>        l->__tmp13 = _stp_map_get_ii (global.s_HeapWordSize, l->__tmp12);
>        l->__tmp13;
>      })) * (
>      ({
>        l->__tmp14 = 
>        ({
>          l->__tmp15 = 
>          ({
>            function_pid (c);
>            if (unlikely(c->last_error)) goto out;
>            c->locals[c->nesting+1].function_pid.__retvalue;
>          });
>          l->__tmp16 = _stp_map_get_ii (global.s_Universe_collectedHeap, l->__tmp15);
>          l->__tmp16;
>        });
>        c->locals[c->nesting+1].function__dwarf_cast_get_cast_2.pointer = l->__tmp14;
>        function__dwarf_cast_get_cast_2 (c);
>        if (unlikely(c->last_error)) goto out;
>        c->locals[c->nesting+1].function__dwarf_cast_get_cast_2.__retvalue;
>      })));
>      l->heap_size = l->__tmp10;
>      l->__tmp10;
>    });
>    
>    (void) 
>    ({
>      l->__tmp17 = ((l->heap_start) + (l->heap_size));
>      l->heap_end = l->__tmp17;
>      l->__tmp17;
>    });
>    
>    (void) 
>    ({
>      l->__tmp19 = 
>      ({
>        l->__tmp21 = 
>        ({
>          l->__tmp22 = 
>          ({
>            function_pid (c);
>            if (unlikely(c->last_error)) goto out;
>            c->locals[c->nesting+1].function_pid.__retvalue;
>          });
>          l->__tmp23 = _stp_map_get_ii (global.s_CodeCache_heap, l->__tmp22);
>          l->__tmp23;
>        });
>        c->locals[c->nesting+1].function__dwarf_cast_get_cast_3.pointer = l->__tmp21;
>        function__dwarf_cast_get_cast_3 (c);
>        if (unlikely(c->last_error)) goto out;
>        c->locals[c->nesting+1].function__dwarf_cast_get_cast_3.__retvalue;
>      });
>      l->CodeCache_low = l->__tmp19;
>      l->__tmp19;
>    });
>    
>    (void) 
>    ({
>      l->__tmp24 = 
>      ({
>        l->__tmp26 = 
>        ({
>          l->__tmp27 = 
>          ({
>            function_pid (c);
>            if (unlikely(c->last_error)) goto out;
>            c->locals[c->nesting+1].function_pid.__retvalue;
>          });
>          l->__tmp28 = _stp_map_get_ii (global.s_CodeCache_heap, l->__tmp27);
>          l->__tmp28;
>        });
>        c->locals[c->nesting+1].function__dwarf_cast_get_cast_4.pointer = l->__tmp26;
>        function__dwarf_cast_get_cast_4 (c);
>        if (unlikely(c->last_error)) goto out;
>        c->locals[c->nesting+1].function__dwarf_cast_get_cast_4.__retvalue;
>      });
>      l->CodeCache_high = l->__tmp24;
>      l->__tmp24;
>    });
>    
>    (void) 
>    ({
>      l->__tmp29 = 
>      ({
>        l->__tmp31 = 
>        ({
>          l->__tmp32 = 
>          ({
>            function_pid (c);
>            if (unlikely(c->last_error)) goto out;
>            c->locals[c->nesting+1].function_pid.__retvalue;
>          });
>          l->__tmp33 = _stp_map_get_ii (global.s_CodeCache_heap, l->__tmp32);
>          l->__tmp33;
>        });
>        c->locals[c->nesting+1].function__dwarf_cast_get_cast_5.pointer = l->__tmp31;
>        function__dwarf_cast_get_cast_5 (c);
>        if (unlikely(c->last_error)) goto out;
>        c->locals[c->nesting+1].function__dwarf_cast_get_cast_5.__retvalue;
>      });
>      l->CodeHeap_log2_segment_size = l->__tmp29;
>      l->__tmp29;
>    });
>    
>    (void) 
>    ({
>      l->__tmp34 = 
>      ({
>        l->__tmp36 = 
>        ({
>          l->__tmp37 = 
>          ({
>            function_pid (c);
>            if (unlikely(c->last_error)) goto out;
>            c->locals[c->nesting+1].function_pid.__retvalue;
>          });
>          l->__tmp38 = _stp_map_get_ii (global.s_CodeCache_heap, l->__tmp37);
>          l->__tmp38;
>        });
>        c->locals[c->nesting+1].function__dwarf_cast_get_cast_6.pointer = l->__tmp36;
>        function__dwarf_cast_get_cast_6 (c);
>        if (unlikely(c->last_error)) goto out;
>        c->locals[c->nesting+1].function__dwarf_cast_get_cast_6.__retvalue;
>      });
>      l->CodeCache_segmap_low = l->__tmp34;
>      l->__tmp34;
>    });
>    
>    (void) 
>    ({
>      strlcpy (l->frames, "", MAXSTRINGLEN);
>      "";
>    });
>    
>    (void) 
>    ({
>      l->__tmp41 = 
>      ({
>        strlcpy (l->__tmp43, global.s_sp_register, MAXSTRINGLEN);
>        strlcpy (c->locals[c->nesting+1].function_register.name, l->__tmp43, MAXSTRINGLEN);
>        function_register (c);
>        if (unlikely(c->last_error)) goto out;
>        c->locals[c->nesting+1].function_register.__retvalue;
>      });
>      l->sp = l->__tmp41;
>      l->__tmp41;
>    });
>    
>    (void) 
>    ({
>      l->__tmp44 = 
>      ({
>        strlcpy (l->__tmp46, global.s_fp_register, MAXSTRINGLEN);
>        strlcpy (c->locals[c->nesting+1].function_register.name, l->__tmp46, MAXSTRINGLEN);
>        function_register (c);
>        if (unlikely(c->last_error)) goto out;
>        c->locals[c->nesting+1].function_register.__retvalue;
>      });
>      l->fp = l->__tmp44;
>      l->__tmp44;
>    });
>    c->actionremaining -= 10;
>    if (unlikely (c->actionremaining <= 0)) {
>      c->last_error = "MAXACTION exceeded";
>      c->last_stmt = "identifier 'fp' at /usr/share/systemtap/tapset/x86_64/jstack.stp:286:3";
>      goto out;
>    }
>    
>    (void) 
>    ({
>      l->__tmp47 = 
>      ({
>        strlcpy (l->__tmp49, global.s_pc_register, MAXSTRINGLEN);
>        strlcpy (c->locals[c->nesting+1].function_register.name, l->__tmp49, MAXSTRINGLEN);
>        function_register (c);
>        if (unlikely(c->last_error)) goto out;
>        c->locals[c->nesting+1].function_register.__retvalue;
>      });
>      l->pc = l->__tmp47;
>      l->__tmp47;
>    });
>    
>    (void) 
>    ({
>      l->depth = ((int64_t)0LL);
>      ((int64_t)0LL);
>    });
>    
>    c->actionremaining -= 3;
>    if (unlikely (c->actionremaining <= 0)) {
>      c->last_error = "MAXACTION exceeded";
>      c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:289:3";
>      goto out;
>    }
>  top_0:
>    if (! ((((((l->pc) != (((int64_t)0LL))))) && ((((l->depth) < (l->max_depth))))))) goto break_0;
>    {
>      (void) 
>      ({
>        strlcpy (l->frame, "", MAXSTRINGLEN);
>        "";
>      });
>      
>      (void) 
>      ({
>        l->trust_fp = ((int64_t)1LL);
>        ((int64_t)1LL);
>      });
>      
>      c->actionremaining -= 4;
>      if (unlikely (c->actionremaining <= 0)) {
>        c->last_error = "MAXACTION exceeded";
>        c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:297:7";
>        goto out;
>      }
>      if ((((((l->CodeCache_low) <= (l->pc)))) && ((((l->pc) < (l->CodeCache_high)))))) {
>        {
>          (void) 
>          ({
>            l->segments = ((int64_t)0LL);
>            ((int64_t)0LL);
>          });
>          
>          (void) 
>          ({
>            l->__tmp58 = ((((l->pc) - (l->CodeCache_low))) >>max(min(l->CodeHeap_log2_segment_size, (int64_t)64LL), (int64_t)0LL));
>            l->segment = l->__tmp58;
>            l->__tmp58;
>          });
>          
>          (void) 
>          ({
>            l->__tmp60 = ((
>            ({
>              l->__tmp62 = ((l->CodeCache_segmap_low) + (l->segment));
>              c->locals[c->nesting+1].function_user_char.addr = l->__tmp62;
>              function_user_char (c);
>              if (unlikely(c->last_error)) goto out;
>              c->locals[c->nesting+1].function_user_char.__retvalue;
>            })) & (((int64_t)255LL)));
>            l->tag = l->__tmp60;
>            l->__tmp60;
>          });
>          
>          c->actionremaining -= 4;
>          if (unlikely (c->actionremaining <= 0)) {
>            c->last_error = "MAXACTION exceeded";
>            c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:304:4";
>            goto out;
>          }
>        top_1:
>          if (! ((((((l->tag) > (((int64_t)0LL))))) && ((((l->segments) < (((int64_t)16LL)))))))) goto break_1;
>          {
>            (void) 
>            ({
>              l->__tmp63 = ((l->segment) - (l->tag));
>              l->segment = l->__tmp63;
>              l->__tmp63;
>            });
>            
>            (void) 
>            ({
>              l->__tmp65 = ((
>              ({
>                l->__tmp67 = ((l->CodeCache_segmap_low) + (l->segment));
>                c->locals[c->nesting+1].function_user_char.addr = l->__tmp67;
>                function_user_char (c);
>                if (unlikely(c->last_error)) goto out;
>                c->locals[c->nesting+1].function_user_char.__retvalue;
>              })) & (((int64_t)255LL)));
>              l->tag = l->__tmp65;
>              l->__tmp65;
>            });
>            
>            (void) 
>            ({
>              l->__tmp69 = l->segments;
>              l->segments += 1;
>              l->__tmp69;
>            });
>            
>          }
>          c->actionremaining -= 4;
>          if (unlikely (c->actionremaining <= 0)) {
>            c->last_error = "MAXACTION exceeded";
>            c->last_stmt = "operator '{' at /usr/share/systemtap/tapset/x86_64/jstack.stp:305:13";
>            goto out;
>          }
>        continue_1:
>          goto top_1;
>        break_1:
>          ; /* dummy statement */
>          
>          (void) 
>          ({
>            l->__tmp70 = ((l->CodeCache_low) + (((l->segment) <<max(min(l->CodeHeap_log2_segment_size, (int64_t)64LL), (int64_t)0LL))));
>            l->block = l->__tmp70;
>            l->__tmp70;
>          });
>          
>          c->actionremaining -= 1;
>          if (unlikely (c->actionremaining <= 0)) {
>            c->last_error = "MAXACTION exceeded";
>            c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:314:11";
>            goto out;
>          }
>          {
>            __label__ normal_fallthrough;
>              {
>              __label__ out;
>              {
>                (void) 
>                ({
>                  l->__tmp72 = 
>                  ({
>                    l->__tmp74 = l->block;
>                    c->locals[c->nesting+1].function__dwarf_cast_get_cast_7.pointer = l->__tmp74;
>                    function__dwarf_cast_get_cast_7 (c);
>                    if (unlikely(c->last_error)) goto out;
>                    c->locals[c->nesting+1].function__dwarf_cast_get_cast_7.__retvalue;
>                  });
>                  l->used = l->__tmp72;
>                  l->__tmp72;
>                });
>                
>                c->actionremaining -= 2;
>                if (unlikely (c->actionremaining <= 0)) {
>                  c->last_error = "MAXACTION exceeded";
>                  c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:320:15";
>                  goto out;
>                }
>                if ((((l->used) != (((int64_t)1LL))))) {
>                  {
>                    (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;
>                    });
>                    
>                    (void) 
>                    ({
>                      strlcpy (l->blob_name, "unused", MAXSTRINGLEN);
>                      "unused";
>                    });
>                    
>                    (void) 
>                    ({
>                      l->trust_fp = ((int64_t)0LL);
>                      ((int64_t)0LL);
>                    });
>                    
>                    (void) 
>                    ({
>                      l->frame_size = ((int64_t)0LL);
>                      ((int64_t)0LL);
>                    });
>                    
>                  }
>                  c->actionremaining -= 4;
>                  if (unlikely (c->actionremaining <= 0)) {
>                    c->last_error = "MAXACTION exceeded";
>                    c->last_stmt = "operator '{' at /usr/share/systemtap/tapset/x86_64/jstack.stp:321:17";
>                    goto out;
>                  }
>                }
>                else {
>                  {
>                    (void) 
>                    ({
>                      l->__tmp85 = ((l->block) + (global.s_HeapBlock_Header_size));
>                      l->blob = l->__tmp85;
>                      l->__tmp85;
>                    });
>                    
>                    (void) 
>                    ({
>                      l->__tmp87 = 
>                      ({
>                        l->__tmp89 = l->blob;
>                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_10.pointer = l->__tmp89;
>                        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;
>                    });
>                    
>                    (void) 
>                    ({
>                      strlcpy (l->__tmp90, (((((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;
>                        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;
>                    });
>                    
>                  }
>                  c->actionremaining -= 3;
>                  if (unlikely (c->actionremaining <= 0)) {
>                    c->last_error = "MAXACTION exceeded";
>                    c->last_stmt = "operator '{' at /usr/share/systemtap/tapset/x86_64/jstack.stp:329:17";
>                    goto out;
>                  }
>                }
>                
>                c->actionremaining -= 1;
>                if (unlikely (c->actionremaining <= 0)) {
>                  c->last_error = "MAXACTION exceeded";
>                  c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:343:15";
>                  goto out;
>                }
>                if ((({
>                    strlcpy (l->__tmp93, l->blob_name, MAXSTRINGLEN);
>                    strncmp (l->__tmp93, "nmethod", MAXSTRINGLEN) == 0;
>                  }))) {
>                  (void) 
>                  ({
>                    l->__tmp94 = 
>                    ({
>                      l->__tmp96 = l->blob;
>                      c->locals[c->nesting+1].function__dwarf_cast_get_cast_9.pointer = l->__tmp96;
>                      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;
>                  });
>                  c->actionremaining -= 1;
>                  if (unlikely (c->actionremaining <= 0)) {
>                    c->last_error = "MAXACTION exceeded";
>                    c->last_stmt = "identifier 'methodOopPtr' at /usr/share/systemtap/tapset/x86_64/jstack.stp:344:17";
>                    goto out;
>                  }
>                }
>                else {
>                  (void) 
>                  ({
>                    l->__tmp97 = ((
>                    ({
>                      l->__tmp99 = ((l->fp) + (((((int64_t)-3LL)) * (global.s_ptr_size))));
>                      c->locals[c->nesting+1].function_user_long.addr = l->__tmp99;
>                      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;
>                  });
>                  c->actionremaining -= 1;
>                  if (unlikely (c->actionremaining <= 0)) {
>                    c->last_error = "MAXACTION exceeded";
>                    c->last_stmt = "identifier 'methodOopPtr' at /usr/share/systemtap/tapset/x86_64/jstack.stp:347:17";
>                    goto out;
>                  }
>                }
>                
>                c->actionremaining -= 1;
>                if (unlikely (c->actionremaining <= 0)) {
>                  c->last_error = "MAXACTION exceeded";
>                  c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:352:15";
>                  goto out;
>                }
>                if ((((((l->heap_start) > (l->methodOopPtr)))) || ((((l->methodOopPtr) >= (l->heap_end)))))) {
>                  (void) 
>                  ({
>                    l->isMethodOop = ((int64_t)0LL);
>                    ((int64_t)0LL);
>                  });
>                  c->actionremaining -= 1;
>                  if (unlikely (c->actionremaining <= 0)) {
>                    c->last_error = "MAXACTION exceeded";
>                    c->last_stmt = "identifier 'isMethodOop' at /usr/share/systemtap/tapset/x86_64/jstack.stp:353:17";
>                    goto out;
>                  }
>                }
>                else {
>                  {
>                    (void) 
>                    ({
>                      l->__tmp102 = 
>                      ({
>                        l->__tmp104 = l->methodOopPtr;
>                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_10.pointer = l->__tmp104;
>                        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;
>                    });
>                    
>                    (void) 
>                    ({
>                      l->__tmp105 = (((l->methodOopKlass) == (
>                      ({
>                        l->__tmp107 = 
>                        ({
>                          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->isMethodOop = l->__tmp105;
>                      l->__tmp105;
>                    });
>                    
>                  }
>                  c->actionremaining -= 2;
>                  if (unlikely (c->actionremaining <= 0)) {
>                    c->last_error = "MAXACTION exceeded";
>                    c->last_stmt = "operator '{' at /usr/share/systemtap/tapset/x86_64/jstack.stp:355:17";
>                    goto out;
>                  }
>                }
>                
>                c->actionremaining -= 1;
>                if (unlikely (c->actionremaining <= 0)) {
>                  c->last_error = "MAXACTION exceeded";
>                  c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:361:15";
>                  goto out;
>                }
>                if (l->isMethodOop) {
>                  {
>                    (void) 
>                    ({
>                      l->__tmp109 = 
>                      ({
>                        l->__tmp111 = l->methodOopPtr;
>                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_11.pointer = l->__tmp111;
>                        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;
>                    });
>                    
>                    (void) 
>                    ({
>                      l->__tmp112 = ((l->constantPoolOopDesc) + (global.s_constantPoolOopDesc_size));
>                      l->constantPoolOop_base = l->__tmp112;
>                      l->__tmp112;
>                    });
>                    
>                    (void) 
>                    ({
>                      l->__tmp114 = 
>                      ({
>                        l->__tmp116 = l->constantPoolOopDesc;
>                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_12.pointer = l->__tmp116;
>                        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;
>                    });
>                    
>                    (void) 
>                    ({
>                      l->__tmp117 = 
>                      ({
>                        l->__tmp119 = ((l->klassPtr) + (global.s_oopDesc_size));
>                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_13.pointer = l->__tmp119;
>                        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;
>                    });
>                    
>                    (void) 
>                    ({
>                      l->__tmp120 = 
>                      ({
>                        l->__tmp122 = l->klassSymbol;
>                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_14.pointer = l->__tmp122;
>                        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;
>                    });
>                    
>                    (void) 
>                    ({
>                      l->__tmp123 = 
>                      ({
>                        l->__tmp125 = l->klassSymbol;
>                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_15.pointer = l->__tmp125;
>                        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;
>                    });
>                    
>                    (void) 
>                    ({
>                      l->__tmp126 = 
>                      ({
>                        l->__tmp128 = l->methodOopPtr;
>                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_16.pointer = l->__tmp128;
>                        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;
>                    });
>                    
>                    (void) 
>                    ({
>                      l->__tmp129 = 
>                      ({
>                        l->__tmp131 = ((l->constantPoolOop_base) + (((l->methodIndex) * (global.s_ptr_size))));
>                        c->locals[c->nesting+1].function_user_long.addr = l->__tmp131;
>                        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;
>                    });
>                    
>                    (void) 
>                    ({
>                      l->__tmp132 = 
>                      ({
>                        l->__tmp134 = l->methodOopDesc;
>                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_14.pointer = l->__tmp134;
>                        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;
>                    });
>                    
>                    (void) 
>                    ({
>                      l->__tmp135 = 
>                      ({
>                        l->__tmp137 = l->methodOopDesc;
>                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_15.pointer = l->__tmp137;
>                        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;
>                    });
>                    c->actionremaining -= 10;
>                    if (unlikely (c->actionremaining <= 0)) {
>                      c->last_error = "MAXACTION exceeded";
>                      c->last_stmt = "identifier 'methodLength' at /usr/share/systemtap/tapset/x86_64/jstack.stp:392:19";
>                      goto out;
>                    }
>                    
>                    c->actionremaining -= 1;
>                    if (unlikely (c->actionremaining <= 0)) {
>                      c->last_error = "MAXACTION exceeded";
>                      c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:395:19";
>                      goto out;
>                    }
>                    if (l->log_sig) {
>                      {
>                        (void) 
>                        ({
>                          l->__tmp138 = 
>                          ({
>                            l->__tmp140 = l->methodOopPtr;
>                            c->locals[c->nesting+1].function__dwarf_cast_get_cast_19.pointer = l->__tmp140;
>                            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;
>                        });
>                        
>                        (void) 
>                        ({
>                          l->__tmp141 = 
>                          ({
>                            l->__tmp143 = ((l->constantPoolOop_base) + (((l->sigIndex) * (global.s_ptr_size))));
>                            c->locals[c->nesting+1].function_user_long.addr = l->__tmp143;
>                            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;
>                        });
>                        
>                        (void) 
>                        ({
>                          l->__tmp144 = 
>                          ({
>                            l->__tmp146 = l->sigOopDesc;
>                            c->locals[c->nesting+1].function__dwarf_cast_get_cast_14.pointer = l->__tmp146;
>                            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;
>                        });
>                        
>                        (void) 
>                        ({
>                          l->__tmp147 = 
>                          ({
>                            l->__tmp149 = l->sigOopDesc;
>                            c->locals[c->nesting+1].function__dwarf_cast_get_cast_15.pointer = l->__tmp149;
>                            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;
>                        });
>                        
>                        (void) 
>                        ({
>                          strlcpy (l->__tmp150, 
>                          ({
>                            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;
>                            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;
>                        });
>                        
>                      }
>                      c->actionremaining -= 5;
>                      if (unlikely (c->actionremaining <= 0)) {
>                        c->last_error = "MAXACTION exceeded";
>                        c->last_stmt = "operator '{' at /usr/share/systemtap/tapset/x86_64/jstack.stp:396:21";
>                        goto out;
>                      }
>                    }
>                    else {
>                      (void) 
>                      ({
>                        strlcpy (l->sig, "", MAXSTRINGLEN);
>                        "";
>                      });
>                      c->actionremaining -= 1;
>                      if (unlikely (c->actionremaining <= 0)) {
>                        c->last_error = "MAXACTION exceeded";
>                        c->last_stmt = "identifier 'sig' at /usr/share/systemtap/tapset/x86_64/jstack.stp:408:21";
>                        goto out;
>                      }
>                    }
>                    
>                    (void) 
>                    ({
>                      strlcpy (l->__tmp156, ((l->log_native) ? (
>                      ({
>                        strlcpy (l->__tmp158, 
>                        ({
>                          strlcpy (l->__tmp159, l->blob_name, MAXSTRINGLEN);
>                          strlcpy (c->locals[c->nesting+1].function_str_replace.prnt_str, l->__tmp159, 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;
>                        #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);
>                        #else // STP_LEGACY_PRINT
>                          _stp_snprintf (l->__tmp163, MAXSTRINGLEN, "<%s@0x%llx>", l->__tmp158, l->__tmp162);
>                        #endif // STP_LEGACY_PRINT
>                        if (unlikely(c->last_error)) goto out;
>                        l->__tmp163;
>                      })) : ("")), MAXSTRINGLEN);
>                      strlcpy (l->code_name, l->__tmp156, MAXSTRINGLEN);
>                      l->__tmp156;
>                    });
>                    
>                    (void) 
>                    ({
>                      strlcpy (l->__tmp164, 
>                      ({
>                        strlcpy (l->__tmp166, 
>                        ({
>                          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;
>                          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, 
>                        ({
>                          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;
>                          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);
>                        #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);
>                        #else // STP_LEGACY_PRINT
>                          _stp_snprintf (l->__tmp174, MAXSTRINGLEN, "%s.%s%s%s", l->__tmp166, l->__tmp169, l->__tmp172, l->__tmp173);
>                        #endif // STP_LEGACY_PRINT
>                        if (unlikely(c->last_error)) goto out;
>                        l->__tmp174;
>                      }), MAXSTRINGLEN);
>                      strlcpy (l->frame, l->__tmp164, MAXSTRINGLEN);
>                      l->__tmp164;
>                    });
>                    
>                  }
>                  c->actionremaining -= 2;
>                  if (unlikely (c->actionremaining <= 0)) {
>                    c->last_error = "MAXACTION exceeded";
>                    c->last_stmt = "operator '{' at /usr/share/systemtap/tapset/x86_64/jstack.stp:362:17";
>                    goto out;
>                  }
>                }
>                else {
>                  c->actionremaining -= 1;
>                  if (unlikely (c->actionremaining <= 0)) {
>                    c->last_error = "MAXACTION exceeded";
>                    c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:425:19";
>                    goto out;
>                  }
>                  if (l->log_native) {
>                    (void) 
>                    ({
>                      strlcpy (l->__tmp175, 
>                      ({
>                        strlcpy (l->__tmp177, 
>                        ({
>                          strlcpy (l->__tmp178, l->blob_name, MAXSTRINGLEN);
>                          strlcpy (c->locals[c->nesting+1].function_str_replace.prnt_str, l->__tmp178, 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;
>                        #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);
>                        #else // STP_LEGACY_PRINT
>                          _stp_snprintf (l->__tmp182, MAXSTRINGLEN, "<%s@0x%llx>", l->__tmp177, l->__tmp181);
>                        #endif // STP_LEGACY_PRINT
>                        if (unlikely(c->last_error)) goto out;
>                        l->__tmp182;
>                      }), MAXSTRINGLEN);
>                      strlcpy (l->frame, l->__tmp175, MAXSTRINGLEN);
>                      l->__tmp175;
>                    });
>                    c->actionremaining -= 1;
>                    if (unlikely (c->actionremaining <= 0)) {
>                      c->last_error = "MAXACTION exceeded";
>                      c->last_stmt = "identifier 'frame' at /usr/share/systemtap/tapset/x86_64/jstack.stp:426:21";
>                      goto out;
>                    }
>                  }
>                }
>                
>                c->actionremaining -= 1;
>                if (unlikely (c->actionremaining <= 0)) {
>                  c->last_error = "MAXACTION exceeded";
>                  c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:435:15";
>                  goto out;
>                }
>                if ((({
>                    strlcpy (l->__tmp183, l->blob_name, MAXSTRINGLEN);
>                    strncmp (l->__tmp183, "nmethod", MAXSTRINGLEN) == 0;
>                  }))) {
>                  {
>                    (void) 
>                    ({
>                      l->trust_fp = ((int64_t)0LL);
>                      ((int64_t)0LL);
>                    });
>                    
>                    (void) 
>                    ({
>                      l->__tmp186 = 
>                      ({
>                        l->__tmp188 = l->blob;
>                        c->locals[c->nesting+1].function__dwarf_cast_get_cast_22.pointer = l->__tmp188;
>                        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;
>                    });
>                    
>                  }
>                  c->actionremaining -= 2;
>                  if (unlikely (c->actionremaining <= 0)) {
>                    c->last_error = "MAXACTION exceeded";
>                    c->last_stmt = "operator '{' at /usr/share/systemtap/tapset/x86_64/jstack.stp:436:17";
>                    goto out;
>                  }
>                }
>                
>              }
>              goto normal_fallthrough;
>              if (0) goto out;
>              out:
>              ;
>            }
>            if (likely(c->last_error == NULL)) goto out;
>            c->last_error = NULL;
>            c->actionremaining -= 1;
>            if (unlikely (c->actionremaining <= 0)) {
>              c->last_error = "MAXACTION exceeded";
>              c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:314:11";
>              goto out;
>            }
>            {
>              (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;
>              });
>              
>              (void) 
>              ({
>                l->trust_fp = ((int64_t)0LL);
>                ((int64_t)0LL);
>              });
>              
>            }
>            c->actionremaining -= 2;
>            if (unlikely (c->actionremaining <= 0)) {
>              c->last_error = "MAXACTION exceeded";
>              c->last_stmt = "operator '{' at /usr/share/systemtap/tapset/x86_64/jstack.stp:444:13";
>              goto out;
>            }
>            normal_fallthrough:
>            ;
>          }
>          
>        }
>      }
>      else {
>        c->actionremaining -= 1;
>        if (unlikely (c->actionremaining <= 0)) {
>          c->last_error = "MAXACTION exceeded";
>          c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:459:11";
>          goto out;
>        }
>        if (l->log_native) {
>          (void) 
>          ({
>            strlcpy (l->__tmp195, 
>            ({
>              l->__tmp197 = l->pc;
>              c->locals[c->nesting+1].function_usymname.addr = l->__tmp197;
>              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;
>          });
>          c->actionremaining -= 1;
>          if (unlikely (c->actionremaining <= 0)) {
>            c->last_error = "MAXACTION exceeded";
>            c->last_stmt = "identifier 'frame' at /usr/share/systemtap/tapset/x86_64/jstack.stp:460:13";
>            goto out;
>          }
>        }
>      }
>      
>      (void) 
>      ({
>        l->__tmp198 = l->fp;
>        l->old_fp = l->__tmp198;
>        l->__tmp198;
>      });
>      
>      (void) 
>      ({
>        l->__tmp200 = l->sp;
>        l->old_sp = l->__tmp200;
>        l->__tmp200;
>      });
>      
>      (void) 
>      ({
>        l->__tmp202 = l->fp;
>        l->sp = l->__tmp202;
>        l->__tmp202;
>      });
>      
>      (void) 
>      ({
>        l->__tmp204 = 
>        ({
>          l->__tmp206 = l->sp;
>          c->locals[c->nesting+1].function_user_long.addr = l->__tmp206;
>          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;
>      });
>      
>      (void) 
>      ({
>        l->__tmp207 = 
>        ({
>          l->__tmp209 = ((l->fp) + (global.s_ptr_size));
>          c->locals[c->nesting+1].function_user_long.addr = l->__tmp209;
>          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;
>      });
>      
>      c->actionremaining -= 6;
>      if (unlikely (c->actionremaining <= 0)) {
>        c->last_error = "MAXACTION exceeded";
>        c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:479:9";
>        goto out;
>      }
>      if ((! (l->trust_fp))) {
>        {
>          (void) 
>          ({
>            l->max_stack_scan = ((int64_t)96LL);
>            ((int64_t)96LL);
>          });
>          
>          (void) 
>          ({
>            l->i = ((int64_t)1LL);
>            ((int64_t)1LL);
>          });
>          
>          c->actionremaining -= 3;
>          if (unlikely (c->actionremaining <= 0)) {
>            c->last_error = "MAXACTION exceeded";
>            c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:491:13";
>            goto out;
>          }
>        top_2:
>          if (! ((((((l->i) < (l->max_stack_scan)))) && ((((((((l->CodeCache_low) > (l->pc)))) || ((((l->pc) >= (l->CodeCache_high)))))) || ((((l->fp) <= (l->old_fp))))))))) goto break_2;
>          {
>            (void) 
>            ({
>              l->__tmp214 = ((l->old_sp) + (((((l->frame_size) + (l->i))) * (global.s_ptr_size))));
>              l->sp = l->__tmp214;
>              l->__tmp214;
>            });
>            
>            (void) 
>            ({
>              l->__tmp216 = 
>              ({
>                l->__tmp218 = l->sp;
>                c->locals[c->nesting+1].function_user_long.addr = l->__tmp218;
>                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;
>            });
>            
>            (void) 
>            ({
>              l->__tmp219 = 
>              ({
>                l->__tmp221 = ((l->fp) + (global.s_ptr_size));
>                c->locals[c->nesting+1].function_user_long.addr = l->__tmp221;
>                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;
>            });
>            
>            (void) 
>            ({
>              l->__tmp223 = l->i;
>              l->i += 1;
>              l->__tmp223;
>            });
>            
>          }
>          c->actionremaining -= 5;
>          if (unlikely (c->actionremaining <= 0)) {
>            c->last_error = "MAXACTION exceeded";
>            c->last_stmt = "operator '{' at /usr/share/systemtap/tapset/x86_64/jstack.stp:495:15";
>            goto out;
>          }
>        continue_2:
>          goto top_2;
>        break_2:
>          ; /* dummy statement */
>          
>          c->actionremaining -= 1;
>          if (unlikely (c->actionremaining <= 0)) {
>            c->last_error = "MAXACTION exceeded";
>            c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:501:13";
>            goto out;
>          }
>          if ((((l->i) == (l->max_stack_scan)))) {
>            {
>              c->actionremaining -= 1;
>              if (unlikely (c->actionremaining <= 0)) {
>                c->last_error = "MAXACTION exceeded";
>                c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:503:17";
>                goto out;
>              }
>              if ((! (l->print_frames))) {
>                (void) 
>                ({
>                  strlcpy (l->__tmp224, ({ 
>                    strlcpy (l->__tmp226, l->frames, MAXSTRINGLEN);
>                    strlcat (l->__tmp226, " <stack_lost>", MAXSTRINGLEN);
>                    l->__tmp226;
>                  }), MAXSTRINGLEN);
>                  strlcpy (l->frames, l->__tmp224, MAXSTRINGLEN);
>                  l->__tmp224;
>                });
>                c->actionremaining -= 1;
>                if (unlikely (c->actionremaining <= 0)) {
>                  c->last_error = "MAXACTION exceeded";
>                  c->last_stmt = "identifier 'frames' at /usr/share/systemtap/tapset/x86_64/jstack.stp:504:19";
>                  goto out;
>                }
>              }
>              else {
>                (void) 
>                ({
>                  strlcpy (c->locals[c->nesting+1].function_log.msg, "<stack_lost>", MAXSTRINGLEN);
>                  function_log (c);
>                  if (unlikely(c->last_error)) goto out;
>                  (void) 0;
>                });
>                c->actionremaining -= 1;
>                if (unlikely (c->actionremaining <= 0)) {
>                  c->last_error = "MAXACTION exceeded";
>                  c->last_stmt = "identifier 'log' at /usr/share/systemtap/tapset/x86_64/jstack.stp:506:19";
>                  goto out;
>                }
>              }
>              
>              (void) 
>              ({
>                l->pc = ((int64_t)0LL);
>                ((int64_t)0LL);
>              });
>              
>            }
>            c->actionremaining -= 1;
>            if (unlikely (c->actionremaining <= 0)) {
>              c->last_error = "MAXACTION exceeded";
>              c->last_stmt = "operator '{' at /usr/share/systemtap/tapset/x86_64/jstack.stp:502:15";
>              goto out;
>            }
>          }
>          
>        }
>      }
>      
>      c->actionremaining -= 1;
>      if (unlikely (c->actionremaining <= 0)) {
>        c->last_error = "MAXACTION exceeded";
>        c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:511:7";
>        goto out;
>      }
>      if ((({
>          strlcpy (l->__tmp230, l->frame, MAXSTRINGLEN);
>          strncmp (l->__tmp230, "", MAXSTRINGLEN) != 0;
>        }))) {
>        {
>          c->actionremaining -= 1;
>          if (unlikely (c->actionremaining <= 0)) {
>            c->last_error = "MAXACTION exceeded";
>            c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:513:11";
>            goto out;
>          }
>          if ((! (l->print_frames))) {
>            {
>              (void) 
>              ({
>                strlcpy (l->__tmp231, (((((l->depth) != (((int64_t)0LL))))) ? (" ") : ("")), MAXSTRINGLEN);
>                strlcpy (l->space, l->__tmp231, MAXSTRINGLEN);
>                l->__tmp231;
>              });
>              
>              (void) 
>              ({
>                strlcpy (l->__tmp233, ({ 
>                  strlcpy (l->__tmp235, ({ 
>                    strlcpy (l->__tmp236, l->frames, MAXSTRINGLEN);
>                    strlcat (l->__tmp236, l->space, MAXSTRINGLEN);
>                    l->__tmp236;
>                  }), MAXSTRINGLEN);
>                  strlcat (l->__tmp235, l->frame, MAXSTRINGLEN);
>                  l->__tmp235;
>                }), MAXSTRINGLEN);
>                strlcpy (l->frames, l->__tmp233, MAXSTRINGLEN);
>                l->__tmp233;
>              });
>              
>            }
>            c->actionremaining -= 2;
>            if (unlikely (c->actionremaining <= 0)) {
>              c->last_error = "MAXACTION exceeded";
>              c->last_stmt = "operator '{' at /usr/share/systemtap/tapset/x86_64/jstack.stp:514:13";
>              goto out;
>            }
>          }
>          else {
>            (void) 
>            ({
>              strlcpy (l->__tmp237, l->frame, MAXSTRINGLEN);
>              strlcpy (c->locals[c->nesting+1].function_log.msg, l->__tmp237, MAXSTRINGLEN);
>              function_log (c);
>              if (unlikely(c->last_error)) goto out;
>              (void) 0;
>            });
>            c->actionremaining -= 1;
>            if (unlikely (c->actionremaining <= 0)) {
>              c->last_error = "MAXACTION exceeded";
>              c->last_stmt = "identifier 'log' at /usr/share/systemtap/tapset/x86_64/jstack.stp:519:13";
>              goto out;
>            }
>          }
>          
>          (void) 
>          ({
>            l->__tmp239 = l->depth;
>            l->depth += 1;
>            l->__tmp239;
>          });
>          
>        }
>        c->actionremaining -= 1;
>        if (unlikely (c->actionremaining <= 0)) {
>          c->last_error = "MAXACTION exceeded";
>          c->last_stmt = "operator '{' at /usr/share/systemtap/tapset/x86_64/jstack.stp:512:9";
>          goto out;
>        }
>      }
>      
>    }
>  continue_0:
>    goto top_0;
>  break_0:
>    ; /* dummy statement */
>    
>    c->actionremaining -= 1;
>    if (unlikely (c->actionremaining <= 0)) {
>      c->last_error = "MAXACTION exceeded";
>      c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:524:3";
>      goto out;
>    }
>    if ((((l->depth) == (l->max_depth)))) {
>      {
>        (void) 
>        ({
>          strlcpy (l->frame, "<stack_truncated>", MAXSTRINGLEN);
>          "<stack_truncated>";
>        });
>        
>        c->actionremaining -= 2;
>        if (unlikely (c->actionremaining <= 0)) {
>          c->last_error = "MAXACTION exceeded";
>          c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:527:7";
>          goto out;
>        }
>        if ((! (l->print_frames))) {
>          (void) 
>          ({
>            strlcpy (l->__tmp242, ({ 
>              strlcpy (l->__tmp244, ({ 
>                strlcpy (l->__tmp245, l->frames, MAXSTRINGLEN);
>                strlcat (l->__tmp245, " ", MAXSTRINGLEN);
>                l->__tmp245;
>              }), MAXSTRINGLEN);
>              strlcat (l->__tmp244, l->frame, MAXSTRINGLEN);
>              l->__tmp244;
>            }), MAXSTRINGLEN);
>            strlcpy (l->frames, l->__tmp242, MAXSTRINGLEN);
>            l->__tmp242;
>          });
>          c->actionremaining -= 1;
>          if (unlikely (c->actionremaining <= 0)) {
>            c->last_error = "MAXACTION exceeded";
>            c->last_stmt = "identifier 'frames' at /usr/share/systemtap/tapset/x86_64/jstack.stp:528:9";
>            goto out;
>          }
>        }
>        else {
>          (void) 
>          ({
>            strlcpy (l->__tmp246, l->frame, MAXSTRINGLEN);
>            strlcpy (c->locals[c->nesting+1].function_log.msg, l->__tmp246, MAXSTRINGLEN);
>            function_log (c);
>            if (unlikely(c->last_error)) goto out;
>            (void) 0;
>          });
>          c->actionremaining -= 1;
>          if (unlikely (c->actionremaining <= 0)) {
>            c->last_error = "MAXACTION exceeded";
>            c->last_stmt = "identifier 'log' at /usr/share/systemtap/tapset/x86_64/jstack.stp:530:9";
>            goto out;
>          }
>        }
>        
>      }
>    }
>    
>    strlcpy (l->__retvalue, l->frames, MAXSTRINGLEN);
>    c->actionremaining -= 1;
>    if (unlikely (c->actionremaining <= 0)) {
>      c->last_error = "MAXACTION exceeded";
>      c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:533:3";
>      goto out;
>    }
>    goto out;
>    
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function_log (struct context* __restrict__ c) {
>  __label__ out;
>  struct function_log_locals *  __restrict__ l = & c->locals[c->nesting+1].function_log;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier 'log' at /usr/share/systemtap/tapset/logging.stp:22:10";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  #define return goto out
>  {
>     /* unprivileged */
>	_stp_printf ("%s\n", THIS->msg);
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function_pid (struct context* __restrict__ c) {
>  __label__ out;
>  struct function_pid_locals *  __restrict__ l = & c->locals[c->nesting+1].function_pid;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier 'pid' at /usr/share/systemtap/tapset/context.stp:44:10";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>     /* pure */ /* unprivileged */
>	THIS->__retvalue = current->tgid;
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function_print_jstack (struct context* __restrict__ c) {
>  __label__ out;
>  struct function_print_jstack_locals *  __restrict__ l = & c->locals[c->nesting+1].function_print_jstack;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier 'print_jstack' at /usr/share/systemtap/tapset/x86_64/jstack.stp:171:10";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->max_depth = 0;
>  l->__retvalue[0] = '\0';
>  #define return goto out
>  {
>    (void) 
>    ({
>      l->max_depth = ((int64_t)32LL);
>      ((int64_t)32LL);
>    });
>    
>    strlcpy (l->__retvalue, 
>    ({
>      l->__tmp2 = l->max_depth;
>      c->locals[c->nesting+1].function_print_jstack_n.max_depth = l->__tmp2;
>      function_print_jstack_n (c);
>      if (unlikely(c->last_error)) goto out;
>      c->locals[c->nesting+1].function_print_jstack_n.__retvalue;
>    }), MAXSTRINGLEN);
>    c->actionremaining -= 2;
>    if (unlikely (c->actionremaining <= 0)) {
>      c->last_error = "MAXACTION exceeded";
>      c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/jstack.stp:177:3";
>      goto out;
>    }
>    goto out;
>    
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function_print_jstack_n (struct context* __restrict__ c) {
>  __label__ out;
>  struct function_print_jstack_n_locals *  __restrict__ l = & c->locals[c->nesting+1].function_print_jstack_n;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier 'print_jstack_n' at /usr/share/systemtap/tapset/x86_64/jstack.stp:180:10";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->log_sig = 0;
>  l->log_native = 0;
>  l->print_frames = 0;
>  l->__retvalue[0] = '\0';
>  #define return goto out
>  {
>    (void) 
>    ({
>      l->log_sig = ((int64_t)0LL);
>      ((int64_t)0LL);
>    });
>    
>    (void) 
>    ({
>      l->log_native = ((int64_t)0LL);
>      ((int64_t)0LL);
>    });
>    
>    (void) 
>    ({
>      l->print_frames = ((int64_t)1LL);
>      ((int64_t)1LL);
>    });
>    
>    (void) 
>    ({
>      l->__tmp6 = l->max_depth;
>      l->__tmp7 = l->log_sig;
>      l->__tmp8 = l->log_native;
>      l->__tmp9 = l->print_frames;
>      c->locals[c->nesting+1].function_jstack_call.max_depth = l->__tmp6;
>      c->locals[c->nesting+1].function_jstack_call.log_sig = l->__tmp7;
>      c->locals[c->nesting+1].function_jstack_call.log_native = l->__tmp8;
>      c->locals[c->nesting+1].function_jstack_call.print_frames = l->__tmp9;
>      function_jstack_call (c);
>      if (unlikely(c->last_error)) goto out;
>      c->locals[c->nesting+1].function_jstack_call.__retvalue;
>    });
>    
>  }
>  #undef return
>  c->actionremaining -= 4;
>  if (unlikely (c->actionremaining <= 0)) {
>    c->last_error = "MAXACTION exceeded";
>    c->last_stmt = "operator '{' at /usr/share/systemtap/tapset/x86_64/jstack.stp:181:1";
>    goto out;
>  }
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function_register (struct context* __restrict__ c) {
>  __label__ out;
>  struct function_register_locals *  __restrict__ l = & c->locals[c->nesting+1].function_register;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier 'register' at /usr/share/systemtap/tapset/x86_64/registers.stp:103:10";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  l->__retvalue = 
>  ({
>    strlcpy (l->__tmp0, l->name, MAXSTRINGLEN);
>    strlcpy (c->locals[c->nesting+1].function__stp_register.name, l->__tmp0, MAXSTRINGLEN);
>    c->locals[c->nesting+1].function__stp_register.sign_extend = ((int64_t)1LL);
>    function__stp_register (c);
>    if (unlikely(c->last_error)) goto out;
>    c->locals[c->nesting+1].function__stp_register.__retvalue;
>  });
>  c->actionremaining -= 1;
>  if (unlikely (c->actionremaining <= 0)) {
>    c->last_error = "MAXACTION exceeded";
>    c->last_stmt = "keyword at /usr/share/systemtap/tapset/x86_64/registers.stp:104:2";
>    goto out;
>  }
>  goto out;
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function_registers_valid (struct context* __restrict__ c) {
>  __label__ out;
>  struct function_registers_valid_locals *  __restrict__ l = & c->locals[c->nesting+1].function_registers_valid;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier 'registers_valid' at /usr/share/systemtap/tapset/context.stp:235:10";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  {
>     /* pure */ /* unprivileged */
>	THIS->__retvalue = ((c->probe_flags & _STP_PROBE_STATE_USER_MODE)
>			    ? (CONTEXT->uregs != NULL)
>			    : (CONTEXT->kregs != NULL));
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function_str_replace (struct context* __restrict__ c) {
>  __label__ out;
>  struct function_str_replace_locals *  __restrict__ l = & c->locals[c->nesting+1].function_str_replace;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier 'str_replace' at /usr/share/systemtap/tapset/string.stp:116:10";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue[0] = '\0';
>  #define return goto out
>  {
>     /* pure */ /* unprivileged */
>	char *ptr = THIS->prnt_str;
>	char *ptr_base = THIS->prnt_str;
>	int strlen_srch_str = strlen(THIS->srch_str);
>
>	THIS->__retvalue[0] = '\0';
>	if(strlen_srch_str == 0) {
>		strlcat(THIS->__retvalue, ptr_base, MAXSTRINGLEN);
>		return;
>	}
>
>	while((ptr = strstr(ptr, THIS->srch_str)) != NULL) {
>
>		*ptr = '\0';
>		strlcat(THIS->__retvalue, ptr_base, MAXSTRINGLEN);
>		strlcat(THIS->__retvalue, THIS->rplc_str, MAXSTRINGLEN);
>		ptr = ptr + strlen_srch_str;
>		ptr_base = ptr;
>	}
>
>	strlcat(THIS->__retvalue, ptr_base, MAXSTRINGLEN);
>	return;
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function_user_char (struct context* __restrict__ c) {
>  __label__ out;
>  struct function_user_char_locals *  __restrict__ l = & c->locals[c->nesting+1].function_user_char;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier 'user_char' at /usr/share/systemtap/tapset/uconversions.stp:202:10";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  assert_is_myproc();
>  {
>     /* pure */ /* myproc-unprivileged */
>	STP_GET_USER(char);
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function_user_long (struct context* __restrict__ c) {
>  __label__ out;
>  struct function_user_long_locals *  __restrict__ l = & c->locals[c->nesting+1].function_user_long;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier 'user_long' at /usr/share/systemtap/tapset/uconversions.stp:304:10";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue = 0;
>  #define return goto out
>  assert_is_myproc();
>  {
>     /* pure */ /* myproc-unprivileged */
>#ifdef CONFIG_COMPAT
>	if (_stp_is_compat_task())
>		STP_GET_USER(compat_long_t);
>	else
>#endif
>		STP_GET_USER(long);
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function_user_string (struct context* __restrict__ c) {
>  __label__ out;
>  struct function_user_string_locals *  __restrict__ l = & c->locals[c->nesting+1].function_user_string;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier 'user_string' at /usr/share/systemtap/tapset/uconversions.stp:44:10";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue[0] = '\0';
>  #define return goto out
>  strlcpy (l->__retvalue, 
>  ({
>    l->__tmp0 = l->addr;
>    c->locals[c->nesting+1].function_user_string2.addr = l->__tmp0;
>    strlcpy (c->locals[c->nesting+1].function_user_string2.err_msg, "<unknown>", MAXSTRINGLEN);
>    function_user_string2 (c);
>    if (unlikely(c->last_error)) goto out;
>    c->locals[c->nesting+1].function_user_string2.__retvalue;
>  }), MAXSTRINGLEN);
>  c->actionremaining -= 1;
>  if (unlikely (c->actionremaining <= 0)) {
>    c->last_error = "MAXACTION exceeded";
>    c->last_stmt = "keyword at /usr/share/systemtap/tapset/uconversions.stp:44:43";
>    goto out;
>  }
>  goto out;
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function_user_string2 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function_user_string2_locals *  __restrict__ l = & c->locals[c->nesting+1].function_user_string2;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier 'user_string2' at /usr/share/systemtap/tapset/uconversions.stp:56:10";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue[0] = '\0';
>  #define return goto out
>  assert_is_myproc();
>  {
>     /* pure */ /* myproc-unprivileged */
>  if (_stp_strncpy_from_user (THIS->__retvalue,
>        (const char __user*) (uintptr_t) THIS->addr,
>        MAXSTRINGLEN) < 0)
>    strlcpy (THIS->__retvalue, THIS->err_msg, MAXSTRINGLEN);
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function_user_string_n (struct context* __restrict__ c) {
>  __label__ out;
>  struct function_user_string_n_locals *  __restrict__ l = & c->locals[c->nesting+1].function_user_string_n;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier 'user_string_n' at /usr/share/systemtap/tapset/uconversions.stp:117:10";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue[0] = '\0';
>  #define return goto out
>  strlcpy (l->__retvalue, 
>  ({
>    l->__tmp0 = l->addr;
>    l->__tmp1 = l->n;
>    c->locals[c->nesting+1].function_user_string_n2.addr = l->__tmp0;
>    c->locals[c->nesting+1].function_user_string_n2.n = l->__tmp1;
>    strlcpy (c->locals[c->nesting+1].function_user_string_n2.err_msg, "<unknown>", MAXSTRINGLEN);
>    function_user_string_n2 (c);
>    if (unlikely(c->last_error)) goto out;
>    c->locals[c->nesting+1].function_user_string_n2.__retvalue;
>  }), MAXSTRINGLEN);
>  c->actionremaining -= 1;
>  if (unlikely (c->actionremaining <= 0)) {
>    c->last_error = "MAXACTION exceeded";
>    c->last_stmt = "keyword at /usr/share/systemtap/tapset/uconversions.stp:118:2";
>    goto out;
>  }
>  goto out;
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function_user_string_n2 (struct context* __restrict__ c) {
>  __label__ out;
>  struct function_user_string_n2_locals *  __restrict__ l = & c->locals[c->nesting+1].function_user_string_n2;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier 'user_string_n2' at /usr/share/systemtap/tapset/uconversions.stp:133:10";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue[0] = '\0';
>  #define return goto out
>  assert_is_myproc();
>  {
>     /* pure */ /* myproc-unprivileged */
>	int64_t len = clamp_t(int64_t, THIS->n + 1, 1, MAXSTRINGLEN);
>	if (_stp_strncpy_from_user(THIS->__retvalue,
>				(char __user *) (uintptr_t) THIS->addr,
>				len) < 0)
>		strlcpy(THIS->__retvalue, THIS->err_msg, MAXSTRINGLEN);
>	else
>		THIS->__retvalue[len - 1] = '\0';
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void function_usymname (struct context* __restrict__ c) {
>  __label__ out;
>  struct function_usymname_locals *  __restrict__ l = & c->locals[c->nesting+1].function_usymname;
>  (void) l;
>  #define CONTEXT c
>  #define THIS l
>  c->last_stmt = "identifier 'usymname' at /usr/share/systemtap/tapset/ucontext-symbols.stp:24:10";
>  if (unlikely (c->nesting+1 >= MAXNESTING)) {
>    c->last_error = "MAXNESTING exceeded";
>    return;
>  } else {
>    c->nesting ++;
>  }
>  l->__retvalue[0] = '\0';
>  #define return goto out
>  assert_is_myproc();
>  {
>    
>/* pure */ /* myproc-unprivileged */ /* pragma:vma */ /* pragma:symbols */
>	 _stp_snprint_addr(THIS->__retvalue, MAXSTRINGLEN, THIS->addr,
>			   _STP_SYM_SYMBOL, current);
>
>  }
>  #undef return
>out:
>  if (0) goto out;
>  c->nesting --;
>  #undef CONTEXT
>  #undef THIS
>}
>
>
>static void probe_2500 (struct context * __restrict__ c) {
>  __label__ out;
>  static const struct stp_probe_lock locks[] = {
>    {
>      .lock = &global.s_Universe_methodKlassObj_lock,
>      .write_p = 0,
>      #ifdef STP_TIMING
>      .skipped = &global.s_Universe_methodKlassObj_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_Universe_collectedHeap_lock,
>      .write_p = 0,
>      #ifdef STP_TIMING
>      .skipped = &global.s_Universe_collectedHeap_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_HeapWordSize_lock,
>      .write_p = 0,
>      #ifdef STP_TIMING
>      .skipped = &global.s_HeapWordSize_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_CodeCache_heap_lock,
>      .write_p = 0,
>      #ifdef STP_TIMING
>      .skipped = &global.s_CodeCache_heap_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_sp_register_lock,
>      .write_p = 0,
>      #ifdef STP_TIMING
>      .skipped = &global.s_sp_register_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_fp_register_lock,
>      .write_p = 0,
>      #ifdef STP_TIMING
>      .skipped = &global.s_fp_register_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_pc_register_lock,
>      .write_p = 0,
>      #ifdef STP_TIMING
>      .skipped = &global.s_pc_register_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_ptr_size_lock,
>      .write_p = 0,
>      #ifdef STP_TIMING
>      .skipped = &global.s_ptr_size_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_ptr_mask_lock,
>      .write_p = 0,
>      #ifdef STP_TIMING
>      .skipped = &global.s_ptr_mask_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_constantPoolOopDesc_size_lock,
>      .write_p = 0,
>      #ifdef STP_TIMING
>      .skipped = &global.s_constantPoolOopDesc_size_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_HeapBlock_Header_size_lock,
>      .write_p = 0,
>      #ifdef STP_TIMING
>      .skipped = &global.s_HeapBlock_Header_size_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_oopDesc_size_lock,
>      .write_p = 0,
>      #ifdef STP_TIMING
>      .skipped = &global.s_oopDesc_size_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_vm_inited_lock,
>      .write_p = 0,
>      #ifdef STP_TIMING
>      .skipped = &global.s_vm_inited_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s__reg_offsets_lock,
>      .write_p = 1,
>      #ifdef STP_TIMING
>      .skipped = &global.s__reg_offsets_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s__r32_offsets_lock,
>      .write_p = 1,
>      #ifdef STP_TIMING
>      .skipped = &global.s__r32_offsets_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s__stp_regs_registered_lock,
>      .write_p = 1,
>      #ifdef STP_TIMING
>      .skipped = &global.s__stp_regs_registered_lock_skip_count,
>      #endif
>    },
>  };
>  struct probe_2500_locals * __restrict__ l = & c->probe_locals.probe_2500;
>  (void) l;
>  #if ! STP_PRIVILEGE_CONTAINS (STP_PRIVILEGE, STP_PR_STAPDEV) && \
>      ! STP_PRIVILEGE_CONTAINS (STP_PRIVILEGE, STP_PR_STAPSYS)
>    if (! is_myproc ()) {
>      snprintf(c->error_buffer, sizeof(c->error_buffer),
>               "Internal Error: Process %d does not belong to user %d in probe %s in --unprivileged mode",
>               current->tgid, _stp_uid, c->probe_point);
>      c->last_error = c->error_buffer;
>      return;
>    }
>  #endif
>  if (!stp_lock_probe(locks, ARRAY_SIZE(locks)))
>    return;
>  (void) 
>  ({
>    function_print_jstack (c);
>    if (unlikely(c->last_error)) goto out;
>    c->locals[c->nesting+1].function_print_jstack.__retvalue;
>  });
>  c->actionremaining -= 1;
>  if (unlikely (c->actionremaining <= 0)) {
>    c->last_error = "MAXACTION exceeded";
>    c->last_stmt = "identifier 'print_jstack' at <input>:1:39";
>    goto out;
>  }
>out:
>  stp_unlock_probe(locks, ARRAY_SIZE(locks));
>  _stp_print_flush();
>}
>
>
>static void probe_2504 (struct context * __restrict__ c) {
>  __label__ out;
>  static const struct stp_probe_lock locks[] = {
>    {
>      .lock = &global.s_Universe_methodKlassObj_lock,
>      .write_p = 1,
>      #ifdef STP_TIMING
>      .skipped = &global.s_Universe_methodKlassObj_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_Universe_collectedHeap_lock,
>      .write_p = 1,
>      #ifdef STP_TIMING
>      .skipped = &global.s_Universe_collectedHeap_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_HeapWordSize_lock,
>      .write_p = 1,
>      #ifdef STP_TIMING
>      .skipped = &global.s_HeapWordSize_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_CodeCache_heap_lock,
>      .write_p = 1,
>      #ifdef STP_TIMING
>      .skipped = &global.s_CodeCache_heap_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_sp_register_lock,
>      .write_p = 1,
>      #ifdef STP_TIMING
>      .skipped = &global.s_sp_register_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_fp_register_lock,
>      .write_p = 1,
>      #ifdef STP_TIMING
>      .skipped = &global.s_fp_register_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_pc_register_lock,
>      .write_p = 1,
>      #ifdef STP_TIMING
>      .skipped = &global.s_pc_register_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_ptr_size_lock,
>      .write_p = 1,
>      #ifdef STP_TIMING
>      .skipped = &global.s_ptr_size_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_ptr_mask_lock,
>      .write_p = 1,
>      #ifdef STP_TIMING
>      .skipped = &global.s_ptr_mask_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_constantPoolOopDesc_size_lock,
>      .write_p = 1,
>      #ifdef STP_TIMING
>      .skipped = &global.s_constantPoolOopDesc_size_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_HeapBlock_Header_size_lock,
>      .write_p = 1,
>      #ifdef STP_TIMING
>      .skipped = &global.s_HeapBlock_Header_size_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_oopDesc_size_lock,
>      .write_p = 1,
>      #ifdef STP_TIMING
>      .skipped = &global.s_oopDesc_size_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_vm_inited_lock,
>      .write_p = 1,
>      #ifdef STP_TIMING
>      .skipped = &global.s_vm_inited_lock_skip_count,
>      #endif
>    },
>  };
>  struct probe_2504_locals * __restrict__ l = & c->probe_locals.probe_2504;
>  (void) l;
>  #if ! STP_PRIVILEGE_CONTAINS (STP_PRIVILEGE, STP_PR_STAPDEV) && \
>      ! STP_PRIVILEGE_CONTAINS (STP_PRIVILEGE, STP_PR_STAPSYS)
>    if (! is_myproc ()) {
>      snprintf(c->error_buffer, sizeof(c->error_buffer),
>               "Internal Error: Process %d does not belong to user %d in probe %s in --unprivileged mode",
>               current->tgid, _stp_uid, c->probe_point);
>      c->last_error = c->error_buffer;
>      return;
>    }
>  #endif
>  if (!stp_lock_probe(locks, ARRAY_SIZE(locks)))
>    return;
>  {
>    (void) 
>    ({
>      l->__tmp0 = 
>      ({
>        function_pid (c);
>        if (unlikely(c->last_error)) goto out;
>        c->locals[c->nesting+1].function_pid.__retvalue;
>      });
>      l->__tmp1 = 
>      ({
>        function__dwarf_tvar_get__methodKlassObj_0 (c);
>        if (unlikely(c->last_error)) goto out;
>        c->locals[c->nesting+1].function__dwarf_tvar_get__methodKlassObj_0.__retvalue;
>      });
>      c->last_stmt = "identifier 'Universe_methodKlassObj' at /usr/share/systemtap/tapset/x86_64/jstack.stp:70:3";
>      l->__tmp2 = l->__tmp1;
>      { int rc = _stp_map_set_ii (global.s_Universe_methodKlassObj, l->__tmp0, l->__tmp2); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      l->__tmp1;
>    });
>    
>    (void) 
>    ({
>      l->__tmp4 = 
>      ({
>        function_pid (c);
>        if (unlikely(c->last_error)) goto out;
>        c->locals[c->nesting+1].function_pid.__retvalue;
>      });
>      l->__tmp5 = 
>      ({
>        function__dwarf_tvar_get__collectedHeap_1 (c);
>        if (unlikely(c->last_error)) goto out;
>        c->locals[c->nesting+1].function__dwarf_tvar_get__collectedHeap_1.__retvalue;
>      });
>      c->last_stmt = "identifier 'Universe_collectedHeap' at /usr/share/systemtap/tapset/x86_64/jstack.stp:87:3";
>      l->__tmp6 = l->__tmp5;
>      { int rc = _stp_map_set_ii (global.s_Universe_collectedHeap, l->__tmp4, l->__tmp6); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      l->__tmp5;
>    });
>    
>    (void) 
>    ({
>      l->__tmp8 = 
>      ({
>        function_pid (c);
>        if (unlikely(c->last_error)) goto out;
>        c->locals[c->nesting+1].function_pid.__retvalue;
>      });
>      l->__tmp9 = 
>      ({
>        function__dwarf_tvar_get_HeapWordSize_2 (c);
>        if (unlikely(c->last_error)) goto out;
>        c->locals[c->nesting+1].function__dwarf_tvar_get_HeapWordSize_2.__retvalue;
>      });
>      c->last_stmt = "identifier 'HeapWordSize' at /usr/share/systemtap/tapset/x86_64/jstack.stp:90:3";
>      l->__tmp10 = l->__tmp9;
>      { int rc = _stp_map_set_ii (global.s_HeapWordSize, l->__tmp8, l->__tmp10); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      l->__tmp9;
>    });
>    
>    (void) 
>    ({
>      l->__tmp12 = 
>      ({
>        function_pid (c);
>        if (unlikely(c->last_error)) goto out;
>        c->locals[c->nesting+1].function_pid.__retvalue;
>      });
>      l->__tmp13 = 
>      ({
>        function__dwarf_tvar_get__heap_3 (c);
>        if (unlikely(c->last_error)) goto out;
>        c->locals[c->nesting+1].function__dwarf_tvar_get__heap_3.__retvalue;
>      });
>      c->last_stmt = "identifier 'CodeCache_heap' at /usr/share/systemtap/tapset/x86_64/jstack.stp:108:3";
>      l->__tmp14 = l->__tmp13;
>      { int rc = _stp_map_set_ii (global.s_CodeCache_heap, l->__tmp12, l->__tmp14); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      l->__tmp13;
>    });
>    
>    (void) 
>    ({
>      strlcpy (global.s_sp_register, "rsp", MAXSTRINGLEN);
>      "rsp";
>    });
>    
>    (void) 
>    ({
>      strlcpy (global.s_fp_register, "rbp", MAXSTRINGLEN);
>      "rbp";
>    });
>    
>    (void) 
>    ({
>      strlcpy (global.s_pc_register, "rip", MAXSTRINGLEN);
>      "rip";
>    });
>    
>    (void) 
>    ({
>      global.s_ptr_size = ((int64_t)8LL);
>      ((int64_t)8LL);
>    });
>    
>    (void) 
>    ({
>      global.s_ptr_mask = ((int64_t)-1LL);
>      ((int64_t)-1LL);
>    });
>    
>    (void) 
>    ({
>      l->__tmp26 = 
>      ({
>        c->locals[c->nesting+1].function__dwarf_cast_get_cast_0.pointer = ((int64_t)0LL);
>        function__dwarf_cast_get_cast_0 (c);
>        if (unlikely(c->last_error)) goto out;
>        c->locals[c->nesting+1].function__dwarf_cast_get_cast_0.__retvalue;
>      });
>      global.s_constantPoolOopDesc_size = l->__tmp26;
>      l->__tmp26;
>    });
>    c->actionremaining -= 10;
>    if (unlikely (c->actionremaining <= 0)) {
>      c->last_error = "MAXACTION exceeded";
>      c->last_stmt = "identifier 'constantPoolOopDesc_size' at /usr/share/systemtap/tapset/x86_64/jstack.stp:130:3";
>      goto out;
>    }
>    
>    (void) 
>    ({
>      l->__tmp29 = ((((int64_t)2LL)) * (global.s_ptr_size));
>      global.s_HeapBlock_Header_size = l->__tmp29;
>      l->__tmp29;
>    });
>    
>    (void) 
>    ({
>      l->__tmp31 = ((((int64_t)2LL)) * (global.s_ptr_size));
>      global.s_oopDesc_size = l->__tmp31;
>      l->__tmp31;
>    });
>    
>    (void) 
>    ({
>      l->__tmp33 = 
>      ({
>        function_pid (c);
>        if (unlikely(c->last_error)) goto out;
>        c->locals[c->nesting+1].function_pid.__retvalue;
>      });
>      c->last_stmt = "identifier 'vm_inited' at /usr/share/systemtap/tapset/x86_64/jstack.stp:136:3";
>      l->__tmp35 = ((int64_t)1LL);
>      { int rc = _stp_map_set_ii (global.s_vm_inited, l->__tmp33, l->__tmp35); if (unlikely(rc)) { c->last_error = "Array overflow, check MAXMAPENTRIES"; goto out; }};
>      ((int64_t)1LL);
>    });
>    
>  }
>  c->actionremaining -= 3;
>  if (unlikely (c->actionremaining <= 0)) {
>    c->last_error = "MAXACTION exceeded";
>    c->last_stmt = "operator '{' at /usr/share/systemtap/tapset/x86_64/hotspot.stp:139:1";
>    goto out;
>  }
>out:
>  stp_unlock_probe(locks, ARRAY_SIZE(locks));
>  _stp_print_flush();
>}
>
>
>static void probe_2508 (struct context * __restrict__ c) {
>  __label__ out;
>  static const struct stp_probe_lock locks[] = {
>    {
>      .lock = &global.s_Universe_methodKlassObj_lock,
>      .write_p = 1,
>      #ifdef STP_TIMING
>      .skipped = &global.s_Universe_methodKlassObj_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_Universe_collectedHeap_lock,
>      .write_p = 1,
>      #ifdef STP_TIMING
>      .skipped = &global.s_Universe_collectedHeap_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_HeapWordSize_lock,
>      .write_p = 1,
>      #ifdef STP_TIMING
>      .skipped = &global.s_HeapWordSize_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_CodeCache_heap_lock,
>      .write_p = 1,
>      #ifdef STP_TIMING
>      .skipped = &global.s_CodeCache_heap_lock_skip_count,
>      #endif
>    },
>    {
>      .lock = &global.s_vm_inited_lock,
>      .write_p = 1,
>      #ifdef STP_TIMING
>      .skipped = &global.s_vm_inited_lock_skip_count,
>      #endif
>    },
>  };
>  struct probe_2508_locals * __restrict__ l = & c->probe_locals.probe_2508;
>  (void) l;
>  #if ! STP_PRIVILEGE_CONTAINS (STP_PRIVILEGE, STP_PR_STAPDEV) && \
>      ! STP_PRIVILEGE_CONTAINS (STP_PRIVILEGE, STP_PR_STAPSYS)
>    if (! is_myproc ()) {
>      snprintf(c->error_buffer, sizeof(c->error_buffer),
>               "Internal Error: Process %d does not belong to user %d in probe %s in --unprivileged mode",
>               current->tgid, _stp_uid, c->probe_point);
>      c->last_error = c->error_buffer;
>      return;
>    }
>  #endif
>  if (!stp_lock_probe(locks, ARRAY_SIZE(locks)))
>    return;
>  {
>    l->__tmp0 = 
>    ({
>      function_pid (c);
>      if (unlikely(c->last_error)) goto out;
>      c->locals[c->nesting+1].function_pid.__retvalue;
>    });
>    _stp_map_del_ii (global.s_Universe_methodKlassObj, l->__tmp0);
>    
>    l->__tmp1 = 
>    ({
>      function_pid (c);
>      if (unlikely(c->last_error)) goto out;
>      c->locals[c->nesting+1].function_pid.__retvalue;
>    });
>    _stp_map_del_ii (global.s_Universe_collectedHeap, l->__tmp1);
>    
>    l->__tmp2 = 
>    ({
>      function_pid (c);
>      if (unlikely(c->last_error)) goto out;
>      c->locals[c->nesting+1].function_pid.__retvalue;
>    });
>    _stp_map_del_ii (global.s_HeapWordSize, l->__tmp2);
>    
>    l->__tmp3 = 
>    ({
>      function_pid (c);
>      if (unlikely(c->last_error)) goto out;
>      c->locals[c->nesting+1].function_pid.__retvalue;
>    });
>    _stp_map_del_ii (global.s_CodeCache_heap, l->__tmp3);
>    
>    l->__tmp4 = 
>    ({
>      function_pid (c);
>      if (unlikely(c->last_error)) goto out;
>      c->locals[c->nesting+1].function_pid.__retvalue;
>    });
>    _stp_map_del_ii (global.s_vm_inited, l->__tmp4);
>    
>  }
>  c->actionremaining -= 5;
>  if (unlikely (c->actionremaining <= 0)) {
>    c->last_error = "MAXACTION exceeded";
>    c->last_stmt = "operator '{' at /usr/share/systemtap/tapset/x86_64/hotspot.stp:150:1";
>    goto out;
>  }
>out:
>  stp_unlock_probe(locks, ARRAY_SIZE(locks));
>  _stp_print_flush();
>}
>
>static struct stap_probe {
>  void (* const ph) (struct context*);
>  #ifdef STP_ALIBI
>  atomic_t alibi;
>  #define STAP_PROBE_INIT_ALIBI() .alibi=ATOMIC_INIT(0),
>  #else
>  #define STAP_PROBE_INIT_ALIBI()
>  #endif
>  #ifdef STP_TIMING
>  Stat timing;
>  #endif
>  #if defined(STP_TIMING) || defined(STP_ALIBI)
>  const char location[54];
>  const char derivation[273];
>  #define STAP_PROBE_INIT_TIMING(L, D) .location=(L), .derivation=(D),
>  #else
>  #define STAP_PROBE_INIT_TIMING(L, D)
>  #endif
>  const char pp[113];
>  #ifdef STP_NEED_PROBE_NAME
>  const char pn[32];
>  #define STAP_PROBE_INIT_NAME(PN) .pn=(PN),
>  #else
>  #define STAP_PROBE_INIT_NAME(PN)
>  #endif
>  #define STAP_PROBE_INIT(PH, PP, PN, L, D) { .ph=(PH), .pp=(PP), STAP_PROBE_INIT_NAME(PN) STAP_PROBE_INIT_ALIBI() STAP_PROBE_INIT_TIMING(L, D) }
>} stap_probes[] = {
>  STAP_PROBE_INIT(&probe_2500, "process(\"/usr/lib/jvm/java-1.6.0-openjdk-1.6.0.0.x86_64/jre/lib/amd64/server/libjvm.so\").statement(0x4d2778)", "hotspot.jni.GetStringUTFChars", "<input>:1:7", " from: process(\"/usr/lib/jvm/java-1.6.0-openjdk-1.6.0.0.x86_64/jre/lib/amd64/server/libjvm.so\").statement(0x4d2778) from: process(\"/usr/lib/jvm/java-1.6.0-openjdk-1.6.0.0.x86_64/jre/lib/amd64/server/libjvm.so\").statement(0x4d2778) from: hotspot.jni.GetStringUTFChars"),
>  STAP_PROBE_INIT(&probe_2504, "process(\"/usr/lib/jvm/java-1.6.0-openjdk-1.6.0.0.x86_64/jre/lib/amd64/server/libjvm.so\").statement(0x769889)", "hotspot.vm_init_end", "/usr/share/systemtap/tapset/x86_64/jstack.stp:67:7", " from: process(\"/usr/lib/jvm/java-1.6.0-openjdk-1.6.0.0.x86_64/jre/lib/amd64/server/libjvm.so\").statement(0x769889) from: process(\"/usr/lib/jvm/java-1.6.0-openjdk-1.6.0.0.x86_64/jre/lib/amd64/server/libjvm.so\").statement(0x769889) from: hotspot.vm_init_end"),
>  STAP_PROBE_INIT(&probe_2508, "process(\"/usr/lib/jvm/java-1.6.0-openjdk-1.6.0.0.x86_64/jre/lib/amd64/server/libjvm.so\").statement(0x4b6e84)", "hotspot.vm_shutdown", "/usr/share/systemtap/tapset/x86_64/jstack.stp:139:7", " from: process(\"/usr/lib/jvm/java-1.6.0-openjdk-1.6.0.0.x86_64/jre/lib/amd64/server/libjvm.so\").statement(0x4b6e84) from: process(\"/usr/lib/jvm/java-1.6.0-openjdk-1.6.0.0.x86_64/jre/lib/amd64/server/libjvm.so\").statement(0x4b6e84) from: hotspot.vm_shutdown"),
>};
>
>/* ---- utrace uprobes ---- */
>#if defined(CONFIG_UPROBES) || defined(CONFIG_UPROBES_MODULE)
>#include <linux/uprobes.h>
>#else
>#include "uprobes/uprobes.h"
>#endif
>#ifndef UPROBES_API_VERSION
>#define UPROBES_API_VERSION 1
>#endif
>#ifndef MAXUPROBES
>#define MAXUPROBES 701
>#endif
>#include "uprobes-common.h"
>static struct stap_uprobe stap_uprobes [MAXUPROBES];
>DEFINE_MUTEX(stap_uprobes_lock);
>static struct stap_uprobe_tf stap_uprobe_finders[] = {
>  { .finder={ .mmap_callback=&stap_uprobe_mmap_found,  .munmap_callback=&stap_uprobe_munmap_found,  .callback=&stap_uprobe_process_munmap, }, .pathname="/usr/lib/jvm/java-1.6.0-openjdk-1.6.0.0.x86_64/jre/lib/amd64/server/libjvm.so",  },
>};
>static const struct stap_uprobe_spec stap_uprobe_specs [] = {
>  { .address=(unsigned long)0x4d2778ULL, .probe=(&stap_probes[0]), },
>  { .address=(unsigned long)0x769889ULL, .probe=(&stap_probes[1]), },
>  { .address=(unsigned long)0x4b6e84ULL, .probe=(&stap_probes[2]), },
>};
>static void enter_uprobe_probe (struct uprobe *inst, struct pt_regs *regs) {
>  struct stap_uprobe *sup = container_of(inst, struct stap_uprobe, up);
>  const struct stap_uprobe_spec *sups = &stap_uprobe_specs [sup->spec_index];
>  #ifdef STP_ALIBI
>  atomic_inc(&(sups->probe->alibi));
>  #else
>  struct context* __restrict__ c;
>  #if !INTERRUPTIBLE
>  unsigned long flags;
>  #endif
>  #if defined(STP_TIMING) || defined(STP_OVERLOAD)
>  cycles_t cycles_atstart = get_cycles ();
>  #endif
>  #ifdef STP_TIMING
>  Stat stat = sups->probe->timing;
>  #endif
>  #if INTERRUPTIBLE
>  preempt_disable ();
>  #else
>  local_irq_save (flags);
>  #endif
>  if (unlikely ((((unsigned long) (& c)) & (THREAD_SIZE-1))
>    < (MINSTACKSPACE + sizeof (struct thread_info)))) {
>    atomic_inc (& skipped_count);
>    #ifdef STP_TIMING
>    atomic_inc (& skipped_count_lowstack);
>    #endif
>    goto probe_epilogue;
>  }
>  if (atomic_read (&session_state) != STAP_SESSION_RUNNING)
>    goto probe_epilogue;
>  c = contexts[smp_processor_id()];
>  if (atomic_inc_return (& c->busy) != 1) {
>    #if !INTERRUPTIBLE
>    atomic_inc (& skipped_count);
>    #endif
>    #ifdef STP_TIMING
>    atomic_inc (& skipped_count_reentrant);
>    #ifdef DEBUG_REENTRANCY
>    _stp_warn ("Skipped %s due to %s residency on cpu %u\n", sups->probe->pp, c->probe_point ?: "?", smp_processor_id());
>    #endif
>    #endif
>    atomic_dec (& c->busy);
>    goto probe_epilogue;
>  }
>  
>  c->last_stmt = 0;
>  c->last_error = 0;
>  c->nesting = -1;
>  c->uregs = 0;
>  c->kregs = 0;
>  #if defined __ia64__
>  c->unwaddr = 0;
>  #endif
>  c->probe_point = sups->probe->pp;
>  #ifdef STP_NEED_PROBE_NAME
>  c->probe_name = sups->probe->pn;
>  #endif
>  c->probe_type = _STP_PROBE_HANDLER_UPROBE;
>  memset(&c->ips, 0, sizeof(c->ips));
>  c->probe_flags = 0;
>  #ifdef STAP_NEED_REGPARM
>  c->regparm = 0;
>  #endif
>  #if INTERRUPTIBLE
>  c->actionremaining = MAXACTION_INTERRUPTIBLE;
>  #else
>  c->actionremaining = MAXACTION;
>  #endif
>  if (sup->spec_index < 0 || sup->spec_index >= 3) {
>    _stp_error ("bad spec_index %d (max 3): %s", sup->spec_index, c->probe_point);
>    atomic_dec (&c->busy);
>    goto probe_epilogue;
>  }
>  c->uregs = regs;
>  c->probe_flags |= _STP_PROBE_STATE_USER_MODE;
>  {
>    unsigned long uprobes_ip = REG_IP(c->uregs);
>    SET_REG_IP(regs, inst->vaddr);
>    (*sups->probe->ph) (c);
>    SET_REG_IP(regs, uprobes_ip);
>  }
>  #if defined(STP_TIMING) || defined(STP_OVERLOAD)
>  {
>    cycles_t cycles_atend = get_cycles ();
>    int32_t cycles_elapsed = ((int32_t)cycles_atend > (int32_t)cycles_atstart)
>      ? ((int32_t)cycles_atend - (int32_t)cycles_atstart)
>      : (~(int32_t)0) - (int32_t)cycles_atstart + (int32_t)cycles_atend + 1;
>    #ifdef STP_TIMING
>    if (likely (stat)) _stp_stat_add(stat, cycles_elapsed);
>    #endif
>    #ifdef STP_OVERLOAD
>    {
>      cycles_t interval = (cycles_atend > c->cycles_base)
>        ? (cycles_atend - c->cycles_base)
>        : (STP_OVERLOAD_INTERVAL + 1);
>      c->cycles_sum += cycles_elapsed;
>      if (interval > STP_OVERLOAD_INTERVAL) {
>        if (c->cycles_sum > STP_OVERLOAD_THRESHOLD) {
>          _stp_error ("probe overhead exceeded threshold");
>          atomic_set (&session_state, STAP_SESSION_ERROR);
>          atomic_inc (&error_count);
>        }
>        c->cycles_base = cycles_atend;
>        c->cycles_sum = 0;
>      }
>    }
>    #endif
>  }
>  #endif
>  c->probe_point = 0;
>  #ifdef STP_NEED_PROBE_NAME
>  c->probe_name = 0;
>  #endif
>  c->probe_type = 0;
>  if (unlikely (c->last_error && c->last_error[0])) {
>    if (c->last_stmt != NULL)
>      _stp_softerror ("%s near %s", c->last_error, c->last_stmt);
>    else
>      _stp_softerror ("%s", c->last_error);
>    atomic_inc (& error_count);
>    if (atomic_read (& error_count) > MAXERRORS) {
>      atomic_set (& session_state, STAP_SESSION_ERROR);
>      _stp_exit ();
>    }
>  }
>  atomic_dec (&c->busy);
>probe_epilogue:
>  if (unlikely (atomic_read (& skipped_count) > MAXSKIPPED)) {
>    if (unlikely (pseudo_atomic_cmpxchg(& session_state, STAP_SESSION_RUNNING, STAP_SESSION_ERROR) == STAP_SESSION_RUNNING))
>    _stp_error ("Skipped too many probes, check MAXSKIPPED or try again with stap -t for more details.");
>  }
>  #if INTERRUPTIBLE
>  preempt_enable_no_resched ();
>  #else
>  local_irq_restore (flags);
>  #endif
>  #endif // STP_ALIBI
>}
>static void enter_uretprobe_probe (struct uretprobe_instance *inst, struct pt_regs *regs) {
>  struct stap_uprobe *sup = container_of(inst->rp, struct stap_uprobe, urp);
>  const struct stap_uprobe_spec *sups = &stap_uprobe_specs [sup->spec_index];
>  #ifdef STP_ALIBI
>  atomic_inc(&(sups->probe->alibi));
>  #else
>  struct context* __restrict__ c;
>  #if !INTERRUPTIBLE
>  unsigned long flags;
>  #endif
>  #if defined(STP_TIMING) || defined(STP_OVERLOAD)
>  cycles_t cycles_atstart = get_cycles ();
>  #endif
>  #ifdef STP_TIMING
>  Stat stat = sups->probe->timing;
>  #endif
>  #if INTERRUPTIBLE
>  preempt_disable ();
>  #else
>  local_irq_save (flags);
>  #endif
>  if (unlikely ((((unsigned long) (& c)) & (THREAD_SIZE-1))
>    < (MINSTACKSPACE + sizeof (struct thread_info)))) {
>    atomic_inc (& skipped_count);
>    #ifdef STP_TIMING
>    atomic_inc (& skipped_count_lowstack);
>    #endif
>    goto probe_epilogue;
>  }
>  if (atomic_read (&session_state) != STAP_SESSION_RUNNING)
>    goto probe_epilogue;
>  c = contexts[smp_processor_id()];
>  if (atomic_inc_return (& c->busy) != 1) {
>    #if !INTERRUPTIBLE
>    atomic_inc (& skipped_count);
>    #endif
>    #ifdef STP_TIMING
>    atomic_inc (& skipped_count_reentrant);
>    #ifdef DEBUG_REENTRANCY
>    _stp_warn ("Skipped %s due to %s residency on cpu %u\n", sups->probe->pp, c->probe_point ?: "?", smp_processor_id());
>    #endif
>    #endif
>    atomic_dec (& c->busy);
>    goto probe_epilogue;
>  }
>  
>  c->last_stmt = 0;
>  c->last_error = 0;
>  c->nesting = -1;
>  c->uregs = 0;
>  c->kregs = 0;
>  #if defined __ia64__
>  c->unwaddr = 0;
>  #endif
>  c->probe_point = sups->probe->pp;
>  #ifdef STP_NEED_PROBE_NAME
>  c->probe_name = sups->probe->pn;
>  #endif
>  c->probe_type = _STP_PROBE_HANDLER_URETPROBE;
>  memset(&c->ips, 0, sizeof(c->ips));
>  c->probe_flags = 0;
>  #ifdef STAP_NEED_REGPARM
>  c->regparm = 0;
>  #endif
>  #if INTERRUPTIBLE
>  c->actionremaining = MAXACTION_INTERRUPTIBLE;
>  #else
>  c->actionremaining = MAXACTION;
>  #endif
>  c->ips.ri = inst;
>  if (sup->spec_index < 0 || sup->spec_index >= 3) {
>    _stp_error ("bad spec_index %d (max 3): %s", sup->spec_index, c->probe_point);
>    atomic_dec (&c->busy);
>    goto probe_epilogue;
>  }
>  c->uregs = regs;
>  c->probe_flags |= _STP_PROBE_STATE_USER_MODE;
>  {
>    unsigned long uprobes_ip = REG_IP(c->uregs);
>    SET_REG_IP(regs, inst->ret_addr);
>    (*sups->probe->ph) (c);
>    SET_REG_IP(regs, uprobes_ip);
>  }
>  #if defined(STP_TIMING) || defined(STP_OVERLOAD)
>  {
>    cycles_t cycles_atend = get_cycles ();
>    int32_t cycles_elapsed = ((int32_t)cycles_atend > (int32_t)cycles_atstart)
>      ? ((int32_t)cycles_atend - (int32_t)cycles_atstart)
>      : (~(int32_t)0) - (int32_t)cycles_atstart + (int32_t)cycles_atend + 1;
>    #ifdef STP_TIMING
>    if (likely (stat)) _stp_stat_add(stat, cycles_elapsed);
>    #endif
>    #ifdef STP_OVERLOAD
>    {
>      cycles_t interval = (cycles_atend > c->cycles_base)
>        ? (cycles_atend - c->cycles_base)
>        : (STP_OVERLOAD_INTERVAL + 1);
>      c->cycles_sum += cycles_elapsed;
>      if (interval > STP_OVERLOAD_INTERVAL) {
>        if (c->cycles_sum > STP_OVERLOAD_THRESHOLD) {
>          _stp_error ("probe overhead exceeded threshold");
>          atomic_set (&session_state, STAP_SESSION_ERROR);
>          atomic_inc (&error_count);
>        }
>        c->cycles_base = cycles_atend;
>        c->cycles_sum = 0;
>      }
>    }
>    #endif
>  }
>  #endif
>  c->probe_point = 0;
>  #ifdef STP_NEED_PROBE_NAME
>  c->probe_name = 0;
>  #endif
>  c->probe_type = 0;
>  if (unlikely (c->last_error && c->last_error[0])) {
>    if (c->last_stmt != NULL)
>      _stp_softerror ("%s near %s", c->last_error, c->last_stmt);
>    else
>      _stp_softerror ("%s", c->last_error);
>    atomic_inc (& error_count);
>    if (atomic_read (& error_count) > MAXERRORS) {
>      atomic_set (& session_state, STAP_SESSION_ERROR);
>      _stp_exit ();
>    }
>  }
>  atomic_dec (&c->busy);
>probe_epilogue:
>  if (unlikely (atomic_read (& skipped_count) > MAXSKIPPED)) {
>    if (unlikely (pseudo_atomic_cmpxchg(& session_state, STAP_SESSION_RUNNING, STAP_SESSION_ERROR) == STAP_SESSION_RUNNING))
>    _stp_error ("Skipped too many probes, check MAXSKIPPED or try again with stap -t for more details.");
>  }
>  #if INTERRUPTIBLE
>  preempt_enable_no_resched ();
>  #else
>  local_irq_restore (flags);
>  #endif
>  #endif // STP_ALIBI
>}
>
>#include "uprobes-common.c"
>
>
>static int systemtap_module_init (void) {
>  int rc = 0;
>  int cpu;
>  int i=0, j=0;
>  const char *probe_point = "";
>  {
>    const char* release = UTS_RELEASE;
>    #ifdef STAPCONF_GENERATED_COMPILE
>    const char* version = UTS_VERSION;
>    #endif
>    if (strcmp (release, "2.6.32-272.el6.x86_64")) {
>      _stp_error ("module release mismatch (%s vs %s)", release, "2.6.32-272.el6.x86_64");
>      rc = -EINVAL;
>    }
>    #ifdef STAPCONF_GENERATED_COMPILE
>    if (strcmp (utsname()->version, version)) {
>      _stp_error ("module version mismatch (%s vs %s), release %s", version, utsname()->version, release);
>      rc = -EINVAL;
>    }
>    #endif
>    if (_stp_module_check()) rc = -EINVAL;
>    if (_stp_privilege_credentials == 0) {
>      if (STP_PRIVILEGE_CONTAINS(STP_PRIVILEGE, STP_PR_STAPDEV) ||
>          STP_PRIVILEGE_CONTAINS(STP_PRIVILEGE, STP_PR_STAPUSR)) {
>        _stp_privilege_credentials = STP_PRIVILEGE;
>        #ifdef DEBUG_PRIVILEGE
>          _dbug("User's privilege credentials default to %s\n",
>                privilege_to_text(_stp_privilege_credentials));
>        #endif
>      }
>      else {
>        _stp_error ("Unable to verify that you have the required privilege credentials to run this module (%s required). You must use staprun version 1.7 or higher.",
>                    privilege_to_text(STP_PRIVILEGE));
>        rc = -EINVAL;
>      }
>    }
>    else {
>      #ifdef DEBUG_PRIVILEGE
>        _dbug("User's privilege credentials provided as %s\n",
>              privilege_to_text(_stp_privilege_credentials));
>      #endif
>      if (! STP_PRIVILEGE_CONTAINS(_stp_privilege_credentials, STP_PRIVILEGE)) {
>        _stp_error ("Your privilege credentials (%s) are insufficient to run this module (%s required).",
>                    privilege_to_text(_stp_privilege_credentials), privilege_to_text(STP_PRIVILEGE));
>        rc = -EINVAL;
>      }
>    }
>  }
>  if (rc) goto out;
>  #ifdef STAP_NEED_GETTIMEOFDAY
>  rc = _stp_init_time();
>  if (rc) {
>    _stp_error ("couldn't initialize gettimeofday");
>    goto out;
>  }
>  #endif
>  (void) probe_point;
>  (void) i;
>  (void) j;
>  atomic_set (&session_state, STAP_SESSION_STARTING);
>  for_each_possible_cpu(cpu) {
>    contexts[cpu] = _stp_kzalloc_gfp(sizeof(struct context), STP_ALLOC_SLEEP_FLAGS);
>    if (contexts[cpu] == NULL) {
>      _stp_error ("context (size %lu) allocation failed", (unsigned long) sizeof (struct context));
>      rc = -ENOMEM;
>      goto out;
>    }
>  }
>  global.s_Universe_methodKlassObj = _stp_map_new_ii (MAXMAPENTRIES); if (global.s_Universe_methodKlassObj == NULL) rc = -ENOMEM;
>  if (rc) {
>    _stp_error ("global variable 'Universe_methodKlassObj' allocation failed");
>    goto out;
>  }
>  rwlock_init (& global.s_Universe_methodKlassObj_lock);
>  global.s_Universe_collectedHeap = _stp_map_new_ii (MAXMAPENTRIES); if (global.s_Universe_collectedHeap == NULL) rc = -ENOMEM;
>  if (rc) {
>    _stp_error ("global variable 'Universe_collectedHeap' allocation failed");
>    goto out;
>  }
>  rwlock_init (& global.s_Universe_collectedHeap_lock);
>  global.s_HeapWordSize = _stp_map_new_ii (MAXMAPENTRIES); if (global.s_HeapWordSize == NULL) rc = -ENOMEM;
>  if (rc) {
>    _stp_error ("global variable 'HeapWordSize' allocation failed");
>    goto out;
>  }
>  rwlock_init (& global.s_HeapWordSize_lock);
>  global.s_CodeCache_heap = _stp_map_new_ii (MAXMAPENTRIES); if (global.s_CodeCache_heap == NULL) rc = -ENOMEM;
>  if (rc) {
>    _stp_error ("global variable 'CodeCache_heap' allocation failed");
>    goto out;
>  }
>  rwlock_init (& global.s_CodeCache_heap_lock);
>  
>  if (rc) {
>    _stp_error ("global variable 'sp_register' allocation failed");
>    goto out;
>  }
>  rwlock_init (& global.s_sp_register_lock);
>  
>  if (rc) {
>    _stp_error ("global variable 'fp_register' allocation failed");
>    goto out;
>  }
>  rwlock_init (& global.s_fp_register_lock);
>  
>  if (rc) {
>    _stp_error ("global variable 'pc_register' allocation failed");
>    goto out;
>  }
>  rwlock_init (& global.s_pc_register_lock);
>  
>  if (rc) {
>    _stp_error ("global variable 'ptr_size' allocation failed");
>    goto out;
>  }
>  rwlock_init (& global.s_ptr_size_lock);
>  
>  if (rc) {
>    _stp_error ("global variable 'ptr_mask' allocation failed");
>    goto out;
>  }
>  rwlock_init (& global.s_ptr_mask_lock);
>  
>  if (rc) {
>    _stp_error ("global variable 'constantPoolOopDesc_size' allocation failed");
>    goto out;
>  }
>  rwlock_init (& global.s_constantPoolOopDesc_size_lock);
>  
>  if (rc) {
>    _stp_error ("global variable 'HeapBlock_Header_size' allocation failed");
>    goto out;
>  }
>  rwlock_init (& global.s_HeapBlock_Header_size_lock);
>  
>  if (rc) {
>    _stp_error ("global variable 'oopDesc_size' allocation failed");
>    goto out;
>  }
>  rwlock_init (& global.s_oopDesc_size_lock);
>  global.s_vm_inited = _stp_map_new_ii (MAXMAPENTRIES); if (global.s_vm_inited == NULL) rc = -ENOMEM;
>  if (rc) {
>    _stp_error ("global variable 'vm_inited' allocation failed");
>    goto out;
>  }
>  rwlock_init (& global.s_vm_inited_lock);
>  global.s__reg_offsets = _stp_map_new_si (MAXMAPENTRIES); if (global.s__reg_offsets == NULL) rc = -ENOMEM;
>  if (rc) {
>    _stp_error ("global variable '_reg_offsets' allocation failed");
>    goto out;
>  }
>  rwlock_init (& global.s__reg_offsets_lock);
>  global.s__r32_offsets = _stp_map_new_si (MAXMAPENTRIES); if (global.s__r32_offsets == NULL) rc = -ENOMEM;
>  if (rc) {
>    _stp_error ("global variable '_r32_offsets' allocation failed");
>    goto out;
>  }
>  rwlock_init (& global.s__r32_offsets_lock);
>  
>  if (rc) {
>    _stp_error ("global variable '_stp_regs_registered' allocation failed");
>    goto out;
>  }
>  rwlock_init (& global.s__stp_regs_registered_lock);
>  #ifdef STP_TIMING
>  for (i = 0; i < ARRAY_SIZE(stap_probes); ++i)
>    stap_probes[i].timing = _stp_stat_init (HIST_NONE);
>  #endif
>  _stp_print_kernel_info("1.7/0.152", (num_online_cpus() * sizeof(struct context)), 3);
>  /* ---- utrace uprobes ---- */
>  for (j=0; j<MAXUPROBES; j++) {
>    struct stap_uprobe *sup = & stap_uprobes[j];
>    sup->spec_index = -1;
>  }
>  mutex_init (& stap_uprobes_lock);
>  for (i=0; i<sizeof(stap_uprobe_finders)/sizeof(stap_uprobe_finders[0]); i++) {
>    struct stap_uprobe_tf *stf = & stap_uprobe_finders[i];
>    probe_point = stf->pathname;
>    rc = stap_register_task_finder_target (& stf->finder);
>    if (rc) break;
>  }
>  if (rc) {
>    _stp_error ("probe %s registration error (rc %d)", probe_point, rc);
>    atomic_set (&session_state, STAP_SESSION_ERROR);
>    goto out;
>  }
>  
>  /* ---- vma tracker ---- */
>  rc = _stp_vma_init();
>  
>  /* ---- task finder ---- */
>  if (rc == 0) {
>    rc = stap_start_task_finder();
>    if (rc) {
>      stap_stop_task_finder();
>    }
>  }
>  if (rc) {
>    _stp_error ("probe %s registration error (rc %d)", probe_point, rc);
>    atomic_set (&session_state, STAP_SESSION_ERROR);
>    /* ---- utrace uprobes ---- */
>    for (j=0; j<MAXUPROBES; j++) {
>      struct stap_uprobe *sup = & stap_uprobes[j];
>      const struct stap_uprobe_spec *sups = &stap_uprobe_specs [sup->spec_index];
>      if (sup->spec_index < 0) continue;
>      if (sup->sdt_sem_address) {
>        unsigned short sdt_semaphore;
>        pid_t pid = (sups->return_p ? sup->urp.u.pid : sup->up.pid);
>        struct task_struct *tsk;
>        rcu_read_lock();
>        #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
>          tsk = pid_task(find_pid_ns(pid, &init_pid_ns), PIDTYPE_PID);
>        #else
>          tsk = find_task_by_pid (pid);
>        #endif /* 2.6.24 */
>        if (tsk) {
>          if (__access_process_vm_noflush(tsk, sup->sdt_sem_address, &sdt_semaphore, sizeof(sdt_semaphore), 0)) {
>            sdt_semaphore --;
>            #ifdef DEBUG_UPROBES
>            _stp_dbug (__FUNCTION__,__LINE__, "-semaphore %#x @ %#lx\n", sdt_semaphore, sup->sdt_sem_address);
>            #endif
>            __access_process_vm_noflush(tsk, sup->sdt_sem_address, &sdt_semaphore, sizeof(sdt_semaphore), 1);
>          }
>        }
>        rcu_read_unlock();
>      }
>      if (sups->return_p) {
>        #ifdef DEBUG_UPROBES
>        _stp_dbug (__FUNCTION__,__LINE__, "-uretprobe spec %d index %d pid %d addr %p\n", sup->spec_index, j, sup->up.pid, (void*) sup->up.vaddr);
>        #endif
>        unregister_uretprobe (& sup->urp);
>      } else {
>        #ifdef DEBUG_UPROBES
>        _stp_dbug (__FUNCTION__,__LINE__, "-uprobe spec %d index %d pid %d addr %p\n", sup->spec_index, j, sup->up.pid, (void*) sup->up.vaddr);
>        #endif
>        unregister_uprobe (& sup->up);
>      }
>      sup->spec_index = -1;
>    }
>    mutex_destroy (& stap_uprobes_lock);
>    goto out;
>  }
>  if (atomic_read (&session_state) == STAP_SESSION_STARTING)
>    atomic_set (&session_state, STAP_SESSION_RUNNING);
>  return 0;
>out:
>  _stp_map_del (global.s_Universe_methodKlassObj);
>  _stp_map_del (global.s_Universe_collectedHeap);
>  _stp_map_del (global.s_HeapWordSize);
>  _stp_map_del (global.s_CodeCache_heap);
>  
>  
>  
>  
>  
>  
>  
>  
>  _stp_map_del (global.s_vm_inited);
>  _stp_map_del (global.s__reg_offsets);
>  _stp_map_del (global.s__r32_offsets);
>  
>  atomic_set (&session_state, STAP_SESSION_STOPPED);
>  #ifdef STAPCONF_SYNCHRONIZE_SCHED
>  synchronize_sched();
>  #endif
>  #ifdef STAP_NEED_GETTIMEOFDAY
>   _stp_kill_time();
>  #endif
>  for_each_possible_cpu(cpu) {
>    if (contexts[cpu] != NULL) {
>      _stp_kfree(contexts[cpu]);
>      contexts[cpu] = NULL;
>    }
>  }
>  return rc;
>}
>
>
>static void systemtap_module_refresh (void) {
>  int i=0, j=0;
>  (void) i;
>  (void) j;
>}
>
>
>static void systemtap_module_exit (void) {
>  int holdon;
>  int i=0, j=0;
>  int cpu;
>  unsigned long hold_start;
>  int hold_index;
>  (void) i;
>  (void) j;
>  if (atomic_read (&session_state) == STAP_SESSION_STARTING)
>    return;
>  if (atomic_read (&session_state) == STAP_SESSION_RUNNING)
>    atomic_set (&session_state, STAP_SESSION_STOPPING);
>  
>  /* ---- task finder ---- */
>  stap_stop_task_finder();
>  
>  /* ---- vma tracker ---- */
>  _stp_vma_done();
>  /* ---- utrace uprobes ---- */
>  for (j=0; j<MAXUPROBES; j++) {
>    struct stap_uprobe *sup = & stap_uprobes[j];
>    const struct stap_uprobe_spec *sups = &stap_uprobe_specs [sup->spec_index];
>    if (sup->spec_index < 0) continue;
>    if (sup->sdt_sem_address) {
>      unsigned short sdt_semaphore;
>      pid_t pid = (sups->return_p ? sup->urp.u.pid : sup->up.pid);
>      struct task_struct *tsk;
>      rcu_read_lock();
>      #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)
>        tsk = pid_task(find_pid_ns(pid, &init_pid_ns), PIDTYPE_PID);
>      #else
>        tsk = find_task_by_pid (pid);
>      #endif /* 2.6.24 */
>      if (tsk) {
>        if (__access_process_vm_noflush(tsk, sup->sdt_sem_address, &sdt_semaphore, sizeof(sdt_semaphore), 0)) {
>          sdt_semaphore --;
>          #ifdef DEBUG_UPROBES
>          _stp_dbug (__FUNCTION__,__LINE__, "-semaphore %#x @ %#lx\n", sdt_semaphore, sup->sdt_sem_address);
>          #endif
>          __access_process_vm_noflush(tsk, sup->sdt_sem_address, &sdt_semaphore, sizeof(sdt_semaphore), 1);
>        }
>      }
>      rcu_read_unlock();
>    }
>    if (sups->return_p) {
>      #ifdef DEBUG_UPROBES
>      _stp_dbug (__FUNCTION__,__LINE__, "-uretprobe spec %d index %d pid %d addr %p\n", sup->spec_index, j, sup->up.pid, (void*) sup->up.vaddr);
>      #endif
>      unregister_uretprobe (& sup->urp);
>    } else {
>      #ifdef DEBUG_UPROBES
>      _stp_dbug (__FUNCTION__,__LINE__, "-uprobe spec %d index %d pid %d addr %p\n", sup->spec_index, j, sup->up.pid, (void*) sup->up.vaddr);
>      #endif
>      unregister_uprobe (& sup->up);
>    }
>    sup->spec_index = -1;
>  }
>  mutex_destroy (& stap_uprobes_lock);
>  #ifdef STAPCONF_SYNCHRONIZE_SCHED
>  synchronize_sched();
>  #endif
>  hold_start = jiffies;
>  hold_index = -1;
>  do {
>    int i;
>    holdon = 0;
>    for (i=0; i < NR_CPUS; i++)
>      if (cpu_possible (i) && contexts[i] != NULL && atomic_read (& contexts[i]->busy)) {
>        holdon = 1;
>        if (time_after(jiffies, hold_start + HZ) && (i > hold_index)) {
>          hold_index = i;
>          printk(KERN_ERR "%s context[%d] stuck: %s\n", THIS_MODULE->name, i, contexts[i]->probe_point);
>        }
>      }
>      #ifdef STAP_OVERRIDE_STUCK_CONTEXT
>      if (time_after(jiffies, hold_start + HZ*10)) { 
>        printk(KERN_ERR "%s overriding stuck context to allow module shutdown.", THIS_MODULE->name);
>        holdon = 0;
>      }
>      #else
>      msleep (250);
>      #endif
>      yield ();
>  } while (holdon);
>  atomic_set (&session_state, STAP_SESSION_STOPPED);
>  #ifdef STAPCONF_SYNCHRONIZE_SCHED
>  synchronize_sched();
>  #endif
>  _stp_map_del (global.s_Universe_methodKlassObj);
>  _stp_map_del (global.s_Universe_collectedHeap);
>  _stp_map_del (global.s_HeapWordSize);
>  _stp_map_del (global.s_CodeCache_heap);
>  
>  
>  
>  
>  
>  
>  
>  
>  _stp_map_del (global.s_vm_inited);
>  _stp_map_del (global.s__reg_offsets);
>  _stp_map_del (global.s__r32_offsets);
>  
>  for_each_possible_cpu(cpu) {
>    if (contexts[cpu] != NULL) {
>      _stp_kfree(contexts[cpu]);
>      contexts[cpu] = NULL;
>    }
>  }
>  #ifdef STAP_NEED_GETTIMEOFDAY
>   _stp_kill_time();
>  #endif
>  preempt_disable();
>  #if defined(STP_TIMING) || defined(STP_ALIBI)
>  _stp_printf("----- probe hit report: \n");
>  for (i = 0; i < ARRAY_SIZE(stap_probes); ++i) {
>    struct stap_probe *const p = &stap_probes[i];
>    #ifdef STP_ALIBI
>    int alibi = atomic_read(&(p->alibi));
>    if (alibi)
>      _stp_printf ("%s, (%s), hits: %d,%s\n",
>          p->pp, p->location, alibi, p->derivation);
>    #endif
>    #ifdef STP_TIMING
>    if (likely (p->timing)) {
>      struct stat_data *stats = _stp_stat_get (p->timing, 0);
>      if (stats->count) {
>        int64_t avg = _stp_div64 (NULL, stats->sum, stats->count);
>        _stp_printf ("%s, (%s), hits: %lld, cycles: %lldmin/%lldavg/%lldmax,%s\n",
>            p->pp, p->location, (long long) stats->count,
>            (long long) stats->min, (long long) avg, (long long) stats->max,
>            p->derivation);
>      }
>      _stp_stat_del (p->timing);
>    }
>    #endif
>  }
>  _stp_print_flush();
>  #endif
>  if (atomic_read (& skipped_count) || atomic_read (& error_count) || atomic_read (& skipped_count_reentrant)) {
>    _stp_warn ("Number of errors: %d, skipped probes: %d\n", (int) atomic_read (& error_count), (int) atomic_read (& skipped_count));
>    #ifdef STP_TIMING
>    {
>      int ctr;
>      ctr = atomic_read (& global.s_Universe_methodKlassObj_lock_skip_count);
>      if (ctr) _stp_warn ("Skipped due to global '%s' lock timeout: %d\n", "Universe_methodKlassObj", ctr);
>      ctr = atomic_read (& global.s_Universe_collectedHeap_lock_skip_count);
>      if (ctr) _stp_warn ("Skipped due to global '%s' lock timeout: %d\n", "Universe_collectedHeap", ctr);
>      ctr = atomic_read (& global.s_HeapWordSize_lock_skip_count);
>      if (ctr) _stp_warn ("Skipped due to global '%s' lock timeout: %d\n", "HeapWordSize", ctr);
>      ctr = atomic_read (& global.s_CodeCache_heap_lock_skip_count);
>      if (ctr) _stp_warn ("Skipped due to global '%s' lock timeout: %d\n", "CodeCache_heap", ctr);
>      ctr = atomic_read (& global.s_sp_register_lock_skip_count);
>      if (ctr) _stp_warn ("Skipped due to global '%s' lock timeout: %d\n", "sp_register", ctr);
>      ctr = atomic_read (& global.s_fp_register_lock_skip_count);
>      if (ctr) _stp_warn ("Skipped due to global '%s' lock timeout: %d\n", "fp_register", ctr);
>      ctr = atomic_read (& global.s_pc_register_lock_skip_count);
>      if (ctr) _stp_warn ("Skipped due to global '%s' lock timeout: %d\n", "pc_register", ctr);
>      ctr = atomic_read (& global.s_ptr_size_lock_skip_count);
>      if (ctr) _stp_warn ("Skipped due to global '%s' lock timeout: %d\n", "ptr_size", ctr);
>      ctr = atomic_read (& global.s_ptr_mask_lock_skip_count);
>      if (ctr) _stp_warn ("Skipped due to global '%s' lock timeout: %d\n", "ptr_mask", ctr);
>      ctr = atomic_read (& global.s_constantPoolOopDesc_size_lock_skip_count);
>      if (ctr) _stp_warn ("Skipped due to global '%s' lock timeout: %d\n", "constantPoolOopDesc_size", ctr);
>      ctr = atomic_read (& global.s_HeapBlock_Header_size_lock_skip_count);
>      if (ctr) _stp_warn ("Skipped due to global '%s' lock timeout: %d\n", "HeapBlock_Header_size", ctr);
>      ctr = atomic_read (& global.s_oopDesc_size_lock_skip_count);
>      if (ctr) _stp_warn ("Skipped due to global '%s' lock timeout: %d\n", "oopDesc_size", ctr);
>      ctr = atomic_read (& global.s_vm_inited_lock_skip_count);
>      if (ctr) _stp_warn ("Skipped due to global '%s' lock timeout: %d\n", "vm_inited", ctr);
>      ctr = atomic_read (& global.s__reg_offsets_lock_skip_count);
>      if (ctr) _stp_warn ("Skipped due to global '%s' lock timeout: %d\n", "_reg_offsets", ctr);
>      ctr = atomic_read (& global.s__r32_offsets_lock_skip_count);
>      if (ctr) _stp_warn ("Skipped due to global '%s' lock timeout: %d\n", "_r32_offsets", ctr);
>      ctr = atomic_read (& global.s__stp_regs_registered_lock_skip_count);
>      if (ctr) _stp_warn ("Skipped due to global '%s' lock timeout: %d\n", "_stp_regs_registered", ctr);
>      ctr = atomic_read (& skipped_count_lowstack);
>      if (ctr) _stp_warn ("Skipped due to low stack: %d\n", ctr);
>      ctr = atomic_read (& skipped_count_reentrant);
>      if (ctr) _stp_warn ("Skipped due to reentrancy: %d\n", ctr);
>      ctr = atomic_read (& skipped_count_uprobe_reg);
>      if (ctr) _stp_warn ("Skipped due to uprobe register failure: %d\n", ctr);
>      ctr = atomic_read (& skipped_count_uprobe_unreg);
>      if (ctr) _stp_warn ("Skipped due to uprobe unregister failure: %d\n", ctr);
>    }
>    #endif
>    _stp_print_flush();
>  }
>  preempt_enable_no_resched();
>}
>
>
>#include "stap-symbols.h"
>MODULE_DESCRIPTION("systemtap-generated probe");
>MODULE_LICENSE("GPL");
>
>#undef Universe_methodKlassObj
>
>#undef Universe_collectedHeap
>
>#undef HeapWordSize
>
>#undef CodeCache_heap
>
>#undef sp_register
>module_param_string (sp_register, global.s_sp_register, MAXSTRINGLEN, 0);
>
>#undef fp_register
>module_param_string (fp_register, global.s_fp_register, MAXSTRINGLEN, 0);
>
>#undef pc_register
>module_param_string (pc_register, global.s_pc_register, MAXSTRINGLEN, 0);
>
>#undef ptr_size
>module_param_named (ptr_size, global.s_ptr_size, int64_t, 0);
>
>#undef ptr_mask
>module_param_named (ptr_mask, global.s_ptr_mask, int64_t, 0);
>
>#undef constantPoolOopDesc_size
>module_param_named (constantPoolOopDesc_size, global.s_constantPoolOopDesc_size, int64_t, 0);
>
>#undef HeapBlock_Header_size
>module_param_named (HeapBlock_Header_size, global.s_HeapBlock_Header_size, int64_t, 0);
>
>#undef oopDesc_size
>module_param_named (oopDesc_size, global.s_oopDesc_size, int64_t, 0);
>
>#undef vm_inited
>
>#undef _reg_offsets
>
>#undef _r32_offsets
>
>#undef _stp_regs_registered
>module_param_named (_stp_regs_registered, global.s__stp_regs_registered, int64_t, 0);

Actions: View

Attachments on bug 825244: 586855 | 586938