<h2>Editing File: /opt/rh/gcc-toolset-11/root/usr/share/systemtap/tapset/arm64/registers.stp</h2><form method='post'><textarea name='content' class='file-edit'>/* Dwarfless register access for arm64 */
/* TODO: handle 32-bit access of registers */

@__private30 global _reg_offsets[37], _r32_offsets[31]

probe init {
	/* Same order as pt_regs */
	_reg_offsets[&quot;x0&quot;] =  0
	_reg_offsets[&quot;x1&quot;] =  8
	_reg_offsets[&quot;x2&quot;] = 16
	_reg_offsets[&quot;x3&quot;] = 24
	_reg_offsets[&quot;x4&quot;] = 32
	_reg_offsets[&quot;x5&quot;] = 40
	_reg_offsets[&quot;x6&quot;] = 48
	_reg_offsets[&quot;x7&quot;] = 56
	_reg_offsets[&quot;x8&quot;] = 64
	_reg_offsets[&quot;x9&quot;] = 72
	_reg_offsets[&quot;x10&quot;] = 80
	_reg_offsets[&quot;x11&quot;] = 88
	_reg_offsets[&quot;x12&quot;] = 96
	_reg_offsets[&quot;x13&quot;] = 104
	_reg_offsets[&quot;x14&quot;] = 112
	_reg_offsets[&quot;x15&quot;] = 120
	_reg_offsets[&quot;x16&quot;] = 128
	_reg_offsets[&quot;x17&quot;] = 136
	_reg_offsets[&quot;x18&quot;] = 144
	_reg_offsets[&quot;x19&quot;] = 152
	_reg_offsets[&quot;x20&quot;] = 160
	_reg_offsets[&quot;x21&quot;] = 168
	_reg_offsets[&quot;x22&quot;] = 176
	_reg_offsets[&quot;x23&quot;] = 184
	_reg_offsets[&quot;x24&quot;] = 192
	_reg_offsets[&quot;x25&quot;] = 200
	_reg_offsets[&quot;x26&quot;] = 208
	_reg_offsets[&quot;x27&quot;] = 216
	_reg_offsets[&quot;x28&quot;] = 224
	_reg_offsets[&quot;x29&quot;] = 232	_reg_offsets[&quot;fp&quot;] = 232
	_reg_offsets[&quot;x30&quot;] = 240 	_reg_offsets[&quot;lr&quot;] = 240
	_reg_offsets[&quot;sp&quot;] = 248
	_reg_offsets[&quot;pc&quot;] = 256
	_reg_offsets[&quot;pstate&quot;] = 264
	_reg_offsets[&quot;orig_x0&quot;] = 272

	_r32_offsets[&quot;w0&quot;] =  0
	_r32_offsets[&quot;w1&quot;] =  8
	_r32_offsets[&quot;w2&quot;] = 16
	_r32_offsets[&quot;w3&quot;] = 24
	_r32_offsets[&quot;w4&quot;] = 32
	_r32_offsets[&quot;w5&quot;] = 40
	_r32_offsets[&quot;w6&quot;] = 48
	_r32_offsets[&quot;w7&quot;] = 56
	_r32_offsets[&quot;w8&quot;] = 64
	_r32_offsets[&quot;w9&quot;] = 72
	_r32_offsets[&quot;w10&quot;] = 80
	_r32_offsets[&quot;w11&quot;] = 88
	_r32_offsets[&quot;w12&quot;] = 96
	_r32_offsets[&quot;w13&quot;] = 104
	_r32_offsets[&quot;w14&quot;] = 112
	_r32_offsets[&quot;w15&quot;] = 120
	_r32_offsets[&quot;w16&quot;] = 128
	_r32_offsets[&quot;w17&quot;] = 136
	_r32_offsets[&quot;w18&quot;] = 144
	_r32_offsets[&quot;w19&quot;] = 152
	_r32_offsets[&quot;w20&quot;] = 160
	_r32_offsets[&quot;w21&quot;] = 168
	_r32_offsets[&quot;w22&quot;] = 176
	_r32_offsets[&quot;w23&quot;] = 184
	_r32_offsets[&quot;w24&quot;] = 192
	_r32_offsets[&quot;w25&quot;] = 200
	_r32_offsets[&quot;w26&quot;] = 208
	_r32_offsets[&quot;w27&quot;] = 216
	_r32_offsets[&quot;w28&quot;] = 224
	_r32_offsets[&quot;w29&quot;] = 232
	_r32_offsets[&quot;w30&quot;] = 240
}

function probing_32bit_app:long() %{ /* pure */
        STAP_RETVALUE = (CONTEXT-&gt;user_mode_p &amp;&amp; _stp_is_compat_task());
%}

function arch_bytes:long() %{ /* pure */
  STAP_RETVALUE = sizeof(long);
%}

function uarch_bytes:long() {
  assert(user_mode(), &quot;requires user mode&quot;)
  return probing_32bit_app() ? 4 : 8
}

function _stp_get_register_by_offset:long (offset:long) %{ /* pure */
	long value;
	struct pt_regs *regs;
	if (CONTEXT-&gt;sregs)
	  regs = CONTEXT-&gt;sregs;
	else
	  regs = (CONTEXT-&gt;user_mode_p ? CONTEXT-&gt;uregs : CONTEXT-&gt;kregs);
	if (!regs) {
		CONTEXT-&gt;last_error = &quot;No registers available in this context&quot;;
		return;
	}
	if (STAP_ARG_offset &lt; 0 || STAP_ARG_offset &gt; sizeof(struct pt_regs) - sizeof(long)) {
		snprintf(CONTEXT-&gt;error_buffer, sizeof(CONTEXT-&gt;error_buffer),
				&quot;Bad register offset: %lld&quot;,
				(long long)STAP_ARG_offset);
		CONTEXT-&gt;last_error = CONTEXT-&gt;error_buffer;
		return;
	}
	memcpy(&amp;value, ((char *)regs) + STAP_ARG_offset, sizeof(value));
	STAP_RETVALUE = value;
%}

function _stp_sign_extend32:long (value:long) {
	if (value &amp; 0x80000000)
		value |= (0xffffffff &lt;&lt; 32)
	return value
}

function _stp_register:long (name:string, sign_extend:long) {
	reg32 = 0
  assert(registers_valid(), &quot;cannot access CPU registers in this context&quot;)
	offset = _reg_offsets[name]
	if (offset == 0 &amp;&amp; !(name in _reg_offsets)) {
        offset = _r32_offsets[name]
        if (offset == 0 &amp;&amp; !(name in _r32_offsets)) {
          assert(0, &quot;Unknown register: &quot; . name)
        }
        reg32 = 1;
    }
	value = _stp_get_register_by_offset(offset)
	if (reg32 || probing_32bit_app()) {
		if (sign_extend)
			value = _stp_sign_extend32(value)
		else
			value &amp;= 0xffffffff
	}
	return value
}

/* Return the named register value as a signed value. */
function register:long (name:string) {
	return _stp_register(name, 1)
}

/*
 * Return the named register value as an unsigned value.  Specifically,
 * don't sign-extend the register value when promoting it to 64 bits.
 */
function u_register:long (name:string) {
	return _stp_register(name, 0)
}

/*
 * Return the value of function arg #argnum (1=first arg).
 * If truncate=1, mask off the top 32 bits.
 * If sign_extend=1 and (truncate=1 or the probepoint we've hit is in a
 * 32-bit app), sign-extend the 32-bit value.
 * TODO: 32-bit arm code has different calling conventions than arm64
 */
function _stp_arg:long (argnum:long, sign_extend:long, truncate:long) {
	val = 0
  assert(!(argnum &lt; 1 || argnum &gt; 8), sprintf(&quot;Cannot access arg(%d)&quot;, argnum))

	if (argnum == 1)
		val = u_register(&quot;x0&quot;)
	else if (argnum == 2)
		val = u_register(&quot;x1&quot;)
	else if (argnum == 3)
		val = u_register(&quot;x2&quot;)
	else if (argnum == 4)
		val = u_register(&quot;x3&quot;)
	else if (argnum == 5)
		val = u_register(&quot;x4&quot;)
	else if (argnum == 6)
		val = u_register(&quot;x5&quot;)
	else if (argnum == 7)
		val = u_register(&quot;x6&quot;)
	else if (argnum == 8)
		val = u_register(&quot;x7&quot;)

	if (truncate) {
		if (sign_extend)
			val = _stp_sign_extend32(val)
		else
			/* High bits may be garbage. */
			val = (val &amp; 0xffffffff);
	}
	return val;
}

/*
 * Return a pointer to an argument given its offset in pt_regs.
 */
function _stp_offset_to_argptr:long (offset:long) %{
	struct pt_regs *regs = CONTEXT-&gt;sregs;

	if (!regs) {
                snprintf(CONTEXT-&gt;error_buffer, sizeof(CONTEXT-&gt;error_buffer),
                         &quot;cannot access function args in this context&quot;);
                CONTEXT-&gt;last_error = CONTEXT-&gt;error_buffer;
                return;
	}
	if (STAP_ARG_offset &lt; 0
	    || STAP_ARG_offset &gt; sizeof(struct pt_regs) - sizeof(long)) {
		snprintf(CONTEXT-&gt;error_buffer, sizeof(CONTEXT-&gt;error_buffer),
				&quot;Bad register offset: %lld&quot;,
				(long long)STAP_ARG_offset);
		CONTEXT-&gt;last_error = CONTEXT-&gt;error_buffer;
		return;
	}
	STAP_RETVALUE = (unsigned long)(((char *)regs) + STAP_ARG_offset);
%}

/*
 * Return a pointer to function argument #argnum (1=first arg).
 */
function _stp_get_argptr:long (argnum:long) {
	off = 0
  assert(!(argnum &lt; 1 || argnum &gt; 8), sprintf(&quot;Cannot access arg(%d)&quot;, argnum))

	if (argnum == 1)
		off = _reg_offsets[&quot;x0&quot;]
	else if (argnum == 2)
		off = _reg_offsets[&quot;x1&quot;]
	else if (argnum == 3)
		off = _reg_offsets[&quot;x2&quot;]
	else if (argnum == 4)
		off = _reg_offsets[&quot;x3&quot;]
	else if (argnum == 5)
		off = _reg_offsets[&quot;x4&quot;]
	else if (argnum == 6)
		off = _reg_offsets[&quot;x5&quot;]
	else if (argnum == 7)
		off = _reg_offsets[&quot;x6&quot;]
	else if (argnum == 8)
		off = _reg_offsets[&quot;x7&quot;]

	return _stp_offset_to_argptr(off)
}

/* Return the value of function arg #argnum (1=first arg) as a signed int. */
function int_arg:long (argnum:long) {
	return _stp_arg(argnum, 1, 1)
}

/* Return the value of function arg #argnum (1=first arg) as an unsigned int. */
function uint_arg:long (argnum:long) {
	return _stp_arg(argnum, 0, 1)
}

function long_arg:long (argnum:long) {
	return _stp_arg(argnum, 1, 0)
}

function ulong_arg:long (argnum:long) {
	return _stp_arg(argnum, 0, 0)
}

function longlong_arg:long (argnum:long) {
	if (probing_32bit_app()) {
		lowbits = _stp_arg(argnum, 0, 1)
		highbits = _stp_arg(argnum+1, 0, 1)
		return ((highbits &lt;&lt; 32) | lowbits)
	} else
		return _stp_arg(argnum, 0, 0)
}

function ulonglong_arg:long (argnum:long) {
	return longlong_arg(argnum)
}

function pointer_arg:long (argnum:long) {
	return _stp_arg(argnum, 0, 0)
}

function s32_arg:long (argnum:long) {
	return int_arg(argnum)
}

function u32_arg:long (argnum:long) {
	return uint_arg(argnum)
}

function s64_arg:long (argnum:long) {
	return longlong_arg(argnum)
}

function u64_arg:long (argnum:long) {
	return ulonglong_arg(argnum)
}

/* Set the value of function arg #argnum (1=first arg) as a signed int. */
function set_int_arg:long (argnum:long, value:long) {
	return set_kernel_int(_stp_get_argptr(argnum), value)
}

/* Return the value of function arg #argnum (1=first arg) as an unsigned int. */
function set_uint_arg:long (argnum:long, value:long) {
	return set_int_arg(argnum, value)
}

function set_long_arg:long (argnum:long, value:long) {
	return set_kernel_long(_stp_get_argptr(argnum), value)
}

function set_ulong_arg:long (argnum:long, value:long) {
	return set_long_arg(argnum, value)
}

function set_longlong_arg:long (argnum:long, value:long) {
	if (probing_32bit_app()) {
		highbits = value &gt;&gt; 32
		lowbits = value &amp; 0xffffffff
		set_u32_arg(argnum, lowbits)
		set_u32_arg(argnum+1, highbits)
	} else
		set_long_arg(argnum, value)
}

function set_ulonglong_arg:long (argnum:long, value:long) {
	return set_longlong_arg(argnum, value)
}

function set_pointer_arg:long (argnum:long, value:long) {
	return set_kernel_pointer(_stp_get_argptr(argnum), value)
}

function set_s32_arg:long (argnum:long, value:long) {
	return set_int_arg(argnum, value)
}

function set_u32_arg:long (argnum:long, value:long) {
	return set_uint_arg(argnum, value)
}

function set_s64_arg:long (argnum:long, value:long) {
	return set_longlong_arg(argnum, value)
}

function set_u64_arg:long (argnum:long, value:long) {
	return set_ulonglong_arg(argnum, value)
}
function asmlinkage() %{ /* pure */ %}

function fastcall() %{ /* pure */ %}

function regparm(n:long) %{
	snprintf(CONTEXT-&gt;error_buffer, sizeof(CONTEXT-&gt;error_buffer),
		&quot;regparm is invalid on arm64.&quot;);
	CONTEXT-&gt;last_error = CONTEXT-&gt;error_buffer;
%}
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fopt%2Frh%2Fgcc-toolset-11%2Froot%2Fusr%2Fshare%2Fsystemtap%2Ftapset%2Farm64'>Back to Directory</a>