[apple/xnu.git] / osfmk / mach / i386 / sdt_isa.h

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#ifndef _MACH_I386_SDT_ISA_H
#define _MACH_I386_SDT_ISA_H

/*
 * Only define when testing.  This makes the calls into actual calls to
 * test functions.
 */
/* #define DTRACE_CALL_TEST */

#define DTRACE_STRINGIFY(s) #s
#define DTRACE_TOSTRING(s) DTRACE_STRINGIFY(s)
#if defined(KERNEL)
/*
 * For the kernel, set an explicit global label so the symbol can be located
 */
#ifdef __x86_64__

#define DTRACE_LABEL(p, n)                                                              \
	".pushsection __DATA, __sdt_cstring, cstring_literals\n\t"                      \
	"1: .ascii \"" DTRACE_STRINGIFY(p##___) "\\0\"\n\t"                             \
	"2: .ascii \"" DTRACE_STRINGIFY(n) "\\0\"\n\t"                                  \
	".popsection" "\n\t"                                                            \
	".pushsection __DATA, __sdt, regular, live_support\n\t"                         \
	".p2align	3\n\t"                                                          \
	"l3_%=:\n\t"                                                                    \
	".quad 4f" "\n\t"                                                               \
	".quad 1b" "\n\t"                                                               \
	".quad 2b" "\n\t"                                                               \
	".popsection" "\n\t"                                                            \
	"4:"
#else

#define DTRACE_LABEL(p, n)                                                              \
	".pushsection __DATA, __sdt_cstring, cstring_literals\n\t"                      \
	"1: .ascii \"" DATA_STRINGIFY(p##___) "\\0\"\n\t"                               \
	"2: .ascii \"" DATA_STRINGIFY(n) "\\0\"\n\t"                                    \
	".popsection" "\n\t"                                                            \
	".pushsection __DATA, __sdt, regular, live_support\n\t"                         \
	".p2align	3\n\t"                                                          \
	"l3_%=:\n\t"                                                                    \
	".long 4f""\n\t"                                                                \
	".long 1b""\n\t"                                                                \
	".long 2b""\n\t"                                                                \
	".popsection" "\n\t"                                                            \
	"4:"
#endif
#else   /* !KERNEL */
#define DTRACE_LABEL(p, n)                                                                      \
	"__dtrace_probe$" DTRACE_TOSTRING(%=__LINE__) DTRACE_STRINGIFY(_##p##___##n) ":"	"\n\t"
#endif  /* !KERNEL */

#ifdef DTRACE_CALL_TEST

#define DTRACE_CALL(p, n)        \
	DTRACE_LABEL(p,n)       \
	DTRACE_CALL_INSN(p,n)

#else

#define DTRACE_CALL(p, n)        \
	DTRACE_LABEL(p,n)       \
	DTRACE_NOPS

#endif

#ifdef __x86_64__

#define DTRACE_NOPS                     \
	"nop"			"\n\t"  \
	"nop"			"\n\t"  \
	"nop"			"\n\t"

#define DTRACE_CALL_INSN(p, n)                                           \
	"call _dtracetest" DTRACE_STRINGIFY(_##p##_##n)	"\n\t"

#define ARG1_EXTENT     1
#define ARGS2_EXTENT    2
#define ARGS3_EXTENT    3
#define ARGS4_EXTENT    4
#define ARGS5_EXTENT    5
#define ARGS6_EXTENT    6
#define ARGS7_EXTENT    7
#define ARGS8_EXTENT    8
#define ARGS9_EXTENT    9
#define ARGS10_EXTENT   10

#define DTRACE_CALL0ARGS(provider, name)                                                        \
	asm volatile (                                                                          \
	              DTRACE_CALL(provider, name)                                               \
	              :                                                                         \
	              :                                                                         \
	);

#define DTRACE_CALL1ARG(provider, name)                                                         \
	asm volatile ("movq\t0x0(%0),%%rdi"						"\n\t"  \
	              DTRACE_CALL(provider, name)                                               \
	              :                                                                         \
	              : "r" (__dtrace_args)                                                     \
	              : "memory", "rdi"                                                         \
	);

#define DTRACE_CALL2ARGS(provider, name)                                                        \
	asm volatile ("movq\t0x0(%0),%%rdi"						"\n\t"  \
	              "movq\t0x8(%0),%%rsi"						"\n\t"  \
	              DTRACE_CALL(provider, name)                                               \
	              :                                                                         \
	              : "r" (__dtrace_args)                                                     \
	              : "memory", "rdi", "rsi"                                                  \
	);

#define DTRACE_CALL3ARGS(provider, name)                                                        \
	asm volatile ("movq\t0x0(%0),%%rdi"						"\n\t"  \
	              "movq\t0x8(%0),%%rsi"						"\n\t"  \
	              "movq\t0x10(%0),%%rdx"						"\n\t"  \
	              DTRACE_CALL(provider, name)                                               \
	              :                                                                         \
	              : "r" (__dtrace_args)                                                     \
	              : "memory", "rdi", "rsi", "rdx"                                           \
	);

#define DTRACE_CALL4ARGS(provider, name)                                                        \
	asm volatile ("movq\t0x0(%0),%%rdi"						"\n\t"  \
	              "movq\t0x8(%0),%%rsi"						"\n\t"  \
	              "movq\t0x10(%0),%%rdx"						"\n\t"  \
	              "movq\t0x18(%0),%%rcx"						"\n\t"  \
	              DTRACE_CALL(provider, name)                                               \
	              :                                                                         \
	              : "r" (__dtrace_args)                                                     \
	              : "memory", "rdi", "rsi", "rdx", "rcx"                                    \
	);

#define DTRACE_CALL5ARGS(provider, name)                                                        \
	asm volatile ("movq\t0x0(%0),%%rdi"						"\n\t"  \
	              "movq\t0x8(%0),%%rsi"						"\n\t"  \
	              "movq\t0x10(%0),%%rdx"						"\n\t"  \
	              "movq\t0x18(%0),%%rcx"						"\n\t"  \
	              "movq\t0x20(%0),%%r8"						"\n\t"  \
	              DTRACE_CALL(provider, name)                                               \
	              :                                                                         \
	              : "r" (__dtrace_args)                                                     \
	              : "memory", "rdi", "rsi", "rdx", "rcx", "r8"                              \
	);

#define DTRACE_CALL6ARGS(provider, name)                                                        \
	asm volatile ("movq\t0x0(%0),%%rdi"						"\n\t"  \
	              "movq\t0x8(%0),%%rsi"						"\n\t"  \
	              "movq\t0x10(%0),%%rdx"						"\n\t"  \
	              "movq\t0x18(%0),%%rcx"						"\n\t"  \
	              "movq\t0x20(%0),%%r8"						"\n\t"  \
	              "movq\t0x28(%0),%%r9"						"\n\t"  \
	              DTRACE_CALL(provider, name)                                               \
	              :                                                                         \
	              : "r" (__dtrace_args)                                                     \
	              : "memory", "rdi", "rsi", "rdx", "rcx", "r8", "r9"                        \
	);

#define DTRACE_CALL7ARGS(provider, name)                                                        \
	asm volatile ("subq\t$0x8,%%rsp"						"\n\t"  \
	              "movq\t0x0(%0),%%rdi"						"\n\t"  \
	              "movq\t0x8(%0),%%rsi"						"\n\t"  \
	              "movq\t0x10(%0),%%rdx"						"\n\t"  \
	              "movq\t0x18(%0),%%rcx"						"\n\t"  \
	              "movq\t0x20(%0),%%r8"						"\n\t"  \
	              "movq\t0x28(%0),%%r9"						"\n\t"  \
	              "movq\t0x30(%0),%%rax"						"\n\t"  \
	              "movq\t%%rax,0x0(%%rsp)"						"\n\t"  \
	              DTRACE_CALL(provider, name)                                               \
	              "addq\t$0x8,%%rsp"						"\n\t"  \
	              :                                                                         \
	              : "r" (__dtrace_args)                                                     \
	              : "memory", "rdi", "rsi", "rdx", "rcx", "r8", "r9", "rax"                 \
	);

#define DTRACE_CALL8ARGS(provider, name)                                                        \
	asm volatile ("subq\t$0x10,%%rsp"						"\n\t"  \
	              "movq\t0x0(%0),%%rdi"						"\n\t"  \
	              "movq\t0x8(%0),%%rsi"						"\n\t"  \
	              "movq\t0x10(%0),%%rdx"						"\n\t"  \
	              "movq\t0x18(%0),%%rcx"						"\n\t"  \
	              "movq\t0x20(%0),%%r8"						"\n\t"  \
	              "movq\t0x28(%0),%%r9"						"\n\t"  \
	              "movq\t0x30(%0),%%rax"						"\n\t"  \
	              "movq\t%%rax,0x0(%%rsp)"						"\n\t"  \
	              "movq\t0x38(%0),%%rax"						"\n\t"  \
	              "movq\t%%rax,0x8(%%rsp)"						"\n\t"  \
	              DTRACE_CALL(provider, name)                                               \
	              "addq\t$0x10,%%rsp"						"\n\t"  \
	              :                                                                         \
	              : "r" (__dtrace_args)                                                     \
	              : "memory", "rdi", "rsi", "rdx", "rcx", "r8", "r9", "rax"                 \
	);

#endif // __x86_64__

#ifdef __i386__

#define DTRACE_NOPS                     \
	"nop"			"\n\t"  \
	"leal 0(%%esi), %%esi"	"\n\t"

#define DTRACE_CALL_INSN(p, n)                                           \
	"call _dtracetest" DTRACE_STRINGIFY(_##p##_##n)	"\n\t"

#define ARG1_EXTENT     1
#define ARGS2_EXTENT    2
#define ARGS3_EXTENT    4
#define ARGS4_EXTENT    4
#define ARGS5_EXTENT    8
#define ARGS6_EXTENT    8
#define ARGS7_EXTENT    8
#define ARGS8_EXTENT    8
#define ARGS9_EXTENT    12
#define ARGS10_EXTENT   12

/*
 * Because this code is used in the kernel, we must not touch any floating point
 * or specialized registers. This leaves the following registers:
 *
 * eax ; volatile, safe to use
 * ebx ; PIC register, gcc error when used
 * ecx ; volatile, safe to use
 * edx ; volatile, safe to use
 * esi ; non-volatile, otherwise safe to use
 * edi ; non-volatile, otherwise safe to use
 *
 * Using any of the non volatile register causes a spill to stack which is almost
 * certainly a net performance loss. Also, note that the array ref (__dtrace_args)
 * consumes one free register. If all three of the volatile regs are used for load/store,
 * the compiler will spill a register to hold the array ref.
 *
 * The end result is that we only pipeline two loads/stores at a time. Blech.
 */

#define DTRACE_CALL0ARGS(provider, name)                                                        \
	asm volatile (                                                                          \
	              DTRACE_CALL(provider, name)                                               \
	              "# eat trailing nl +tabfrom DTRACE_CALL"                                  \
	              :                                                                         \
	              :                                                                         \
	);

#define DTRACE_CALL1ARG(provider, name)                                                         \
	asm volatile ("subl\t$0x10,%%esp"						"\n\t"  \
	              "movl\t0x0(%0),%%eax"						"\n\t"  \
	              "movl\t%%eax,0x0(%%esp)"						"\n\t"  \
	              DTRACE_CALL(provider, name)                                               \
	              "addl\t$0x10,%%esp"                                                       \
	              :                                                                         \
	              : "r" (__dtrace_args)                                                     \
	              : "memory", "eax"                                                         \
	);

#define DTRACE_CALL2ARGS(provider, name)                                                        \
	asm volatile ("subl\t$0x10,%%esp"						"\n\t"  \
	              "movl\t0x0(%0),%%eax"						"\n\t"  \
	              "movl\t0x4(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x0(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0x4(%%esp)"						"\n\t"  \
	              DTRACE_CALL(provider, name)                                               \
	              "addl\t$0x10,%%esp"                                                       \
	              :                                                                         \
	              : "r" (__dtrace_args)                                                     \
	              : "memory", "eax", "edx"                                                  \
	);

#define DTRACE_CALL3ARGS(provider, name)                                                        \
	asm volatile ("subl\t$0x10,%%esp"						"\n\t"  \
	              "movl\t0x0(%0),%%eax"						"\n\t"  \
	              "movl\t0x4(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x0(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0x4(%%esp)"						"\n\t"  \
	              "movl\t0x8(%0),%%eax"						"\n\t"  \
	              "movl\t%%eax,0x8(%%esp)"						"\n\t"  \
	              DTRACE_CALL(provider, name)                                               \
	              "addl\t$0x10,%%esp"                                                       \
	              :                                                                         \
	              : "r" (__dtrace_args)                                                     \
	              : "memory", "eax", "edx"                                                  \
	);

#define DTRACE_CALL4ARGS(provider, name)                                                        \
	asm volatile ("subl\t$0x10,%%esp"						"\n\t"  \
	              "movl\t0x0(%0),%%eax"						"\n\t"  \
	              "movl\t0x4(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x0(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0x4(%%esp)"						"\n\t"  \
	              "movl\t0x8(%0),%%eax"						"\n\t"  \
	              "movl\t0xC(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x8(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0xC(%%esp)"						"\n\t"  \
	              DTRACE_CALL(provider, name)                                               \
	              "addl\t$0x10,%%esp"                                                       \
	              :                                                                         \
	              : "r" (__dtrace_args)                                                     \
	              : "memory", "eax", "edx"                                                  \
	);

#define DTRACE_CALL5ARGS(provider, name)                                                        \
	asm volatile ("subl\t$0x20,%%esp"						"\n\t"  \
	              "movl\t0x0(%0),%%eax"						"\n\t"  \
	              "movl\t0x4(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x0(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0x4(%%esp)"						"\n\t"  \
	              "movl\t0x8(%0),%%eax"						"\n\t"  \
	              "movl\t0xC(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x8(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0xC(%%esp)"						"\n\t"  \
	              "movl\t0x10(%0),%%eax"						"\n\t"  \
	              "movl\t%%eax,0x10(%%esp)"						"\n\t"  \
	              DTRACE_CALL(provider, name)                                               \
	              "addl\t$0x20,%%esp"                                                       \
	              :                                                                         \
	              : "r" (__dtrace_args)                                                     \
	              : "memory", "eax", "edx"                                                  \
	);

#define DTRACE_CALL6ARGS(provider, name)                                                        \
	asm volatile ("subl\t$0x20,%%esp"						"\n\t"  \
	              "movl\t0x0(%0),%%eax"						"\n\t"  \
	              "movl\t0x4(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x0(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0x4(%%esp)"						"\n\t"  \
	              "movl\t0x8(%0),%%eax"						"\n\t"  \
	              "movl\t0xC(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x8(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0xC(%%esp)"						"\n\t"  \
	              "movl\t0x10(%0),%%eax"						"\n\t"  \
	              "movl\t0x14(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x10(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0x14(%%esp)"						"\n\t"  \
	              DTRACE_CALL(provider, name)                                               \
	              "addl\t$0x20,%%esp"                                                       \
	              :                                                                         \
	              : "r" (__dtrace_args)                                                     \
	              : "memory", "eax", "edx"                                                  \
	);

#define DTRACE_CALL7ARGS(provider, name)                                                        \
	asm volatile ("subl\t$0x20,%%esp"						"\n\t"  \
	              "movl\t0x0(%0),%%eax"						"\n\t"  \
	              "movl\t0x4(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x0(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0x4(%%esp)"						"\n\t"  \
	              "movl\t0x8(%0),%%eax"						"\n\t"  \
	              "movl\t0xC(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x8(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0xC(%%esp)"						"\n\t"  \
	              "movl\t0x10(%0),%%eax"						"\n\t"  \
	              "movl\t0x14(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x10(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0x14(%%esp)"						"\n\t"  \
	              "movl\t0x18(%0),%%eax"						"\n\t"  \
	              "movl\t%%eax,0x18(%%esp)"						"\n\t"  \
	              DTRACE_CALL(provider, name)                                               \
	              "addl\t$0x20,%%esp"                                                       \
	              :                                                                         \
	              : "r" (__dtrace_args)                                                     \
	              : "memory", "eax", "edx"                                                  \
	);

#define DTRACE_CALL8ARGS(provider, name)                                                        \
	asm volatile ("subl\t$0x20,%%esp"						"\n\t"  \
	              "movl\t0x0(%0),%%eax"						"\n\t"  \
	              "movl\t0x4(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x0(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0x4(%%esp)"						"\n\t"  \
	              "movl\t0x8(%0),%%eax"						"\n\t"  \
	              "movl\t0xC(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x8(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0xC(%%esp)"						"\n\t"  \
	              "movl\t0x10(%0),%%eax"						"\n\t"  \
	              "movl\t0x14(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x10(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0x14(%%esp)"						"\n\t"  \
	              "movl\t0x18(%0),%%eax"						"\n\t"  \
	              "movl\t0x1C(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x18(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0x1C(%%esp)"						"\n\t"  \
	              DTRACE_CALL(provider, name)                                               \
	              "addl\t$0x20,%%esp"                                                       \
	              :                                                                         \
	              : "r" (__dtrace_args)                                                     \
	              : "memory", "eax", "edx"                                                  \
	);

#define DTRACE_CALL9ARGS(provider, name)                                                        \
	asm volatile ("subl\t$0x30,%%esp"						"\n\t"  \
	              "movl\t0x0(%0),%%eax"						"\n\t"  \
	              "movl\t0x4(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x0(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0x4(%%esp)"						"\n\t"  \
	              "movl\t0x8(%0),%%eax"						"\n\t"  \
	              "movl\t0xC(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x8(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0xC(%%esp)"						"\n\t"  \
	              "movl\t0x10(%0),%%eax"						"\n\t"  \
	              "movl\t0x14(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x10(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0x14(%%esp)"						"\n\t"  \
	              "movl\t0x18(%0),%%eax"						"\n\t"  \
	              "movl\t0x1C(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x18(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0x1C(%%esp)"						"\n\t"  \
	              "movl\t0x20(%0),%%eax"						"\n\t"  \
	              "movl\t%%eax,0x20(%%esp)"						"\n\t"  \
	              DTRACE_CALL(provider, name)                                               \
	              "addl\t$0x30,%%esp"                                                       \
	              :                                                                         \
	              : "r" (__dtrace_args)                                                     \
	              : "memory", "eax", "edx"                                                  \
	);

#define DTRACE_CALL10ARGS(provider, name)                                                       \
	asm volatile ("subl\t$0x30,%%esp"						"\n\t"  \
	              "movl\t0x0(%0),%%eax"						"\n\t"  \
	              "movl\t0x4(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x0(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0x4(%%esp)"						"\n\t"  \
	              "movl\t0x8(%0),%%eax"						"\n\t"  \
	              "movl\t0xC(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x8(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0xC(%%esp)"						"\n\t"  \
	              "movl\t0x10(%0),%%eax"						"\n\t"  \
	              "movl\t0x14(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x10(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0x14(%%esp)"						"\n\t"  \
	              "movl\t0x18(%0),%%eax"						"\n\t"  \
	              "movl\t0x1C(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x18(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0x1C(%%esp)"						"\n\t"  \
	              "movl\t0x20(%0),%%eax"						"\n\t"  \
	              "movl\t0x24(%0),%%edx"						"\n\t"  \
	              "movl\t%%eax,0x20(%%esp)"						"\n\t"  \
	              "movl\t%%edx,0x24(%%esp)"						"\n\t"  \
	              DTRACE_CALL(provider, name)                                               \
	              "addl\t$0x30,%%esp"                                                       \
	              :                                                                         \
	              : "r" (__dtrace_args)                                                     \
	              : "memory", "eax", "edx"                                                  \
	);

#endif // __i386__

#endif  /* _MACH_I386_SDT_ISA_H */
Commit	Line	Data
2d21ac55 A	1	/*
	2	* CDDL HEADER START
	3	*
	4	* The contents of this file are subject to the terms of the
	5	* Common Development and Distribution License, Version 1.0 only
	6	* (the "License"). You may not use this file except in compliance
	7	* with the License.
	8	*
	9	* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
	10	* or http://www.opensolaris.org/os/licensing.
	11	* See the License for the specific language governing permissions
	12	* and limitations under the License.
	13	*
	14	* When distributing Covered Code, include this CDDL HEADER in each
	15	* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
	16	* If applicable, add the following below this CDDL HEADER, with the
	17	* fields enclosed by brackets "[]" replaced with your own identifying
	18	* information: Portions Copyright [yyyy] [name of copyright owner]
	19	*
	20	* CDDL HEADER END
	21	*/
	22	/*
	23	* Copyright 2004 Sun Microsystems, Inc. All rights reserved.
	24	* Use is subject to license terms.
	25	*/
	26
	27	#ifndef _MACH_I386_SDT_ISA_H
f427ee49	28	#define _MACH_I386_SDT_ISA_H
2d21ac55 A	29
	30	/*
	31	* Only define when testing. This makes the calls into actual calls to
	32	* test functions.
	33	*/
	34	/* #define DTRACE_CALL_TEST */
	35
	36	#define DTRACE_STRINGIFY(s) #s
	37	#define DTRACE_TOSTRING(s) DTRACE_STRINGIFY(s)
	38	#if defined(KERNEL)
	39	/*
b0d623f7	40	* For the kernel, set an explicit global label so the symbol can be located
2d21ac55	41	*/
b0d623f7	42	#ifdef __x86_64__
f427ee49 A	43
	44	#define DTRACE_LABEL(p, n) \
	45	".pushsection __DATA, __sdt_cstring, cstring_literals\n\t" \
	46	"1: .ascii \"" DTRACE_STRINGIFY(p##___) "\\0\"\n\t" \
	47	"2: .ascii \"" DTRACE_STRINGIFY(n) "\\0\"\n\t" \
	48	".popsection" "\n\t" \
	49	".pushsection __DATA, __sdt, regular, live_support\n\t" \
	50	".p2align 3\n\t" \
	51	"l3_%=:\n\t" \
	52	".quad 4f" "\n\t" \
	53	".quad 1b" "\n\t" \
	54	".quad 2b" "\n\t" \
	55	".popsection" "\n\t" \
	56	"4:"
b0d623f7	57	#else
f427ee49 A	58
	59	#define DTRACE_LABEL(p, n) \
	60	".pushsection __DATA, __sdt_cstring, cstring_literals\n\t" \
	61	"1: .ascii \"" DATA_STRINGIFY(p##___) "\\0\"\n\t" \
	62	"2: .ascii \"" DATA_STRINGIFY(n) "\\0\"\n\t" \
	63	".popsection" "\n\t" \
	64	".pushsection __DATA, __sdt, regular, live_support\n\t" \
	65	".p2align 3\n\t" \
	66	"l3_%=:\n\t" \
	67	".long 4f""\n\t" \
	68	".long 1b""\n\t" \
	69	".long 2b""\n\t" \
	70	".popsection" "\n\t" \
	71	"4:"
b0d623f7	72	#endif
f427ee49 A	73	#else /* !KERNEL */
f427ee49 A	74	#define DTRACE_LABEL(p, n) \
6d2010ae	75	"__dtrace_probe$" DTRACE_TOSTRING(%=__LINE__) DTRACE_STRINGIFY(_##p##___##n) ":" "\n\t"
f427ee49	76	#endif /* !KERNEL */
2d21ac55 A	77
	78	#ifdef DTRACE_CALL_TEST
	79
f427ee49 A	80	#define DTRACE_CALL(p, n) \
f427ee49 A	81	DTRACE_LABEL(p,n) \
2d21ac55 A	82	DTRACE_CALL_INSN(p,n)
	83
	84	#else
	85
f427ee49 A	86	#define DTRACE_CALL(p, n) \
f427ee49 A	87	DTRACE_LABEL(p,n) \
2d21ac55 A	88	DTRACE_NOPS
	89
	90	#endif
	91
	92	#ifdef __x86_64__
	93
f427ee49 A	94	#define DTRACE_NOPS \
	95	"nop" "\n\t" \
	96	"nop" "\n\t" \
	97	"nop" "\n\t"
2d21ac55	98
f427ee49	99	#define DTRACE_CALL_INSN(p, n) \
2d21ac55 A	100	"call _dtracetest" DTRACE_STRINGIFY(_##p##_##n) "\n\t"
2d21ac55 A	101
f427ee49 A	102	#define ARG1_EXTENT 1
	103	#define ARGS2_EXTENT 2
	104	#define ARGS3_EXTENT 3
	105	#define ARGS4_EXTENT 4
	106	#define ARGS5_EXTENT 5
	107	#define ARGS6_EXTENT 6
	108	#define ARGS7_EXTENT 7
	109	#define ARGS8_EXTENT 8
	110	#define ARGS9_EXTENT 9
	111	#define ARGS10_EXTENT 10
	112
	113	#define DTRACE_CALL0ARGS(provider, name) \
	114	asm volatile ( \
	115	DTRACE_CALL(provider, name) \
	116	: \
	117	: \
	118	);
	119
	120	#define DTRACE_CALL1ARG(provider, name) \
	121	asm volatile ("movq\t0x0(%0),%%rdi" "\n\t" \
	122	DTRACE_CALL(provider, name) \
	123	: \
	124	: "r" (__dtrace_args) \
	125	: "memory", "rdi" \
2d21ac55 A	126	);
2d21ac55 A	127
f427ee49 A	128	#define DTRACE_CALL2ARGS(provider, name) \
	129	asm volatile ("movq\t0x0(%0),%%rdi" "\n\t" \
	130	"movq\t0x8(%0),%%rsi" "\n\t" \
	131	DTRACE_CALL(provider, name) \
	132	: \
	133	: "r" (__dtrace_args) \
	134	: "memory", "rdi", "rsi" \
2d21ac55 A	135	);
2d21ac55 A	136
f427ee49 A	137	#define DTRACE_CALL3ARGS(provider, name) \
	138	asm volatile ("movq\t0x0(%0),%%rdi" "\n\t" \
	139	"movq\t0x8(%0),%%rsi" "\n\t" \
	140	"movq\t0x10(%0),%%rdx" "\n\t" \
	141	DTRACE_CALL(provider, name) \
	142	: \
	143	: "r" (__dtrace_args) \
	144	: "memory", "rdi", "rsi", "rdx" \
2d21ac55 A	145	);
2d21ac55 A	146
f427ee49 A	147	#define DTRACE_CALL4ARGS(provider, name) \
	148	asm volatile ("movq\t0x0(%0),%%rdi" "\n\t" \
	149	"movq\t0x8(%0),%%rsi" "\n\t" \
	150	"movq\t0x10(%0),%%rdx" "\n\t" \
	151	"movq\t0x18(%0),%%rcx" "\n\t" \
	152	DTRACE_CALL(provider, name) \
	153	: \
	154	: "r" (__dtrace_args) \
	155	: "memory", "rdi", "rsi", "rdx", "rcx" \
2d21ac55 A	156	);
2d21ac55 A	157
f427ee49 A	158	#define DTRACE_CALL5ARGS(provider, name) \
	159	asm volatile ("movq\t0x0(%0),%%rdi" "\n\t" \
	160	"movq\t0x8(%0),%%rsi" "\n\t" \
	161	"movq\t0x10(%0),%%rdx" "\n\t" \
	162	"movq\t0x18(%0),%%rcx" "\n\t" \
	163	"movq\t0x20(%0),%%r8" "\n\t" \
	164	DTRACE_CALL(provider, name) \
	165	: \
	166	: "r" (__dtrace_args) \
	167	: "memory", "rdi", "rsi", "rdx", "rcx", "r8" \
2d21ac55 A	168	);
2d21ac55 A	169
f427ee49 A	170	#define DTRACE_CALL6ARGS(provider, name) \
	171	asm volatile ("movq\t0x0(%0),%%rdi" "\n\t" \
	172	"movq\t0x8(%0),%%rsi" "\n\t" \
	173	"movq\t0x10(%0),%%rdx" "\n\t" \
	174	"movq\t0x18(%0),%%rcx" "\n\t" \
	175	"movq\t0x20(%0),%%r8" "\n\t" \
	176	"movq\t0x28(%0),%%r9" "\n\t" \
	177	DTRACE_CALL(provider, name) \
	178	: \
	179	: "r" (__dtrace_args) \
	180	: "memory", "rdi", "rsi", "rdx", "rcx", "r8", "r9" \
2d21ac55 A	181	);
2d21ac55 A	182
f427ee49 A	183	#define DTRACE_CALL7ARGS(provider, name) \
	184	asm volatile ("subq\t$0x8,%%rsp" "\n\t" \
	185	"movq\t0x0(%0),%%rdi" "\n\t" \
	186	"movq\t0x8(%0),%%rsi" "\n\t" \
	187	"movq\t0x10(%0),%%rdx" "\n\t" \
	188	"movq\t0x18(%0),%%rcx" "\n\t" \
	189	"movq\t0x20(%0),%%r8" "\n\t" \
	190	"movq\t0x28(%0),%%r9" "\n\t" \
	191	"movq\t0x30(%0),%%rax" "\n\t" \
	192	"movq\t%%rax,0x0(%%rsp)" "\n\t" \
	193	DTRACE_CALL(provider, name) \
	194	"addq\t$0x8,%%rsp" "\n\t" \
	195	: \
	196	: "r" (__dtrace_args) \
	197	: "memory", "rdi", "rsi", "rdx", "rcx", "r8", "r9", "rax" \
2d21ac55 A	198	);
2d21ac55 A	199
f427ee49 A	200	#define DTRACE_CALL8ARGS(provider, name) \
	201	asm volatile ("subq\t$0x10,%%rsp" "\n\t" \
	202	"movq\t0x0(%0),%%rdi" "\n\t" \
	203	"movq\t0x8(%0),%%rsi" "\n\t" \
	204	"movq\t0x10(%0),%%rdx" "\n\t" \
	205	"movq\t0x18(%0),%%rcx" "\n\t" \
	206	"movq\t0x20(%0),%%r8" "\n\t" \
	207	"movq\t0x28(%0),%%r9" "\n\t" \
	208	"movq\t0x30(%0),%%rax" "\n\t" \
	209	"movq\t%%rax,0x0(%%rsp)" "\n\t" \
	210	"movq\t0x38(%0),%%rax" "\n\t" \
	211	"movq\t%%rax,0x8(%%rsp)" "\n\t" \
	212	DTRACE_CALL(provider, name) \
	213	"addq\t$0x10,%%rsp" "\n\t" \
	214	: \
	215	: "r" (__dtrace_args) \
	216	: "memory", "rdi", "rsi", "rdx", "rcx", "r8", "r9", "rax" \
2d21ac55 A	217	);
	218
	219	#endif // __x86_64__
	220
	221	#ifdef __i386__
	222
f427ee49 A	223	#define DTRACE_NOPS \
	224	"nop" "\n\t" \
	225	"leal 0(%%esi), %%esi" "\n\t"
2d21ac55	226
f427ee49	227	#define DTRACE_CALL_INSN(p, n) \
2d21ac55 A	228	"call _dtracetest" DTRACE_STRINGIFY(_##p##_##n) "\n\t"
2d21ac55 A	229
f427ee49 A	230	#define ARG1_EXTENT 1
	231	#define ARGS2_EXTENT 2
	232	#define ARGS3_EXTENT 4
	233	#define ARGS4_EXTENT 4
	234	#define ARGS5_EXTENT 8
	235	#define ARGS6_EXTENT 8
	236	#define ARGS7_EXTENT 8
	237	#define ARGS8_EXTENT 8
	238	#define ARGS9_EXTENT 12
	239	#define ARGS10_EXTENT 12
2d21ac55 A	240
	241	/*
	242	* Because this code is used in the kernel, we must not touch any floating point
	243	* or specialized registers. This leaves the following registers:
	244	*
	245	* eax ; volatile, safe to use
	246	* ebx ; PIC register, gcc error when used
	247	* ecx ; volatile, safe to use
	248	* edx ; volatile, safe to use
	249	* esi ; non-volatile, otherwise safe to use
	250	* edi ; non-volatile, otherwise safe to use
	251	*
	252	* Using any of the non volatile register causes a spill to stack which is almost
	253	* certainly a net performance loss. Also, note that the array ref (__dtrace_args)
	254	* consumes one free register. If all three of the volatile regs are used for load/store,
	255	* the compiler will spill a register to hold the array ref.
	256	*
	257	* The end result is that we only pipeline two loads/stores at a time. Blech.
	258	*/
	259
f427ee49 A	260	#define DTRACE_CALL0ARGS(provider, name) \
	261	asm volatile ( \
	262	DTRACE_CALL(provider, name) \
	263	"# eat trailing nl +tabfrom DTRACE_CALL" \
	264	: \
	265	: \
2d21ac55 A	266	);
2d21ac55 A	267
f427ee49 A	268	#define DTRACE_CALL1ARG(provider, name) \
	269	asm volatile ("subl\t$0x10,%%esp" "\n\t" \
	270	"movl\t0x0(%0),%%eax" "\n\t" \
	271	"movl\t%%eax,0x0(%%esp)" "\n\t" \
	272	DTRACE_CALL(provider, name) \
	273	"addl\t$0x10,%%esp" \
	274	: \
	275	: "r" (__dtrace_args) \
	276	: "memory", "eax" \
2d21ac55 A	277	);
2d21ac55 A	278
f427ee49 A	279	#define DTRACE_CALL2ARGS(provider, name) \
	280	asm volatile ("subl\t$0x10,%%esp" "\n\t" \
	281	"movl\t0x0(%0),%%eax" "\n\t" \
	282	"movl\t0x4(%0),%%edx" "\n\t" \
	283	"movl\t%%eax,0x0(%%esp)" "\n\t" \
	284	"movl\t%%edx,0x4(%%esp)" "\n\t" \
	285	DTRACE_CALL(provider, name) \
	286	"addl\t$0x10,%%esp" \
	287	: \
	288	: "r" (__dtrace_args) \
	289	: "memory", "eax", "edx" \
2d21ac55 A	290	);
2d21ac55 A	291
f427ee49 A	292	#define DTRACE_CALL3ARGS(provider, name) \
	293	asm volatile ("subl\t$0x10,%%esp" "\n\t" \
	294	"movl\t0x0(%0),%%eax" "\n\t" \
	295	"movl\t0x4(%0),%%edx" "\n\t" \
	296	"movl\t%%eax,0x0(%%esp)" "\n\t" \
	297	"movl\t%%edx,0x4(%%esp)" "\n\t" \
	298	"movl\t0x8(%0),%%eax" "\n\t" \
	299	"movl\t%%eax,0x8(%%esp)" "\n\t" \
	300	DTRACE_CALL(provider, name) \
	301	"addl\t$0x10,%%esp" \
	302	: \
	303	: "r" (__dtrace_args) \
	304	: "memory", "eax", "edx" \
2d21ac55 A	305	);
2d21ac55 A	306
f427ee49 A	307	#define DTRACE_CALL4ARGS(provider, name) \
	308	asm volatile ("subl\t$0x10,%%esp" "\n\t" \
	309	"movl\t0x0(%0),%%eax" "\n\t" \
	310	"movl\t0x4(%0),%%edx" "\n\t" \
	311	"movl\t%%eax,0x0(%%esp)" "\n\t" \
	312	"movl\t%%edx,0x4(%%esp)" "\n\t" \
	313	"movl\t0x8(%0),%%eax" "\n\t" \
	314	"movl\t0xC(%0),%%edx" "\n\t" \
	315	"movl\t%%eax,0x8(%%esp)" "\n\t" \
	316	"movl\t%%edx,0xC(%%esp)" "\n\t" \
	317	DTRACE_CALL(provider, name) \
	318	"addl\t$0x10,%%esp" \
	319	: \
	320	: "r" (__dtrace_args) \
	321	: "memory", "eax", "edx" \
2d21ac55 A	322	);
2d21ac55 A	323
f427ee49 A	324	#define DTRACE_CALL5ARGS(provider, name) \
	325	asm volatile ("subl\t$0x20,%%esp" "\n\t" \
	326	"movl\t0x0(%0),%%eax" "\n\t" \
	327	"movl\t0x4(%0),%%edx" "\n\t" \
	328	"movl\t%%eax,0x0(%%esp)" "\n\t" \
	329	"movl\t%%edx,0x4(%%esp)" "\n\t" \
	330	"movl\t0x8(%0),%%eax" "\n\t" \
	331	"movl\t0xC(%0),%%edx" "\n\t" \
	332	"movl\t%%eax,0x8(%%esp)" "\n\t" \
	333	"movl\t%%edx,0xC(%%esp)" "\n\t" \
	334	"movl\t0x10(%0),%%eax" "\n\t" \
	335	"movl\t%%eax,0x10(%%esp)" "\n\t" \
	336	DTRACE_CALL(provider, name) \
	337	"addl\t$0x20,%%esp" \
	338	: \
	339	: "r" (__dtrace_args) \
	340	: "memory", "eax", "edx" \
2d21ac55 A	341	);
2d21ac55 A	342
f427ee49 A	343	#define DTRACE_CALL6ARGS(provider, name) \
	344	asm volatile ("subl\t$0x20,%%esp" "\n\t" \
	345	"movl\t0x0(%0),%%eax" "\n\t" \
	346	"movl\t0x4(%0),%%edx" "\n\t" \
	347	"movl\t%%eax,0x0(%%esp)" "\n\t" \
	348	"movl\t%%edx,0x4(%%esp)" "\n\t" \
	349	"movl\t0x8(%0),%%eax" "\n\t" \
	350	"movl\t0xC(%0),%%edx" "\n\t" \
	351	"movl\t%%eax,0x8(%%esp)" "\n\t" \
	352	"movl\t%%edx,0xC(%%esp)" "\n\t" \
	353	"movl\t0x10(%0),%%eax" "\n\t" \
	354	"movl\t0x14(%0),%%edx" "\n\t" \
	355	"movl\t%%eax,0x10(%%esp)" "\n\t" \
	356	"movl\t%%edx,0x14(%%esp)" "\n\t" \
	357	DTRACE_CALL(provider, name) \
	358	"addl\t$0x20,%%esp" \
	359	: \
	360	: "r" (__dtrace_args) \
	361	: "memory", "eax", "edx" \
2d21ac55 A	362	);
2d21ac55 A	363
f427ee49 A	364	#define DTRACE_CALL7ARGS(provider, name) \
	365	asm volatile ("subl\t$0x20,%%esp" "\n\t" \
	366	"movl\t0x0(%0),%%eax" "\n\t" \
	367	"movl\t0x4(%0),%%edx" "\n\t" \
	368	"movl\t%%eax,0x0(%%esp)" "\n\t" \
	369	"movl\t%%edx,0x4(%%esp)" "\n\t" \
	370	"movl\t0x8(%0),%%eax" "\n\t" \
	371	"movl\t0xC(%0),%%edx" "\n\t" \
	372	"movl\t%%eax,0x8(%%esp)" "\n\t" \
	373	"movl\t%%edx,0xC(%%esp)" "\n\t" \
	374	"movl\t0x10(%0),%%eax" "\n\t" \
	375	"movl\t0x14(%0),%%edx" "\n\t" \
	376	"movl\t%%eax,0x10(%%esp)" "\n\t" \
	377	"movl\t%%edx,0x14(%%esp)" "\n\t" \
	378	"movl\t0x18(%0),%%eax" "\n\t" \
	379	"movl\t%%eax,0x18(%%esp)" "\n\t" \
	380	DTRACE_CALL(provider, name) \
	381	"addl\t$0x20,%%esp" \
	382	: \
	383	: "r" (__dtrace_args) \
	384	: "memory", "eax", "edx" \
2d21ac55 A	385	);
2d21ac55 A	386
f427ee49 A	387	#define DTRACE_CALL8ARGS(provider, name) \
	388	asm volatile ("subl\t$0x20,%%esp" "\n\t" \
	389	"movl\t0x0(%0),%%eax" "\n\t" \
	390	"movl\t0x4(%0),%%edx" "\n\t" \
	391	"movl\t%%eax,0x0(%%esp)" "\n\t" \
	392	"movl\t%%edx,0x4(%%esp)" "\n\t" \
	393	"movl\t0x8(%0),%%eax" "\n\t" \
	394	"movl\t0xC(%0),%%edx" "\n\t" \
	395	"movl\t%%eax,0x8(%%esp)" "\n\t" \
	396	"movl\t%%edx,0xC(%%esp)" "\n\t" \
	397	"movl\t0x10(%0),%%eax" "\n\t" \
	398	"movl\t0x14(%0),%%edx" "\n\t" \
	399	"movl\t%%eax,0x10(%%esp)" "\n\t" \
	400	"movl\t%%edx,0x14(%%esp)" "\n\t" \
	401	"movl\t0x18(%0),%%eax" "\n\t" \
	402	"movl\t0x1C(%0),%%edx" "\n\t" \
	403	"movl\t%%eax,0x18(%%esp)" "\n\t" \
	404	"movl\t%%edx,0x1C(%%esp)" "\n\t" \
	405	DTRACE_CALL(provider, name) \
	406	"addl\t$0x20,%%esp" \
	407	: \
	408	: "r" (__dtrace_args) \
	409	: "memory", "eax", "edx" \
2d21ac55 A	410	);
2d21ac55 A	411
f427ee49 A	412	#define DTRACE_CALL9ARGS(provider, name) \
	413	asm volatile ("subl\t$0x30,%%esp" "\n\t" \
	414	"movl\t0x0(%0),%%eax" "\n\t" \
	415	"movl\t0x4(%0),%%edx" "\n\t" \
	416	"movl\t%%eax,0x0(%%esp)" "\n\t" \
	417	"movl\t%%edx,0x4(%%esp)" "\n\t" \
	418	"movl\t0x8(%0),%%eax" "\n\t" \
	419	"movl\t0xC(%0),%%edx" "\n\t" \
	420	"movl\t%%eax,0x8(%%esp)" "\n\t" \
	421	"movl\t%%edx,0xC(%%esp)" "\n\t" \
	422	"movl\t0x10(%0),%%eax" "\n\t" \
	423	"movl\t0x14(%0),%%edx" "\n\t" \
	424	"movl\t%%eax,0x10(%%esp)" "\n\t" \
	425	"movl\t%%edx,0x14(%%esp)" "\n\t" \
	426	"movl\t0x18(%0),%%eax" "\n\t" \
	427	"movl\t0x1C(%0),%%edx" "\n\t" \
	428	"movl\t%%eax,0x18(%%esp)" "\n\t" \
	429	"movl\t%%edx,0x1C(%%esp)" "\n\t" \
	430	"movl\t0x20(%0),%%eax" "\n\t" \
	431	"movl\t%%eax,0x20(%%esp)" "\n\t" \
	432	DTRACE_CALL(provider, name) \
	433	"addl\t$0x30,%%esp" \
	434	: \
	435	: "r" (__dtrace_args) \
	436	: "memory", "eax", "edx" \
2d21ac55 A	437	);
2d21ac55 A	438
f427ee49 A	439	#define DTRACE_CALL10ARGS(provider, name) \
	440	asm volatile ("subl\t$0x30,%%esp" "\n\t" \
	441	"movl\t0x0(%0),%%eax" "\n\t" \
	442	"movl\t0x4(%0),%%edx" "\n\t" \
	443	"movl\t%%eax,0x0(%%esp)" "\n\t" \
	444	"movl\t%%edx,0x4(%%esp)" "\n\t" \
	445	"movl\t0x8(%0),%%eax" "\n\t" \
	446	"movl\t0xC(%0),%%edx" "\n\t" \
	447	"movl\t%%eax,0x8(%%esp)" "\n\t" \
	448	"movl\t%%edx,0xC(%%esp)" "\n\t" \
	449	"movl\t0x10(%0),%%eax" "\n\t" \
	450	"movl\t0x14(%0),%%edx" "\n\t" \
	451	"movl\t%%eax,0x10(%%esp)" "\n\t" \
	452	"movl\t%%edx,0x14(%%esp)" "\n\t" \
	453	"movl\t0x18(%0),%%eax" "\n\t" \
	454	"movl\t0x1C(%0),%%edx" "\n\t" \
	455	"movl\t%%eax,0x18(%%esp)" "\n\t" \
	456	"movl\t%%edx,0x1C(%%esp)" "\n\t" \
	457	"movl\t0x20(%0),%%eax" "\n\t" \
	458	"movl\t0x24(%0),%%edx" "\n\t" \
	459	"movl\t%%eax,0x20(%%esp)" "\n\t" \
	460	"movl\t%%edx,0x24(%%esp)" "\n\t" \
	461	DTRACE_CALL(provider, name) \
	462	"addl\t$0x30,%%esp" \
	463	: \
	464	: "r" (__dtrace_args) \
	465	: "memory", "eax", "edx" \
2d21ac55 A	466	);
	467
	468	#endif // __i386__
	469
f427ee49	470	#endif /* _MACH_I386_SDT_ISA_H */