ftp.nice.ch/pub/next/unix/developer/pcn.2.0.s.tar.gz#/src/include/pcn_structs.h

This is pcn_structs.h in view mode; [Download] [Up]

/*
 * PCN System
 * Author:      Steve Tuecke
 *              Argonne National Laboratory
 *
 * Please see the DISCLAIMER file in the top level directory of the
 * distribution regarding the provisions under which this software
 * is distributed.
 *
 * pcn_structs.h
 *
 * Structure declarations for stuff that pcnlink outputs into
 * the custom info file, and used is by the runtime system.
 */

#ifndef _PCN_INCLUDE_PCN_STRUCTS_H
#define _PCN_INCLUDE_PCN_STRUCTS_H

#include "pcn_tags.h"
#include "pcn_types.h"

/*
#ifdef alliant
#define void int
#endif
*/

typedef u_int_t	code_t;
typedef int_t	foreign_t;

#ifndef NULL
#define NULL		((void *) 0)
#endif

/*
 * CELL_SIZE should be sizeof(cell_t), but it is used in spots that
 * require an integer and not a sizeof(cell_t)
 */
#ifndef CELL_SIZE
#define CELL_SIZE	4
#endif
#define CELL_BITS	CELL_SIZE*8

#if CELL_SIZE == 4
#define CELLS_PER_DOUBLE	2
#define CHARS_PER_CELL		4
#else /* CELL_SIZE == 8 */
#define CELLS_PER_DOUBLE	1
#define CHARS_PER_CELL		8
#endif /* CELL_SIZE */

#define StringSizeToCells(N)  (((N) + CHARS_PER_CELL - 1) / CHARS_PER_CELL)


#if defined(PDB) && !defined(DEBUG)
#define DEBUG 0
#endif

#ifdef PCN_PROFILE
#ifndef GAUGE
#define GAUGE
#endif
#ifndef UPSHOT
#define UPSHOT
#endif
#endif

#ifdef PCNT_FILE
/*
 * If we are compiling a pcnt file, then we want to declare some
 * some variables depending on if its profiling and/or pdb build.
 * The purpose of these variables is to cause a link to fail if
 * the pcnt file is compiled with one set of flags, but is linked
 * with an emulator version for a different set of flags.
 */
#ifdef PDB
int_t _p_compiled_with_pdb;
#else
int_t _p_not_compiled_with_pdb;
#endif
#ifdef PCN_PROFILE
int_t _p_compiled_with_profile;
#else
int_t _p_not_compiled_with_profile;
#endif
#endif /* PCNT_FILE /

/*
 * data_header_t
 *
 * All data that is accessible from PCN is tagged. This structure
 * defines the layout of the tag word.  The 'size' field
 * gives the number of elements in this data structure (i.e., number
 * of array or tuple elements).
 *
 * Note: It is important that the tag reside in the low order
 * 	bits of the word.  This is because a tag word must be
 *	distinguishable from a pointer.  Pointers are always
 *	word aligned, so their two low order bits are always
 *	0.  A tag never has both of the two low order bits set
 *	to 0.  This allows us to follow pointers without having
 *	to first mask off a tag.
 */
typedef struct data_header_struct
{
#ifdef PCN_BIT_FIELDS_R_TO_L
    u_int_t	tag		: TAG_SIZE;
    u_int_t	mark		: 1;
    u_int_t	size		: (CELL_BITS - TAG_SIZE - 1);
#else  /* PCN_BIT_FIELDS_R_TO_L */
    u_int_t	size		: (CELL_BITS - TAG_SIZE - 1);
    u_int_t	mark		: 1;
    u_int_t	tag		: TAG_SIZE;
#endif /* PCN_BIT_FIELDS_R_TO_L */
} data_header_t;


/*
 * byte_filled_word_t
 *
 * The PCN abstract machine instructions divide some words into
 * byte sized chunks.  This byte_filled_word_t structure defines
 * how those bytes are laid out in the word.  b0 (or the pad in
 * a 64 bit machine) should always be the high order byte, and b3 
 * should always be the low order byte.  
 */
typedef struct byte_filled_word_struct {
#ifdef PCN_BIT_FIELDS_R_TO_L
    u_int_t	b3	: 8;
    u_int_t	b2	: 8;
    u_int_t	b1	: 8;
    u_int_t	b0	: 8;
#if CELL_BITS == 64
    u_int_t	pad	: 32;
#endif
#else  /* PCN_BIT_FIELDS_R_TO_L */
#if CELL_BITS == 64
    u_int_t	pad	: 32;
#endif
    u_int_t	b0	: 8;
    u_int_t	b1	: 8;
    u_int_t	b2	: 8;
    u_int_t	b3	: 8;
#endif /* PCN_BIT_FIELDS_R_TO_L */
} byte_filled_word_t;


/*
 * instruction_t
 *
 * PCN abstract machine instruction format.  There are two different
 * type of instructions, t1 and t2:
 *	t1 : Uses the first word for byte size values, and second and
 *		third words for pointers.
 *	t2 : Uses the first two words for byte size values, and
 *		the third word for a pointer.
 */
typedef union instruction_struct {
    struct {
	byte_filled_word_t	op0;
	cell_t *		p1;
	cell_t *		p2;
    } t1;
    struct {
	byte_filled_word_t	op0;
	byte_filled_word_t	op1;
	cell_t *		p2;
    } t2;
} instruction_t;


/*
 * proc_header_t
 *
 * PCN procedure header structure.
 *
 * Every PCN procedure that is linked in has one of these.
 */
typedef struct proc_header_struct
{
    char_t *module_name;/* String containing this procedure's module's name */
    char_t *proc_name;	/* String containing this procedure's name */
    u_int_t arity;	/* The arity of this procedure */
    code_t *code;	/* Pointer to the code array */
    struct proc_header_struct *next; /* Next proc_header in this hash bucket */
#ifdef GAUGE    
    int_t  *idle_timer;	/* Pointer to this procedure's idle timer */
    u_int_t n_counters;	/* Number of counters */
    int_t  *counters;	/* Pointer to counters array */
    u_int_t n_timers;	/* Number of timers */
    int_t  *timers;	/* Pointer to timers array */
    char_t **model;
#endif /* GAUGE */
#ifdef PDB
    bool_t  debugable;	/* procedure compiled with debugging on */
    bool_t  debug;	/* PDB currently debugging this procedure */
    int_t   break_num;	/* Breakpoint number, or 0 if not set as breakpoint */
			/*    If negative, then this breakpoint is disabled */
    bool_t  exported;	/* Is this procedure exported? */
#endif /* PDB */    
} proc_header_t;


/*
 * foreign_table_t
 *
 * A table of all foreign procedures that are linked in and
 * accessible from PCN.  This is only used for debugging
 * purposes.
 */
typedef struct foreign_table_struct
{
    char_t *foreign_name;	/* Name of foreign procedure */
    foreign_t *foreign_ptr;	/* Pointer to foreign procedure */
} foreign_table_t;


/*
 * static_double_value_t
 *
 * A structure defining how doubles that are accessible from
 * PCN are layed out.  (i.e., location of tag, data, etc.)
 *
 * This is used by the linker via the DOUBLE_VALUE_T macro
 * below to create double constants for PCN programs.
 */
typedef struct static_double_value_struct
{
    int_t		n_cells;
    data_header_t	h;
    double_t		d;
} static_double_value_t;

/*
 * static_int_value_t
 *
 * A structure defining how integers that are accessible from
 * PCN are layed out.  (i.e., location of tag, data, etc.)
 *
 * This is used by the linker via the INT_VALUE_T macro
 * below to create integer constants for PCN programs.
 */
typedef struct static_int_value_struct
{
    int_t		n_cells;
    data_header_t	h;
    int_t		i;
} static_int_value_t;

/*
 * static_string_value_t
 *
 * A structure defining how strings that are accessible from
 * PCN are layed out.  (i.e., location of tag, data, etc.)
 *
 * This is used by the linker via the STRING_VALUE_T macro
 * below to create string constants for PCN programs.
 *
 * (Well, actually it is not, because arbitrary length
 * strings need to be layed out in memory immediately after
 * the data_header.  Therefore, the 'str' field array size
 * needs to be different for each string constant.  However,
 * this structure does give show you how string constants
 * are layed out...)
 */
typedef struct static_string_value_struct
{
    int_t		n_cells;
    data_header_t	h;
    char_t		str[4];
} static_string_value_t;


/*
 * Macros which the linker uses to lay out constants in memory...
 */
#ifdef PCN_BIT_FIELDS_R_TO_L

#define DV(StrSize,VarName,Value) \
    static static_double_value_t VarName = {(1+CELLS_PER_DOUBLE),{DOUBLE_TAG,0,1},Value}
#define IV(StrSize,VarName,Value) \
    static static_int_value_t VarName = {(2),{INT_TAG,0,1},Value}
#define SV(StrSize,VarName,Value) \
    static struct { int_t n_cells; data_header_t h; char_t str[StrSize]; } VarName = {(1+StringSizeToCells(StrSize)),{STRING_TAG,0,StrSize},Value}

#else  /* PCN_BIT_FIELDS_R_TO_L */

#define DV(StrSize,VarName,Value) \
    static static_double_value_t VarName = {(1+CELLS_PER_DOUBLE),{1,0,DOUBLE_TAG},Value}
#define IV(StrSize,VarName,Value) \
    static static_int_value_t VarName = {(2),{1,0,INT_TAG},Value}
#define SV(StrSize,VarName,Value) \
    static struct { int_t n_cells; data_header_t h; char_t str[StrSize]; } VarName = {(1+StringSizeToCells(StrSize)),{StrSize,0,STRING_TAG},Value}

#endif /* PCN_BIT_FIELDS_R_TO_L */

/* Some macros to shorten up the pcnt file */
#define EPH	extern proc_header_t
#define EF	extern foreign_t
#define FC	(foreign_t *)
#define SI	static int_t
#define SC	static code_t
#define SCH	static char_t
#define PH	proc_header_t
#define PHC	(proc_header_t *)

#endif /* _PCN_INCLUDE_PCN_STRUCTS_H */

These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Marcel Waldvogel and Netfuture.ch.