Macro results from the CPAN

Macro

Alien-LibJIT

view release on metacpan or search on metacpan

libjit/jit/jit-elf-defs.h view on Meta::CPAN


typedef struct
{
  Elf64_Xword m_value;		/* Symbol value.  */
  Elf64_Xword m_info;		/* Size and index.  */
  Elf64_Xword m_poffset;	/* Symbol offset.  */
  Elf64_Half m_repeat;		/* Repeat count.  */
  Elf64_Half m_stride;		/* Stride info.  */
} Elf64_Move;

/* Macro to construct move records.  */
#define ELF32_M_SYM(info)	((info) >> 8)
#define ELF32_M_SIZE(info)	((unsigned char) (info))
#define ELF32_M_INFO(sym, size)	(((sym) << 8) + (unsigned char) (size))

#define ELF64_M_SYM(info)	ELF32_M_SYM (info)
#define ELF64_M_SIZE(info)	ELF32_M_SIZE (info)
#define ELF64_M_INFO(sym, size)	ELF32_M_INFO (sym, size)


/* Motorola 68k specific definitions.  */

libjit/jit/jit-gen-x86-64.h view on Meta::CPAN

/*
 * jit-gen-x86-64.h - Macros for generating x86_64 code.
 *
 * Copyright (C) 2008  Southern Storm Software, Pty Ltd.
 *
 * This file is part of the libjit library.
 *
 * The libjit library is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public License
 * as published by the Free Software Foundation, either version 2.1 of
 * the License, or (at your option) any later version.
 *

libjit/jit/jit-gen-x86-64.h view on Meta::CPAN

			} \
			break;\
			default: \
			{ \
				jit_assert(0); \
			} \
		} \
	} while(0)

/*
 * Macros to implement the simple opcodes.
 */
#define x86_64_alu_reg_reg_size(inst, opc, dreg, sreg, size) \
	do { \
		switch(size) \
		{ \
			case 1: \
			{ \
				x86_64_rex_emit(inst, size, (dreg), 0, (sreg)); \
				*(inst)++ = (((unsigned char)(opc)) << 3) + 2; \
				x86_64_reg_emit((inst), (dreg), (sreg)); \

libjit/jit/jit-gen-x86-64.h view on Meta::CPAN

	do { \
		*(inst)++ = (unsigned char)(p1); \
		x86_64_rex_emit(inst, (size), (r), (indexreg), (basereg)); \
		*(inst)++ = (unsigned char)(opc1); \
		*(inst)++ = (unsigned char)(opc2); \
		*(inst)++ = (unsigned char)(opc3); \
		x86_64_memindex_emit((inst), (r), (basereg), (disp), (indexreg), (shift)); \
	} while(0)

/*
 * xmm1: Macro for use of the X86_64_XMM1 enum
 */
#define x86_64_xmm1_reg_reg(inst, opc, dreg, sreg, is_double) \
	do { \
		x86_64_p1_xmm2_reg_reg_size((inst), ((is_double) ? 0xf2 : 0xf3), 0x0f, (opc), (dreg), (sreg), 0); \
	} while(0)

#define x86_64_xmm1_reg_regp(inst, opc, dreg, sregp, is_double) \
	do { \
		x86_64_p1_xmm2_reg_regp_size((inst), ((is_double) ? 0xf2 : 0xf3), 0x0f, (opc), (dreg), (sregp), 0); \
	} while(0)

libjit/jit/jit-gen-x86-64.h view on Meta::CPAN

	do { \
		x86_64_p1_xmm2_reg_membase_size((inst), 0xf3, 0x0f, 0x5e, (dreg), (basereg), (disp), 0); \
	} while(0)

#define x86_64_divss_reg_memindex(inst, dreg, basereg, disp, indexreg, shift) \
	do { \
		x86_64_p1_xmm2_reg_memindex_size((inst), 0xf3, 0x0f, 0x5e, (dreg), (basereg), (disp), (indexreg), (shift), 0); \
	} while(0)

/*
 * Macros for the logical operations with packed single precision values.
 */
#define x86_64_plops_reg_reg(inst, op, dreg, sreg) \
	do { \
		x86_64_xmm2_reg_reg((inst), 0x0f, (op), (dreg), (sreg)); \
	} while(0)

#define x86_64_plops_reg_regp(inst, op, dreg, sregp) \
	do { \
		x86_64_xmm2_reg_regp((inst), 0x0f, (op), (dreg), (sregp)); \
	} while(0)

libjit/jit/jit-gen-x86-64.h view on Meta::CPAN

		x86_64_p1_xmm2_reg_membase_size((inst), 0xf3, 0x0f, 0x51, (dreg), (basereg), (disp), 0); \
	} while(0)

#define x86_64_sqrtss_reg_memindex(inst, dreg, basereg, disp, indexreg, shift) \
	do { \
		x86_64_p1_xmm2_reg_memindex_size((inst), 0xf3, 0x0f, 0x51, (dreg), (basereg), (disp), (indexreg), (shift), 0); \
	} while(0)


/*
 * Macros for the logical operations with packed double precision values.
 */
#define x86_64_plopd_reg_reg(inst, op, dreg, sreg) \
	do { \
		x86_64_p1_xmm2_reg_reg_size((inst), 0x66, 0x0f, (op), (dreg), (sreg), 0); \
	} while(0)

#define x86_64_plopd_reg_regp(inst, op, dreg, sregp) \
	do { \
		x86_64_p1_xmm2_reg_regp_size((inst), 0x66, 0x0f, (op), (dreg), (sregp), 0); \
	} while(0)

libjit/jit/jit-gen-x86.h view on Meta::CPAN

/*
 * jit-gen-x86.h: Macros for generating x86 code
 *
 * Authors:
 *   Paolo Molaro (lupus@ximian.com)
 *   Intel Corporation (ORP Project)
 *   Sergey Chaban (serge@wildwestsoftware.com)
 *   Dietmar Maurer (dietmar@ximian.com)
 *   Patrik Torstensson
 * 
 * Copyright (C)  2000 Intel Corporation.  All rights reserved.
 * Copyright (C)  2001, 2002 Ximian, Inc.

libjit/jit/jit-internal.h view on Meta::CPAN

#if defined(HAVE_STRING_H)
# include <string.h>
#elif defined(HAVE_STRINGS_H)
# include <strings.h>
#endif
#if defined(HAVE_MEMORY_H)
# include <memory.h>
#endif

/*
 * Macros that replace the routines in <jit/jit-util.h>
 * with direct calls on the underlying library functions.
 */
#if defined(HAVE_MEMSET)
# define jit_memset(s, c, len)		(memset((s), (c), (len)))
# define jit_memzero(s, len)		(memset((s), 0, (len)))
#elif defined(HAVE_BZERO)
# define jit_memzero(s, len)		(bzero((char *)(s), (len)))
#else
# define jit_memzero(s, len)		(jit_memset((char *)(s), 0, (len)))
#endif

libjit/jit/jit-rules.h view on Meta::CPAN

#else
# error "unknown jit backend type"
#endif

/*
 * The information blocks for all registers in the system.
 */
extern jit_reginfo_t const _jit_reg_info[JIT_NUM_REGS];

/*
 * Macros for getting register information
 */

/* Get register name. */
#define jit_reg_name(reg)		(_jit_reg_info[reg].name)

/* Get register flags. */
#define jit_reg_flags(reg)		(_jit_reg_info[reg].flags)

/* Get CPU register number for machine instruction encoding. */
#define jit_reg_code(reg)		(_jit_reg_info[reg].cpu_reg)

libjit/tools/gen-apply.c view on Meta::CPAN


	/* Include jit-apply-func.h here to allow the backend to add it's definitions */
	printf("#include \"jit-apply-func.h\"\n\n");

	printf("void\n_jit_builtin_apply_add_struct(jit_apply_builder *builder, void *value, jit_type_t struct_type);\n\n");

	printf("void\n_jit_builtin_apply_get_struct(jit_apply_builder *builder, void *value, jit_type_t struct_type);\n\n");

	printf("void\n_jit_builtin_apply_get_struct_return(jit_apply_builder *builder, void *return_value, jit_apply_return *apply_return, jit_type_t struct_type);\n\n");

	/* Macro to initialize the apply builder */
	printf("#define jit_apply_builder_init(builder,type)\t\\\n");
	printf("\tdo { \\\n");
	apply_size = max_apply_size;
	printf("\t\t(builder)->apply_args = (jit_apply_struct *)alloca(sizeof(jit_apply_struct)); \\\n");
	if(apply_size > sizeof(void *))
	{
		printf("\t\tjit_memset((builder)->apply_args, 0, %d); \\\n", apply_size);
	}
	printf("\t\t(builder)->apply_args->stack_args = (unsigned char *)alloca(jit_type_get_max_arg_size((type))); \\\n");
	printf("\t\t(builder)->stack_used = 0; \\\n");

libjit/tools/gen-apply.c view on Meta::CPAN

	{
		word_reg_limit = "???";
	}
	if(num_float_regs > 0)
	{
		printf("\t\t(builder)->float_used = 0; \\\n");
	}
	printf("\t\t(builder)->struct_return = 0; \\\n");
	printf("\t} while (0)\n\n");

	/* Macro to initialize the apply builder in closure parse mode.
	   The "args" parameter is the result of calling "__builtin_apply_args" */
	printf("#define jit_apply_parser_init(builder,type,args)\t\\\n");
	printf("\tdo { \\\n");
	printf("\t\t(builder)->apply_args = (jit_apply_struct *)(args); \\\n");
	printf("\t\t(builder)->stack_used = 0; \\\n");
	if(x86_fastcall)
	{
		printf("\t\t(builder)->word_used = 0; \\\n");
		printf("\t\tif(jit_type_get_abi((type)) == jit_abi_fastcall) \\\n");
		printf("\t\t\t(builder)->word_max = 2; \\\n");

libjit/tools/gen-apply.c view on Meta::CPAN

	{
		printf("\t\t(builder)->word_used = 0; \\\n");
	}
	if(num_float_regs > 0)
	{
		printf("\t\t(builder)->float_used = 0; \\\n");
	}
	printf("\t\t(builder)->struct_return = 0; \\\n");
	printf("\t} while (0)\n\n");

	/* Macro to add a word argument to the apply parameters */
	printf("#define jit_apply_builder_add_word(builder,value) \\\n");
	printf("\tdo { \\\n");
	if(num_word_regs > 0 || x86_fastcall)
	{
		printf("\t\tif((builder)->word_used < %s) \\\n", word_reg_limit);
		printf("\t\t{ \\\n");
		printf("\t\t\t(builder)->apply_args->word_regs[(builder)->word_used] = (jit_nint)(value); \\\n");
		printf("\t\t\t++((builder)->word_used); \\\n");
		if(struct_reg_overlaps_word_reg)
		{

libjit/tools/gen-apply.c view on Meta::CPAN

		printf("\t\t\t(builder)->stack_used += sizeof(jit_nint); \\\n");
		printf("\t\t} \\\n");
	}
	else
	{
		printf("\t\t*((jit_nint*)((builder)->apply_args->stack_args + (builder)->stack_used)) = (jit_nint)(value); \\\n");
		printf("\t\t(builder)->stack_used += sizeof(jit_nint); \\\n");
	}
	printf("\t} while (0)\n\n");

	/* Macro to get a word argument from the apply parameters */
	printf("#define jit_apply_parser_get_word(builder,type,value) \\\n");
	printf("\tdo { \\\n");
	if(num_word_regs > 0 || x86_fastcall)
	{
		printf("\t\tif((builder)->word_used < %s) \\\n", word_reg_limit);
		printf("\t\t{ \\\n");
		printf("\t\t\t(value) = (type)((builder)->apply_args->word_regs[(builder)->word_used]); \\\n");
		printf("\t\t\t++((builder)->word_used); \\\n");
		printf("\t\t} \\\n");
		printf("\t\telse \\\n");

libjit/tools/gen-apply.c view on Meta::CPAN

		printf("\t\t\t(builder)->stack_used += sizeof(jit_nint); \\\n");
		printf("\t\t} \\\n");
	}
	else
	{
		printf("\t\t(value) = (type)(*((jit_nint*)((builder)->apply_args->stack_args + (builder)->stack_used))); \\\n");
		printf("\t\t(builder)->stack_used += sizeof(jit_nint); \\\n");
	}
	printf("\t} while (0)\n\n");

	/* Macro to align the word registers for a "long" value */
	printf("#define jit_apply_builder_align_regs(builder,num_words,align) \\\n");
	if((align_long_regs || !can_split_long) &&
	   (num_word_regs > 0 || x86_fastcall))
	{
		printf("\tdo { \\\n");
		printf("\t\tif((align) > sizeof(jit_nint) && (num_words) > 1) \\\n");
		printf("\t\t{ \\\n");
		if(align_long_regs)
		{
			printf("\t\t\tif(((builder)->word_used %% 2) == 1) \\\n");

libjit/tools/gen-apply.c view on Meta::CPAN

			printf("\t\t\t} \\\n");
		}
		printf("\t\t} \\\n");
		printf("\t} while (0)\n\n");
	}
	else
	{
		printf("\tdo { ; } while (0)\n\n");
	}

	/* Macro to align the stack for a "long" value */
	printf("#define jit_apply_builder_align_stack(builder,num_words,align) \\\n");
	if(align_long_stack)
	{
		printf("\tdo { \\\n");
		printf("\t\tif((align) > sizeof(jit_nint) && (num_words) > 1) \\\n");
		printf("\t\t{ \\\n");
		printf("\t\t\tif(((builder)->stack_used %% 2) == 1) \\\n");
		printf("\t\t\t{ \\\n");
		printf("\t\t\t\t++((builder)->stack_used); \\\n");
		printf("\t\t\t} \\\n");
		printf("\t\t} \\\n");
		printf("\t} while (0)\n\n");
	}
	else
	{
		printf("\tdo { ; } while (0)\n\n");
	}

	/* Macro to add a large (e.g. dword) argument to the apply parameters */
	printf("#define jit_apply_builder_add_large_inner(builder,ptr,size,align) \\\n");
	printf("\tdo { \\\n");
	printf("\t\tunsigned int __num_words = ((size) + sizeof(jit_nint) - 1) / sizeof(jit_nint); \\\n");
	if(num_word_regs > 0 || x86_fastcall)
	{
		printf("\t\tjit_apply_builder_align_regs((builder), __num_words, (align)); \\\n");
		printf("\t\tif((%s - (builder)->word_used) >= __num_words) \\\n", word_reg_limit);
		printf("\t\t{ \\\n");
		printf("\t\t\tjit_memcpy((builder)->apply_args->word_regs + (builder)->word_used, (ptr), (size)); \\\n");
		printf("\t\t\t(builder)->word_used += __num_words; \\\n");

libjit/tools/gen-apply.c view on Meta::CPAN

		printf("\t\tjit_memcpy((builder)->apply_args->stack_args + (builder)->stack_used, (ptr), (size)); \\\n");
		printf("\t\t(builder)->stack_used += __num_words * sizeof(jit_nint); \\\n");
	}
	printf("\t} while (0)\n\n");
	printf("#define jit_apply_builder_add_large(builder,type,value) \\\n");
	printf("\tdo { \\\n");
	printf("\t\ttype __temp = (type)(value); \\\n");
	printf("\t\tjit_apply_builder_add_large_inner((builder), &__temp, sizeof(__temp), sizeof(jit_nint)); \\\n");
	printf("\t} while (0)\n\n");

	/* Macro to get a large (e.g. dword) argument from the apply parameters */
	printf("#define jit_apply_parser_get_large(builder,type,finaltype,value) \\\n");
	printf("\tdo { \\\n");
	printf("\t\ttype __temp; \\\n");
	printf("\t\tunsigned int __num_words = (sizeof(__temp) + sizeof(jit_nint) - 1) / sizeof(jit_nint); \\\n");
	if(num_word_regs > 0 || x86_fastcall)
	{
		printf("\t\tjit_apply_builder_align_regs((builder), __num_words, sizeof(type)); \\\n");
		printf("\t\tif((%s - (builder)->word_used) >= __num_words) \\\n", word_reg_limit);
		printf("\t\t{ \\\n");
		printf("\t\t\tjit_memcpy(&__temp, (builder)->apply_args->word_regs + (builder)->word_used, sizeof(__temp)); \\\n");

libjit/tools/gen-apply.c view on Meta::CPAN

	}
	else
	{
		printf("\t\tjit_apply_builder_align_stack((builder), __num_words, sizeof(type)); \\\n");
		printf("\t\tjit_memcpy(&__temp, (builder)->apply_args->stack_args + (builder)->stack_used, sizeof(__temp)); \\\n");
		printf("\t\t(builder)->stack_used += __num_words * sizeof(jit_nint); \\\n");
	}
	printf("\t\t(value) = (finaltype)(__temp); \\\n");
	printf("\t} while (0)\n\n");

	/* Macro to add a large (e.g. dword) argument to the apply parameters
	   on the stack, ignoring word registers */
	printf("#define jit_apply_builder_add_large_stack(builder,type,value) \\\n");
	printf("\tdo { \\\n");
	printf("\t\ttype __temp = (type)(value); \\\n");
	printf("\t\tunsigned int __num_words = (sizeof(__temp) + sizeof(jit_nint) - 1) / sizeof(jit_nint); \\\n");
	printf("\t\tjit_apply_builder_align_stack((builder), __num_words, sizeof(type)); \\\n");
	printf("\t\tjit_memcpy((builder)->apply_args->stack_args + (builder)->stack_used, &__temp, sizeof(__temp)); \\\n");
	printf("\t\t(builder)->stack_used += __num_words * sizeof(jit_nint); \\\n");
	printf("\t} while (0)\n\n");

	/* Macro to get a large (e.g. dword) argument from the apply parameters
	   on the stack, ignoring word registers */
	printf("#define jit_apply_parser_get_large_stack(builder,type,finaltype,value) \\\n");
	printf("\tdo { \\\n");
	printf("\t\ttype __temp; \\\n");
	printf("\t\tunsigned int __num_words = (sizeof(__temp) + sizeof(jit_nint) - 1) / sizeof(jit_nint); \\\n");
	printf("\t\tjit_apply_builder_align_stack((builder), __num_words, sizeof(type)); \\\n");
	printf("\t\tjit_memcpy(&__temp, (builder)->apply_args->stack_args + (builder)->stack_used, sizeof(__temp)); \\\n");
	printf("\t\t(builder)->stack_used += __num_words * sizeof(jit_nint); \\\n");
	printf("\t\t(value) = (finaltype)(__temp); \\\n");
	printf("\t} while (0)\n\n");

	/* Macro to set the structure return area */
	printf("#define jit_apply_builder_add_struct_return(builder,size,return_buf) \\\n");
	printf("\tdo { \\\n");
	printf("\t\tunsigned int __struct_size = (unsigned int)(size); \\\n");
	printf("\t\tif(__struct_size >= 1 && __struct_size <= 64 && \\\n");
	printf("\t\t   (_jit_apply_return_in_reg[(__struct_size - 1) / 8] \\\n");
	printf("\t\t       & (1 << ((__struct_size - 1) %% 8))) != 0) \\\n");
	printf("\t\t{ \\\n");
	printf("\t\t\t(builder)->struct_return = 0; \\\n");
	printf("\t\t} \\\n");
	printf("\t\telse \\\n");

libjit/tools/gen-apply.c view on Meta::CPAN

	{
		printf("\t\t\t(builder)->apply_args->struct_ptr = (builder)->struct_return; \\\n");
	}
	else
	{
		printf("\t\t\tjit_apply_builder_add_word((builder), (builder)->struct_return); \\\n");
	}
	printf("\t\t} \\\n");
	printf("\t} while (0)\n\n");

	/* Macro to extract the structure return value, if it is in registers */
	printf("#define jit_apply_builder_get_struct_return(builder,size,return_buf,apply_return) \\\n");
	printf("\tdo { \\\n");
	printf("\t\tif(!((builder)->struct_return)) \\\n");
	printf("\t\t{ \\\n");
	printf("\t\t\tjit_memcpy((return_buf), (apply_return), (size)); \\\n");
	printf("\t\t} \\\n");
	printf("\t\telse if((builder)->struct_return != (void *)(return_buf)) \\\n");
	printf("\t\t{ \\\n");
	printf("\t\t\tjit_memcpy((return_buf), (builder)->struct_return, (size)); \\\n");
	printf("\t\t} \\\n");
	printf("\t} while (0)\n\n");

	/* Macro to start the vararg area */
	printf("#define jit_apply_builder_start_varargs(builder) \\\n");
	printf("\tdo { \\\n");
	if(varargs_on_stack)
	{
		if(num_word_regs > 0 || x86_fastcall)
		{
			printf("\t\t(builder)->word_used = %s; \\\n", word_reg_limit);
		}
		if(num_float_regs > 0)
		{
			printf("\t\t(builder)->float_used = %d; \\\n", num_float_regs);
		}
	}
	printf("\t} while (0)\n\n");

	/* Macro to start the vararg area when parsing a closure */
	printf("#define jit_apply_parser_start_varargs(builder) \\\n");
	printf("\tdo { \\\n");
	if(varargs_on_stack)
	{
		if(num_word_regs > 0 || x86_fastcall)
		{
			printf("\t\t(builder)->word_used = %s; \\\n", word_reg_limit);
		}
		if(num_float_regs > 0)
		{

( run in 0.705 second using v1.01-cache-2.11-cpan-49f99fa48dc )