path: root/deps/lightning/check/lightning.c

/*
 * Copyright (C) 2012-2019  Free Software Foundation, Inc.
 *
 * This file is part of GNU lightning.
 *
 * GNU lightning 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 3, or (at your option)
 * any later version.
 *
 * GNU lightning is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
 * License for more details.
 *
 * Authors:
 *	Paulo Cesar Pereira de Andrade
 */

#if HAVE_CONFIG_H
# include "config.h"
#endif

#if HAVE_GETOPT_H
#  include <getopt.h>
#else
#  include <unistd.h>
#endif
#include <stdio.h>
#include <stdarg.h>
#include <lightning.h>
#include <dlfcn.h>

#if defined(__linux__) && (defined(__i386__) || defined(__x86_64__))
#  include <fpu_control.h>
#endif

/* The label_t identifier clashes with a system definitions */
#if defined(_AIX) || defined(__sun__) || defined(__osf__)
#  define label_t		l_label_t
#endif

#if defined(__hpux)
#  define DL_HANDLE		RTLD_NEXT
#elif defined(__sgi)
static void			*DL_HANDLE;
#elif defined(__osf__)
#  define DL_HANDLE		NULL
#else
#  define DL_HANDLE		RTLD_DEFAULT
#endif

#if defined(__GNUC__)
#  define noreturn		__attribute__ ((noreturn))
#  define printf_format(f, v)	__attribute__ ((format (printf, f, v)))
#  define maybe_unused		__attribute__ ((unused))
#else
#  define noreturn		/**/
#  define printf_format(f, v)	/**/
#  define maybe_unused		/**/
#endif

#define check_data(length)						\
    do {								\
	if (data_offset + length > data_length)				\
	    error(".data too small (%ld < %ld)",			\
		  data_length, data_offset + length);			\
    } while (0)

#define get_label_by_name(name)	((label_t *)get_hash(labels, name))

#define PARSING_NONE		0
#define PARSING_DATA		1
#define PARSING_CODE		2
#define MAX_IDENTIFIER		256

/*
 * Types
 */
typedef struct instr		  instr_t;
typedef union value		  value_t;
typedef struct parser		  parser_t;
typedef struct label	  	  label_t;
typedef struct patch	  	  patch_t;
typedef struct symbol	  	  symbol_t;
typedef struct hash		  hash_t;
typedef struct entry		  entry_t;
typedef int			(*function_t)(int argc, char *argv[]);

typedef enum {
    tok_eof = -1,
    tok_symbol,
    tok_char,
    tok_int,
    tok_float,
    tok_pointer,
    tok_string,
    tok_register,
    tok_dot,
    tok_newline,
    tok_semicollon,
} token_t;

typedef enum {
    skip_none,
    skip_ws,
    skip_nl,
} skip_t;

typedef enum {
    type_none,
    type_c,
    type_s,
    type_i,
    type_l,
    type_f,
    type_d,
    type_p,
} type_t;

#define compose(a, b)		(((a) << 8) | b)
typedef enum {
    expr_inc	 = compose('+', '+'),
    expr_dec	 = compose('-', '-'),
    expr_not	 = '!',
    expr_com	 = '~',
    expr_mul	 = '*',
    expr_div	 = '/',
    expr_rem	 = '%',
    expr_add	 = '+',
    expr_sub	 = '-',
    expr_lsh	 = compose('<', '<'),
    expr_rsh	 = compose('>', '>'),
    expr_and	 = '&',
    expr_or	 = '|',
    expr_xor	 = '^',
    expr_set	 = '=',
    expr_mulset	 = compose('*', '='),
    expr_divset	 = compose('/', '='),
    expr_remset	 = compose('%', '='),
    expr_addset	 = compose('+', '='),
    expr_subset	 = compose('-', '='),
    expr_lshset	 = compose(expr_lsh, '='),
    expr_rshset	 = compose(expr_rsh, '='),
    expr_andset	 = compose('&', '='),
    expr_orset	 = compose('|', '='),
    expr_xorset	 = compose('^', '='),
    expr_lt	 = '<',
    expr_le	 = compose('<', '='),
    expr_eq	 = compose('=', '='),
    expr_ne	 = compose('!', '='),
    expr_gt	 = '>',
    expr_ge	 = compose('>', '='),
    expr_andand	 = compose('&', '&'),
    expr_oror	 = compose('|', '|'),
    expr_lparen	 = '(',
    expr_rparen	 = ')',
    expr_int	 = '0',
    expr_float	 = '.',
    expr_pointer = '@',
    expr_symbol  = '$',
} expr_t;
#undef compose

struct instr {
    instr_t		 *next;
    const char		 *name;
    void		(*function)(void);
    int			  flag;
};

union value {
    jit_word_t		 i;
    jit_uword_t		 ui;
    float		 f;
    double		 d;
    void		*p;
    char		*cp;
    label_t		*label;
    patch_t		*patch;
};

struct parser {
    FILE		*fp;
    char		 name[256];
    int			 line;
    int			 regval;
    type_t		 regtype;
    expr_t		 expr;
    type_t		 type;
    value_t		 value;

    /* variable length string buffer */
    char		*string;
    int			 length;
    int			 offset;

    int			 newline;
    expr_t		 putback;
    int			 short_circuit;
    int			 parsing;

    struct {
	unsigned char	 buffer[4096];
	int		 offset;
	int		 length;
    } data;
};

typedef enum {
    label_kind_data,
    label_kind_code,
    label_kind_code_forward,
    label_kind_dynamic,
} label_kind_t;

struct hash {
    entry_t		**entries;
    int			  size;
    int			  count;
};

struct entry {
    entry_t		 *next;
    char		 *name;
    void		 *value;
    int			  flag;
};

struct label {
    label_t		*next;
    char		*name;
    void		*value;
    label_kind_t	 kind;
};

typedef enum {
    patch_kind_jmp,
    patch_kind_mov,
    patch_kind_call,
} patch_kind_t;

struct patch {
    patch_t		*next;
    label_t		*label;
    void		*value;
    patch_kind_t	 kind;
};

/* minor support for expressions */
struct symbol {
    symbol_t		*next;
    char		*name;
    value_t		 value;
    type_t		 type;
};

/*
 * Prototypes
 */
static jit_gpr_t get_ireg(void);
static jit_fpr_t get_freg(void);
static symbol_t *get_symbol(void);
static void jmp_forward(void *value, label_t *label);
static void mov_forward(void *value, label_t *label);
static void call_forward(void *value, label_t *label);
static void make_arg(void *value);
static jit_pointer_t get_arg(void);
static jit_word_t get_imm(void);
static void live(void);
static void align(void);	static void name(void);
static void prolog(void);
static void frame(void);	static void tramp(void);
static void ellipsis(void);
static void allocai(void);	static void allocar(void);
static void arg(void);
static void getarg_c(void);	static void getarg_uc(void);
static void getarg_s(void);	static void getarg_us(void);
static void getarg_i(void);
#if __WORDSIZE == 64
static void getarg_ui(void);	static void getarg_l(void);
#endif
static void getarg(void);
static void putargr(void);	static void putargi(void);
static void addr(void);		static void addi(void);
static void addxr(void);	static void addxi(void);
static void addcr(void);	static void addci(void);
static void subr(void);		static void subi(void);
static void subxr(void);	static void subxi(void);
static void subcr(void);	static void subci(void);
static void rsbr(void);		static void rsbi(void);
static void mulr(void);		static void muli(void);
static void qmulr(void);	static void qmuli(void);
static void qmulr_u(void);	static void qmuli_u(void);
static void divr(void);		static void divi(void);
static void divr_u(void);	static void divi_u(void);
static void qdivr(void);	static void qdivi(void);
static void qdivr_u(void);	static void qdivi_u(void);
static void remr(void);		static void remi(void);
static void remr_u(void);	static void remi_u(void);
static void andr(void);		static void andi(void);
static void orr(void);		static void ori(void);
static void xorr(void);		static void xori(void);
static void lshr(void);		static void lshi(void);
static void rshr(void);		static void rshi(void);
static void rshr_u(void);	static void rshi_u(void);
static void negr(void);		static void comr(void);
static void ltr(void);		static void lti(void);
static void ltr_u(void);	static void lti_u(void);
static void ler(void);		static void lei(void);
static void ler_u(void);	static void lei_u(void);
static void eqr(void);		static void eqi(void);
static void ger(void);		static void gei(void);
static void ger_u(void);	static void gei_u(void);
static void gtr(void);		static void gti(void);
static void gtr_u(void);	static void gti_u(void);
static void ner(void);		static void nei(void);
static void movr(void);		static void movi(void);
static void extr_c(void);	static void extr_uc(void);
static void extr_s(void);	static void extr_us(void);
#if __WORDSIZE == 64
static void extr_i(void);	static void extr_ui(void);
#endif
static void htonr_us(void);	static void ntohr_us(void);
static void htonr_ui(void);	static void ntohr_ui(void);
#if __WORDSIZE == 64
static void htonr_ul(void);	static void ntohr_ul(void);
#endif
static void htonr(void);	static void ntohr(void);
static void ldr_c(void);	static void ldi_c(void);
static void ldr_uc(void);	static void ldi_uc(void);
static void ldr_s(void);	static void ldi_s(void);
static void ldr_us(void);	static void ldi_us(void);
static void ldr_i(void);	static void ldi_i(void);
#if __WORDSIZE == 64
static void ldr_ui(void);	static void ldi_ui(void);
static void ldr_l(void);	static void ldi_l(void);
#endif
static void ldr(void);		static void ldi(void);
static void ldxr_c(void);	static void ldxi_c(void);
static void ldxr_uc(void);	static void ldxi_uc(void);
static void ldxr_s(void);	static void ldxi_s(void);
static void ldxr_us(void);	static void ldxi_us(void);
static void ldxr_i(void);	static void ldxi_i(void);
#if __WORDSIZE == 64
static void ldxr_ui(void);	static void ldxi_ui(void);
static void ldxr_l(void);	static void ldxi_l(void);
#endif
static void ldxr(void);		static void ldxi(void);
static void str_c(void);	static void sti_c(void);
static void str_s(void);	static void sti_s(void);
static void str_i(void);	static void sti_i(void);
#if __WORDSIZE == 64
static void str_l(void);	static void sti_l(void);
#endif
static void str(void);		static void sti(void);
static void stxr_c(void);	static void stxi_c(void);
static void stxr_s(void);	static void stxi_s(void);
static void stxr_i(void);	static void stxi_i(void);
#if __WORDSIZE == 64
static void stxr_l(void);	static void stxi_l(void);
#endif
static void stxr(void);		static void stxi(void);
static void bltr(void);		static void blti(void);
static void bltr_u(void);	static void blti_u(void);
static void bler(void);		static void blei(void);
static void bler_u(void);	static void blei_u(void);
static void beqr(void);		static void beqi(void);
static void bger(void);		static void bgei(void);
static void bger_u(void);	static void bgei_u(void);
static void bgtr(void);		static void bgti(void);
static void bgtr_u(void);	static void bgti_u(void);
static void bner(void);		static void bnei(void);
static void bmsr(void);		static void bmsi(void);
static void bmcr(void);		static void bmci(void);
static void boaddr(void);	static void boaddi(void);
static void boaddr_u(void);	static void boaddi_u(void);
static void bxaddr(void);	static void bxaddi(void);
static void bxaddr_u(void);	static void bxaddi_u(void);
static void bosubr(void);	static void bosubi(void);
static void bosubr_u(void);	static void bosubi_u(void);
static void bxsubr(void);	static void bxsubi(void);
static void bxsubr_u(void);	static void bxsubi_u(void);
static void jmpr(void);		static void jmpi(void);
static void callr(void);	static void calli(void);
static void prepare(void);
static void pushargr(void);	static void pushargi(void);
static void finishr(void);	static void finishi(void);
static void ret(void);
static void retr(void);		static void reti(void);
static void retval_c(void);	static void retval_uc(void);
static void retval_s(void);	static void retval_us(void);
static void retval_i(void);
#if __WORDSIZE == 64
static void retval_ui(void);	static void retval_l(void);
#endif
static void retval(void);
static void epilog(void);
static void arg_f(void);	static void getarg_f(void);
static void putargr_f(void);	static void putargi_f(void);
static void addr_f(void);	static void addi_f(void);
static void subr_f(void);	static void subi_f(void);
static void rsbr_f(void);	static void rsbi_f(void);
static void mulr_f(void);	static void muli_f(void);
static void divr_f(void);	static void divi_f(void);
static void negr_f(void);	static void absr_f(void);
static void sqrtr_f(void);
static void ltr_f(void);	static void lti_f(void);
static void ler_f(void);	static void lei_f(void);
static void eqr_f(void);	static void eqi_f(void);
static void ger_f(void);	static void gei_f(void);
static void gtr_f(void);	static void gti_f(void);
static void ner_f(void);	static void nei_f(void);
static void unltr_f(void);	static void unlti_f(void);
static void unler_f(void);	static void unlei_f(void);
static void uneqr_f(void);	static void uneqi_f(void);
static void unger_f(void);	static void ungei_f(void);
static void ungtr_f(void);	static void ungti_f(void);
static void ltgtr_f(void);	static void ltgti_f(void);
static void ordr_f(void);	static void ordi_f(void);
static void unordr_f(void);	static void unordi_f(void);
static void truncr_f_i(void);
#if __WORDSIZE == 64
static void truncr_f_l(void);
#endif
static void truncr_f(void);
static void extr_f(void);	static void extr_d_f(void);
static void movr_f(void);	static void movi_f(void);
static void ldr_f(void);	static void ldi_f(void);
static void ldxr_f(void);	static void ldxi_f(void);
static void str_f(void);	static void sti_f(void);
static void stxr_f(void);	static void stxi_f(void);
static void bltr_f(void);	static void blti_f(void);
static void bler_f(void);	static void blei_f(void);
static void beqr_f(void);	static void beqi_f(void);
static void bger_f(void);	static void bgei_f(void);
static void bgtr_f(void);	static void bgti_f(void);
static void bner_f(void);	static void bnei_f(void);
static void bunltr_f(void);	static void bunlti_f(void);
static void bunler_f(void);	static void bunlei_f(void);
static void buneqr_f(void);	static void buneqi_f(void);
static void bunger_f(void);	static void bungei_f(void);
static void bungtr_f(void);	static void bungti_f(void);
static void bltgtr_f(void);	static void bltgti_f(void);
static void bordr_f(void);	static void bordi_f(void);
static void bunordr_f(void);	static void bunordi_f(void);
static void pushargr_f(void);	static void pushargi_f(void);
static void retr_f(void);	static void reti_f(void);
static void retval_f(void);
static void arg_d(void);	static void getarg_d(void);
static void putargr_d(void);	static void putargi_d(void);
static void addr_d(void);	static void addi_d(void);
static void subr_d(void);	static void subi_d(void);
static void rsbr_d(void);	static void rsbi_d(void);
static void mulr_d(void);	static void muli_d(void);
static void divr_d(void);	static void divi_d(void);
static void negr_d(void);	static void absr_d(void);
static void sqrtr_d(void);
static void ltr_d(void);	static void lti_d(void);
static void ler_d(void);	static void lei_d(void);
static void eqr_d(void);	static void eqi_d(void);
static void ger_d(void);	static void gei_d(void);
static void gtr_d(void);	static void gti_d(void);
static void ner_d(void);	static void nei_d(void);
static void unltr_d(void);	static void unlti_d(void);
static void unler_d(void);	static void unlei_d(void);
static void uneqr_d(void);	static void uneqi_d(void);
static void unger_d(void);	static void ungei_d(void);
static void ungtr_d(void);	static void ungti_d(void);
static void ltgtr_d(void);	static void ltgti_d(void);
static void ordr_d(void);	static void ordi_d(void);
static void unordr_d(void);	static void unordi_d(void);
static void truncr_d_i(void);
#if __WORDSIZE == 64
static void truncr_d_l(void);
#endif
static void truncr_d(void);
static void extr_d(void);	static void extr_f_d(void);
static void movr_d(void);	static void movi_d(void);
static void ldr_d(void);	static void ldi_d(void);
static void ldxr_d(void);	static void ldxi_d(void);
static void str_d(void);	static void sti_d(void);
static void stxr_d(void);	static void stxi_d(void);
static void bltr_d(void);	static void blti_d(void);
static void bler_d(void);	static void blei_d(void);
static void beqr_d(void);	static void beqi_d(void);
static void bger_d(void);	static void bgei_d(void);
static void bgtr_d(void);	static void bgti_d(void);
static void bner_d(void);	static void bnei_d(void);
static void bunltr_d(void);	static void bunlti_d(void);
static void bunler_d(void);	static void bunlei_d(void);
static void buneqr_d(void);	static void buneqi_d(void);
static void bunger_d(void);	static void bungei_d(void);
static void bungtr_d(void);	static void bungti_d(void);
static void bltgtr_d(void);	static void bltgti_d(void);
static void bordr_d(void);	static void bordi_d(void);
static void bunordr_d(void);	static void bunordi_d(void);
static void pushargr_d(void);	static void pushargi_d(void);
static void retr_d(void);	static void reti_d(void);
static void retval_d(void);
static void vastart(void);	static void vapush(void);
static void vaarg(void);	static void vaarg_d(void);
static void vaend(void);

static void error(const char *format, ...) noreturn printf_format(1, 2);
static void warn(const char *format, ...) printf_format(1, 2) maybe_unused;
static void message(const char *kind, const char *format, va_list ap);

static int getch(void);
static int getch_noeof(void);
static int ungetch(int ch);
static int skipws(void);
static int skipnl(void);
static int skipct(void);
static int skipcp(void);
static jit_word_t get_int(skip_t skip);
static jit_uword_t get_uint(skip_t skip);
static double get_float(skip_t skip);
static float make_float(double d);
static void *get_pointer(skip_t skip);
static label_t *get_label(skip_t skip);
static token_t regname(void);
static token_t identifier(int ch);
static void get_data(type_t type);
static void dot(void);
static token_t number(int ch);
static int escape(int ch);
static token_t string(void);
static token_t dynamic(void);
static token_t character(void);
static void expression_prim(void);
static void expression_inc(int pre);
static void expression_dec(int pre);
static void expression_unary(void);
static void expression_mul(void);
static void expression_add(void);
static void expression_shift(void);
static void expression_bit(void);
static void expression_rel(void);
static void expression_cond(void);
static token_t expression(void);
static token_t primary(skip_t skip);
static void parse(void);
static int execute(int argc, char *argv[]);

static void *xmalloc(size_t size);
static void *xrealloc(void *pointer, size_t size);
static void *xcalloc(size_t nmemb, size_t size);

static label_t *new_label(label_kind_t kind, char *name, void *value);
static patch_t *new_patch(patch_kind_t kind, label_t *label, void *value);
static int bcmp_symbols(const void *left, const void *right);
static int qcmp_symbols(const void *left, const void *right);
static symbol_t *new_symbol(char *name);
static symbol_t *get_symbol_by_name(char *name);

static hash_t *new_hash(void);
static int hash_string(char *name);
static void put_hash(hash_t *hash, entry_t *entry);
static entry_t *get_hash(hash_t *hash, char *name);
static void rehash(hash_t *hash);

/*
 * Initialization
 */
static jit_state_t	 *_jit;
static int		  flag_verbose;
static int		  flag_data;
static int		  flag_disasm;
static char		 *progname;
static parser_t		  parser;
static hash_t		 *labels;
static int		  label_offset;
static patch_t		 *patches;
static symbol_t		**symbols;
static int		  symbol_length;
static int		  symbol_offset;
static hash_t		 *instrs;
static char		 *data;
static size_t		  data_offset, data_length;
static instr_t		  instr_vector[] = {
#define entry(value)	{ NULL, #value, value }
#define entry2(name, function)	{ NULL, name, function }
    entry(live),
    entry(align),	entry(name),
    entry(prolog),
    entry(frame),	entry(tramp),
    entry(ellipsis),
    entry(allocai),	entry(allocar),
    entry(arg),
    entry(getarg_c),	entry(getarg_uc),
    entry(getarg_s),	entry(getarg_us),
    entry(getarg_i),
#if __WORDSIZE == 64
    entry(getarg_ui),	entry(getarg_l),
#endif
    entry(getarg),
    entry(putargr),	entry(putargi),
    entry(addr),	entry(addi),
    entry(addxr),	entry(addxi),
    entry(addcr),	entry(addci),
    entry(subr),	entry(subi),
    entry(subxr),	entry(subxi),
    entry(subcr),	entry(subci),
    entry(rsbr),	entry(rsbi),
    entry(mulr),	entry(muli),
    entry(qmulr),	entry(qmuli),
    entry(qmulr_u),	entry(qmuli_u),
    entry(divr),	entry(divi),
    entry(divr_u),	entry(divi_u),
    entry(qdivr),	entry(qdivi),
    entry(qdivr_u),	entry(qdivi_u),
    entry(remr),	entry(remi),
    entry(remr_u),	entry(remi_u),
    entry(andr),	entry(andi),
    entry(orr),		entry(ori),
    entry(xorr),	entry(xori),
    entry(lshr),	entry(lshi),
    entry(rshr),	entry(rshi),
    entry(rshr_u),	entry(rshi_u),
    entry(negr),	entry(comr),
    entry(ltr),		entry(lti),
    entry(ltr_u),	entry(lti_u),
    entry(ler),		entry(lei),
    entry(ler_u),	entry(lei_u),
    entry(eqr),		entry(eqi),
    entry(ger),		entry(gei),
    entry(ger_u),	entry(gei_u),
    entry(gtr),		entry(gti),
    entry(gtr_u),	entry(gti_u),
    entry(ner),		entry(nei),
    entry(movr),	entry(movi),
    entry(extr_c),	entry(extr_uc),
    entry(extr_s),	entry(extr_us),
#if __WORDSIZE == 64
    entry(extr_i),	entry(extr_ui),
#endif
    entry(htonr_us),	entry(ntohr_us),
    entry(htonr_ui),	entry(ntohr_ui),
#if __WORDSIZE == 64
    entry(htonr_ul),	entry(ntohr_ul),
#endif
    entry(htonr),	entry(ntohr),
    entry(ldr_c),	entry(ldi_c),
    entry(ldr_uc), 	entry(ldi_uc),
    entry(ldr_s),	entry(ldi_s),
    entry(ldr_us), 	entry(ldi_us),
    entry(ldr_i),	entry(ldi_i),
#if __WORDSIZE == 64
    entry(ldr_ui), 	entry(ldi_ui),
    entry(ldr_l),	entry(ldi_l),
#endif
    entry(ldr),		entry(ldi),
    entry(ldxr_c),	entry(ldxi_c),
    entry(ldxr_uc),	entry(ldxi_uc),
    entry(ldxr_s),	entry(ldxi_s),
    entry(ldxr_us),	entry(ldxi_us),
    entry(ldxr_i),	entry(ldxi_i),
#if __WORDSIZE == 64
    entry(ldxr_ui),	entry(ldxi_ui),
    entry(ldxr_l),	entry(ldxi_l),
#endif
    entry(ldxr),	entry(ldxi),
    entry(str_c),	entry(sti_c),
    entry(str_s),	entry(sti_s),
    entry(str_i),	entry(sti_i),
#if __WORDSIZE == 64
    entry(str_l),	entry(sti_l),
#endif
    entry(str),		entry(sti),
    entry(stxr_c),	entry(stxi_c),
    entry(stxr_s),	entry(stxi_s),
    entry(stxr_i),	entry(stxi_i),
#if __WORDSIZE == 64
    entry(stxr_l),	entry(stxi_l),
#endif
    entry(stxr),	entry(stxi),
    entry(bltr),	entry(blti),
    entry(bltr_u),	entry(blti_u),
    entry(bler),	entry(blei),
    entry(bler_u),	entry(blei_u),
    entry(beqr),	entry(beqi),
    entry(bger),	entry(bgei),
    entry(bger_u),	entry(bgei_u),
    entry(bgtr),	entry(bgti),
    entry(bgtr_u),	entry(bgti_u),
    entry(bner),	entry(bnei),
    entry(bmsr),	entry(bmsi),
    entry(bmcr),	entry(bmci),
    entry(boaddr),	entry(boaddi),
    entry(boaddr_u),	entry(boaddi_u),
    entry(bxaddr),	entry(bxaddi),
    entry(bxaddr_u),	entry(bxaddi_u),
    entry(bosubr),	entry(bosubi),
    entry(bosubr_u),	entry(bosubi_u),
    entry(bxsubr),	entry(bxsubi),
    entry(bxsubr_u),	entry(bxsubi_u),
    entry(jmpr),	entry(jmpi),
    entry(callr),	entry(calli),
    entry(prepare),
    entry(pushargr),	entry(pushargi),
    entry(finishr),	entry(finishi),
    entry(ret),
    entry(retr),	entry(reti),
    entry(retval_c),	entry(retval_uc),
    entry(retval_s),	entry(retval_us),
    entry(retval_i),
#if __WORDSIZE == 64
    entry(retval_ui),	entry(retval_l),
#endif
    entry(retval),
    entry(epilog),
    entry(arg_f),	entry(getarg_f),
    entry(putargr_f),	entry(putargi_f),
    entry(addr_f),	entry(addi_f),
    entry(subr_f),	entry(subi_f),
    entry(rsbr_f),	entry(rsbi_f),
    entry(mulr_f),	entry(muli_f),
    entry(divr_f),	entry(divi_f),
    entry(negr_f),	entry(absr_f),
    entry(sqrtr_f),
    entry(ltr_f),	entry(lti_f),
    entry(ler_f),	entry(lei_f),
    entry(eqr_f),	entry(eqi_f),
    entry(ger_f),	entry(gei_f),
    entry(gtr_f),	entry(gti_f),
    entry(ner_f),	entry(nei_f),
    entry(unltr_f),	entry(unlti_f),
    entry(unler_f),	entry(unlei_f),
    entry(uneqr_f),	entry(uneqi_f),
    entry(unger_f),	entry(ungei_f),
    entry(ungtr_f),	entry(ungti_f),
    entry(ltgtr_f),	entry(ltgti_f),
    entry(ordr_f),	entry(ordi_f),
    entry(unordr_f),	entry(unordi_f),
    entry(truncr_f_i),
#if __WORDSIZE == 64
    entry(truncr_f_l),
#endif
    entry(truncr_f),
    entry(extr_f),	entry(extr_d_f),
    entry(movr_f),	entry(movi_f),
    entry(ldr_f),	entry(ldi_f),
    entry(ldxr_f),	entry(ldxi_f),
    entry(str_f),	entry(sti_f),
    entry(stxr_f),	entry(stxi_f),
    entry(bltr_f),	entry(blti_f),
    entry(bler_f),	entry(blei_f),
    entry(beqr_f),	entry(beqi_f),
    entry(bger_f),	entry(bgei_f),
    entry(bgtr_f),	entry(bgti_f),
    entry(bner_f),	entry(bnei_f),
    entry(bunltr_f),	entry(bunlti_f),
    entry(bunler_f),	entry(bunlei_f),
    entry(buneqr_f),	entry(buneqi_f),
    entry(bunger_f),	entry(bungei_f),
    entry(bungtr_f),	entry(bungti_f),
    entry(bltgtr_f),	entry(bltgti_f),
    entry(bordr_f),	entry(bordi_f),
    entry(bunordr_f),	entry(bunordi_f),
    entry(pushargr_f),	entry(pushargi_f),
    entry(retr_f),	entry(reti_f),
    entry(retval_f),
    entry(arg_d),	entry(getarg_d),
    entry(putargr_d),	entry(putargi_d),
    entry(addr_d),	entry(addi_d),
    entry(subr_d),	entry(subi_d),
    entry(rsbr_d),	entry(rsbi_d),
    entry(mulr_d),	entry(muli_d),
    entry(divr_d),	entry(divi_d),
    entry(negr_d),	entry(absr_d),
    entry(sqrtr_d),
    entry(ltr_d),	entry(lti_d),
    entry(ler_d),	entry(lei_d),
    entry(eqr_d),	entry(eqi_d),
    entry(ger_d),	entry(gei_d),
    entry(gtr_d),	entry(gti_d),
    entry(ner_d),	entry(nei_d),
    entry(unltr_d),	entry(unlti_d),
    entry(unler_d),	entry(unlei_d),
    entry(uneqr_d),	entry(uneqi_d),
    entry(unger_d),	entry(ungei_d),
    entry(ungtr_d),	entry(ungti_d),
    entry(ltgtr_d),	entry(ltgti_d),
    entry(ordr_d),	entry(ordi_d),
    entry(unordr_d),	entry(unordi_d),
    entry(truncr_d_i),
#if __WORDSIZE == 64
    entry(truncr_d_l),
#endif
    entry(truncr_d),
    entry(extr_d),	entry(extr_f_d),
    entry(movr_d),	entry(movi_d),
    entry(ldr_d),	entry(ldi_d),
    entry(ldxr_d),	entry(ldxi_d),
    entry(str_d),	entry(sti_d),
    entry(stxr_d),	entry(stxi_d),
    entry(bltr_d),	entry(blti_d),
    entry(bler_d),	entry(blei_d),
    entry(beqr_d),	entry(beqi_d),
    entry(bger_d),	entry(bgei_d),
    entry(bgtr_d),	entry(bgti_d),
    entry(bner_d),	entry(bnei_d),
    entry(bunltr_d),	entry(bunlti_d),
    entry(bunler_d),	entry(bunlei_d),
    entry(buneqr_d),	entry(buneqi_d),
    entry(bunger_d),	entry(bungei_d),
    entry(bungtr_d),	entry(bungti_d),
    entry(bltgtr_d),	entry(bltgti_d),
    entry(bordr_d),	entry(bordi_d),
    entry(bunordr_d),	entry(bunordi_d),
    entry(pushargr_d),	entry(pushargi_d),
    entry(retr_d),	entry(reti_d),
    entry(retval_d),
    entry2("va_start", vastart),
    entry2("va_push", vapush),
    entry2("va_arg", vaarg),
    entry2("va_arg_d", vaarg_d),
    entry2("va_end", vaend),
#undef entry
};

/*
 * Implementation
 */
static jit_gpr_t
get_ireg(void)
{
    if (primary(skip_ws) != tok_register)
	error("bad register");
    if (parser.regtype != type_l)
	error("bad int register");

    return ((jit_gpr_t)parser.regval);
}

static jit_fpr_t
get_freg(void)
{
    if (primary(skip_ws) != tok_register)
	error("bad register");
    if (parser.regtype != type_d)
	error("bad float register");

    return ((jit_fpr_t)parser.regval);
}

static symbol_t *
get_symbol(void)
{
    symbol_t	*symbol;
    int		 ch = skipws();

    if (ch != '$')
	error("expecting variable");
    (void)identifier('$');
    if (parser.string[1] == '\0')
	error("expecting variable");
    if ((symbol = get_symbol_by_name(parser.string)) == NULL)
	symbol = new_symbol(parser.string);

    return (symbol);
}

static void
jmp_forward(void *value, label_t *label)
{
    (void)new_patch(patch_kind_jmp, label, value);
}

static void
mov_forward(void *value, label_t *label)
{
    (void)new_patch(patch_kind_mov, label, value);
}

static void
call_forward(void *value, label_t *label)
{
    (void)new_patch(patch_kind_call, label, value);
}

static void
make_arg(void *value)
{
    symbol_t	*symbol = get_symbol();

    symbol->type = type_p;
    symbol->value.p = value;
}

static jit_pointer_t
get_arg(void)
{
    symbol_t	*symbol = get_symbol();

    if (symbol->type != type_p)
	error("bad argument %s type", symbol->name);

    return symbol->value.p;
}

static jit_word_t
get_imm(void)
{
    int		 ch;
    label_t	*label;
    jit_word_t	 value;
    ch = skipws();
    switch (ch) {
	case '+': case '-': case '0' ... '9':
	    ungetch(ch);
	    value = get_int(skip_none);
	    break;
	case '\'':
	    character();
	    value = parser.value.i;
	    break;
	case '$':
	    switch (expression()) {
		case tok_int:
		case tok_pointer:
		    value = parser.value.i;
		    break;
		default:
		    error("expecting immediate");
	    }
	    break;
	case '@':
	    dynamic();
	    value = (jit_word_t)parser.value.p;
	    break;
	default:
	    ungetch(ch);
	    label = get_label(skip_none);
	    if (label->kind == label_kind_data)
		value = (jit_word_t)label->value;
	    else
		error("expecting immediate");
	    break;
    }
    return (value);
}

#define entry(name)							\
static void								\
name(void)								\
{									\
    jit_##name();							\
}
#define entry_ca(name)							\
static void								\
name(void)								\
{									\
    make_arg(jit_##name());						\
}
#define entry_ia(name)							\
static void								\
name(void)								\
{									\
    jit_gpr_t		r0 = get_ireg();				\
    jit_pointer_t	ac = get_arg();					\
    jit_##name(r0, ac);							\
}
#define entry_im(name)							\
static void								\
name(void)								\
{									\
    jit_word_t	 im = get_imm();					\
    jit_##name(im);							\
}
#define entry_ir(name)							\
static void								\
name(void)								\
{									\
    jit_gpr_t	 r0 = get_ireg();					\
    jit_##name(r0);							\
}
#define entry_ima(name)							\
static void								\
name(void)								\
{									\
    jit_word_t		im = get_imm();					\
    jit_pointer_t	ac = get_arg();					\
    jit_##name(im, ac);							\
}
#define entry_ir_ir_ir(name)						\
static void								\
name(void)								\
{									\
    jit_gpr_t	r0 = get_ireg(), r1 = get_ireg(), r2 = get_ireg();	\
    jit_##name(r0, r1, r2);						\
}
#define entry_ir_ir_im(name)						\
static void								\
name(void)								\
{									\
    jit_gpr_t	r0 = get_ireg(), r1 = get_ireg();			\
    jit_word_t	im = get_imm();						\
    jit_##name(r0, r1, im);						\
}
#define entry_ir_ir_ir_ir(name)						\
static void								\
name(void)								\
{									\
    jit_gpr_t	r0 = get_ireg(), r1 = get_ireg(),			\
		r2 = get_ireg(), r3 = get_ireg();			\
    jit_##name(r0, r1, r2, r3);						\
}
#define entry_ir_ir_ir_im(name)						\
static void								\
name(void)								\
{									\
    jit_gpr_t	r0 = get_ireg(), r1 = get_ireg(), r2 = get_ireg();	\
    jit_word_t	im = get_imm();						\
    jit_##name(r0, r1, r2, im);						\
}
#define entry_ir_ir(name)						\
static void								\
name(void)								\
{									\
    jit_gpr_t	r0 = get_ireg(), r1 = get_ireg();			\
    jit_##name(r0, r1);							\
}
#define entry_ir_im(name)						\
static void								\
name(void)								\
{									\
    jit_gpr_t	r0 = get_ireg();					\
    jit_word_t	im = get_imm();						\
    jit_##name(r0, im);							\
}
#define entry_ir_pm(name)						\
static void								\
name(void)								\
{									\
    jit_gpr_t	 r0 = get_ireg();					\
    void	*pm = get_pointer(skip_ws);				\
    jit_##name(r0, pm);							\
}
#define entry_pm_ir(name)						\
static void								\
name(void)								\
{									\
    void	*pm = get_pointer(skip_ws);				\
    jit_gpr_t	 r0 = get_ireg();					\
    jit_##name(pm, r0);							\
}
#define entry_im_ir_ir(name)						\
static void								\
name(void)								\
{									\
    jit_word_t	im = get_imm();						\
    jit_gpr_t	r0 = get_ireg(), r1 = get_ireg();			\
    (void)jit_##name(im, r0, r1);					\
}
#define entry_lb_ir_ir(name)						\
static void								\
name(void)								\
{									\
    jit_node_t	*jmp;							\
    label_t	*label = get_label(skip_ws);				\
    jit_gpr_t	 r0 = get_ireg(), r1 = get_ireg();			\
    if (label->kind == label_kind_code_forward)				\
	jmp_forward((void *)jit_##name(r0, r1), label);			\
    else {								\
	jmp = jit_##name(r0, r1);					\
	jit_patch_at(jmp, (jit_node_t *)label->value);			\
    }									\
}
#define entry_lb_ir_im(name)						\
static void								\
name(void)								\
{									\
    jit_node_t	*jmp;							\
    label_t	*label = get_label(skip_ws);				\
    jit_gpr_t	 r0 = get_ireg();					\
    jit_word_t	 im = get_imm();					\
    if (label->kind == label_kind_code_forward)				\
	jmp_forward((void *)jit_##name(r0, im), label);			\
    else {								\
	jmp = jit_##name(r0, im);					\
	jit_patch_at(jmp, (jit_node_t *)label->value);			\
    }									\
}
#define entry_lb(name)							\
static void								\
name(void)								\
{									\
    jit_node_t	*jmp;							\
    label_t	*label = get_label(skip_ws);				\
    if (label->kind == label_kind_code_forward)				\
	jmp_forward((void *)jit_##name(), label);			\
    else {								\
	jmp = jit_##name();						\
	jit_patch_at(jmp, (jit_node_t *)label->value);			\
    }									\
}
#define entry_pm(name)							\
static void								\
name(void)								\
{									\
    void	*pm = get_pointer(skip_ws);				\
    jit_##name(pm);							\
}
#define entry_fa(name)							\
static void								\
name(void)								\
{									\
    jit_fpr_t		r0 = get_freg();				\
    jit_pointer_t	ac = get_arg();					\
    jit_##name(r0, ac);							\
}
#define entry_fma(name)							\
static void								\
name(void)								\
{									\
    jit_float64_t	im = get_float(skip_ws);			\
    jit_pointer_t	ac = get_arg();					\
    jit_##name(im, ac);							\
}
#define entry_fr_fr_fr(name)						\
static void								\
name(void)								\
{									\
    jit_fpr_t	r0 = get_freg(), r1 = get_freg(), r2 = get_freg();	\
    jit_##name(r0, r1, r2);						\
}
#define entry_fr_fr_fm(name)						\
static void								\
name(void)								\
{									\
    jit_fpr_t		r0 = get_freg(), r1 = get_freg();		\
    jit_float64_t	im = get_float(skip_ws);			\
    jit_##name(r0, r1, make_float(im));					\
}
#define entry_fr_fr_dm(name)						\
static void								\
name(void)								\
{									\
    jit_fpr_t		r0 = get_freg(), r1 = get_freg();		\
    jit_float64_t	im = get_float(skip_ws);			\
    jit_##name(r0, r1, im);						\
}
#define entry_fr_fr(name)						\
static void								\
name(void)								\
{									\
    jit_fpr_t	r0 = get_freg(), r1 = get_freg();			\
    jit_##name(r0, r1);							\
}
#define entry_ir_fr_fr(name)						\
static void								\
name(void)								\
{									\
    jit_gpr_t	r0 = get_ireg();					\
    jit_fpr_t	r1 = get_freg(), r2 = get_freg();			\
    jit_##name(r0, r1, r2);						\
}
#define entry_ir_fr_fm(name)						\
static void								\
name(void)								\
{									\
    jit_gpr_t		r0 = get_ireg();				\
    jit_fpr_t		r1 = get_freg();				\
    jit_float64_t	im = get_float(skip_ws);			\
    jit_##name(r0, r1, make_float(im));					\
}
#define entry_ir_fr_dm(name)						\
static void								\
name(void)								\
{									\
    jit_gpr_t		r0 = get_ireg();				\
    jit_fpr_t		r1 = get_freg();				\
    jit_float64_t	im = get_float(skip_ws);			\
    jit_##name(r0, r1, im);						\
}
#define entry_ir_fr(name)						\
static void								\
name(void)								\
{									\
    jit_gpr_t	r0 = get_ireg();					\
    jit_fpr_t	r1 = get_freg();					\
    jit_##name(r0, r1);							\
}
#define entry_fr_ir(name)						\
static void								\
name(void)								\
{									\
    jit_fpr_t	r0 = get_freg();					\
    jit_gpr_t	r1 = get_ireg();					\
    jit_##name(r0, r1);							\
}
#define entry_fr_fm(name)						\
static void								\
name(void)								\
{									\
    jit_fpr_t		r0 = get_freg();				\
    jit_float64_t	im = get_float(skip_ws);			\
    jit_##name(r0, make_float(im));					\
}
#define entry_fr_dm(name)						\
static void								\
name(void)								\
{									\
    jit_fpr_t		r0 = get_freg();				\
    jit_float64_t	im = get_float(skip_ws);			\
    jit_##name(r0, im);							\
}
#define entry_fr_pm(name)						\
static void								\
name(void)								\
{									\
    jit_fpr_t	 r0 = get_freg();					\
    void	*pm = get_pointer(skip_ws);				\
    jit_##name(r0, pm);							\
}
#define entry_fr_ir_ir(name)						\
static void								\
name(void)								\
{									\
    jit_fpr_t	r0 = get_freg();					\
    jit_gpr_t	r1 = get_ireg(), r2 = get_ireg();			\
    jit_##name(r0, r1, r2);						\
}
#define entry_fr_ir_im(name)						\
static void								\
name(void)								\
{									\
    jit_fpr_t	r0 = get_freg();					\
    jit_gpr_t	r1 = get_ireg();					\
    jit_word_t	im = get_imm();						\
    jit_##name(r0, r1, im);						\
}
#define entry_pm_fr(name)						\
static void								\
name(void)								\
{									\
    void	*pm = get_pointer(skip_ws);				\
    jit_fpr_t	 r0 = get_freg();					\
    jit_##name(pm, r0);							\
}
#define entry_ir_ir_fr(name)						\
static void								\
name(void)								\
{									\
    jit_gpr_t	r0 = get_ireg(), r1 = get_ireg();			\
    jit_fpr_t	r2 = get_freg();					\
    jit_##name(r0, r1, r2);						\
}
#define entry_im_ir_fr(name)						\
static void								\
name(void)								\
{									\
    jit_word_t	im = get_imm();						\
    jit_gpr_t	r0 = get_ireg();					\
    jit_fpr_t	r1 = get_freg();					\
    jit_##name(im, r0, r1);						\
}
#define entry_lb_fr_fr(name)						\
static void								\
name(void)								\
{									\
    jit_node_t	*jmp;							\
    label_t	*label = get_label(skip_ws);				\
    jit_fpr_t	 r0 = get_freg(), r1 = get_freg();			\
    if (label->kind == label_kind_code_forward)				\
	jmp_forward((void *)jit_##name(r0, r1), label);			\
    else {								\
	jmp = jit_##name(r0, r1);					\
	jit_patch_at(jmp, (jit_node_t *)label->value);			\
    }									\
}
#define entry_lb_fr_fm(name)						\
static void								\
name(void)								\
{									\
    jit_node_t		*jmp;						\
    label_t		*label = get_label(skip_ws);			\
    jit_fpr_t		 r0 = get_freg();				\
    jit_float64_t	 im = get_float(skip_ws);			\
    if (label->kind == label_kind_code_forward)				\
	jmp_forward((void *)jit_##name(r0, make_float(im)), label);	\
    else {								\
	jmp = jit_##name(r0, make_float(im));				\
	jit_patch_at(jmp, (jit_node_t *)label->value);			\
    }									\
}
#define entry_lb_fr_dm(name)						\
static void								\
name(void)								\
{									\
    jit_node_t		*jmp;						\
    label_t		*label = get_label(skip_ws);			\
    jit_fpr_t		 r0 = get_freg();				\
    jit_float64_t	 im = get_float(skip_ws);			\
    if (label->kind == label_kind_code_forward)				\
	jmp_forward((void *)jit_##name(r0, im), label);			\
    else {								\
	jmp = jit_##name(r0, im);					\
	jit_patch_at(jmp, (jit_node_t *)label->value);			\
    }									\
}
#define entry_fr(name)							\
static void								\
name(void)								\
{									\
    jit_fpr_t	r0 = get_freg();					\
    jit_##name(r0);							\
}
#define entry_fm(name)							\
static void								\
name(void)								\
{									\
    jit_float64_t	im = get_float(skip_ws);			\
    jit_##name(make_float(im));						\
}
#define entry_dm(name)							\
static void								\
name(void)								\
{									\
    jit_float64_t	im = get_float(skip_ws);			\
    jit_##name(im);							\
}
#define entry_fn(name)							\
static void								\
name(void)								\
{									\
    int		 ch;							\
    label_t	*label;							\
    void	*value;							\
    ch = skipws();							\
    switch (ch) {							\
	case '0' ... '9':						\
	    ungetch(ch);						\
	    value = (void *)(jit_word_t)get_uint(skip_none);		\
	    break;							\
	case '$':							\
	    switch (expression()) {					\
		case tok_int:						\
		    value = (void *)parser.value.i;			\
		    break;						\
		case tok_pointer:					\
		    value = parser.value.p;				\
		    break;						\
		default:						\
		    error("expecting pointer");				\
	    }								\
	    break;							\
	case '@':							\
	    dynamic();							\
	    value = parser.value.p;					\
	    break;							\
	default:							\
	    ungetch(ch);						\
	    label = get_label(skip_none);				\
	    if (label->kind == label_kind_code_forward)			\
		call_forward((void *)jit_##name(NULL), label);		\
	    else							\
		jit_patch_at(jit_##name(NULL), label->value);		\
	    return;							\
    }									\
    jit_##name(value);							\
}
static void
name(void) {
    int		 ch = skipws();
    (void)identifier(ch);
    jit_name(parser.string);
}
static void
live(void) {
    if (primary(skip_ws) != tok_register)
	error("bad register");
    jit_live(parser.regval);
}
entry_im(align)
entry(prolog)
entry_im(frame)			entry_im(tramp)
entry(ellipsis)
void
allocai(void) {
    symbol_t	*symbol;
    jit_word_t	 i, im = get_imm();
    i = jit_allocai(im);
    symbol = get_symbol();
    symbol->type = type_l;
    symbol->value.i = i;
}
entry_ir_ir(allocar)
entry_ca(arg)
entry_ia(getarg_c)		entry_ia(getarg_uc)
entry_ia(getarg_s)		entry_ia(getarg_us)
entry_ia(getarg_i)
#if __WORDSIZE == 64
entry_ia(getarg_ui)		entry_ia(getarg_l)
#endif
entry_ia(getarg)
entry_ia(putargr)		entry_ima(putargi)
entry_ir_ir_ir(addr)		entry_ir_ir_im(addi)
entry_ir_ir_ir(addxr)		entry_ir_ir_im(addxi)
entry_ir_ir_ir(addcr)		entry_ir_ir_im(addci)
entry_ir_ir_ir(subr)		entry_ir_ir_im(subi)
entry_ir_ir_ir(subxr)		entry_ir_ir_im(subxi)
entry_ir_ir_ir(subcr)		entry_ir_ir_im(subci)
entry_ir_ir_ir(rsbr)		entry_ir_ir_im(rsbi)
entry_ir_ir_ir(mulr)		entry_ir_ir_im(muli)
entry_ir_ir_ir_ir(qmulr)	entry_ir_ir_ir_im(qmuli)
entry_ir_ir_ir_ir(qmulr_u)	entry_ir_ir_ir_im(qmuli_u)
entry_ir_ir_ir(divr)		entry_ir_ir_im(divi)
entry_ir_ir_ir(divr_u)		entry_ir_ir_im(divi_u)
entry_ir_ir_ir_ir(qdivr)	entry_ir_ir_ir_im(qdivi)
entry_ir_ir_ir_ir(qdivr_u)	entry_ir_ir_ir_im(qdivi_u)
entry_ir_ir_ir(remr)		entry_ir_ir_im(remi)
entry_ir_ir_ir(remr_u)		entry_ir_ir_im(remi_u)
entry_ir_ir_ir(andr)		entry_ir_ir_im(andi)
entry_ir_ir_ir(orr)		entry_ir_ir_im(ori)
entry_ir_ir_ir(xorr)		entry_ir_ir_im(xori)
entry_ir_ir_ir(lshr)		entry_ir_ir_im(lshi)
entry_ir_ir_ir(rshr)		entry_ir_ir_im(rshi)
entry_ir_ir_ir(rshr_u)		entry_ir_ir_im(rshi_u)
entry_ir_ir(negr)		entry_ir_ir(comr)
entry_ir_ir_ir(ltr)		entry_ir_ir_im(lti)
entry_ir_ir_ir(ltr_u)		entry_ir_ir_im(lti_u)
entry_ir_ir_ir(ler)		entry_ir_ir_im(lei)
entry_ir_ir_ir(ler_u)		entry_ir_ir_im(lei_u)
entry_ir_ir_ir(eqr)		entry_ir_ir_im(eqi)
entry_ir_ir_ir(ger)		entry_ir_ir_im(gei)
entry_ir_ir_ir(ger_u)		entry_ir_ir_im(gei_u)
entry_ir_ir_ir(gtr)		entry_ir_ir_im(gti)
entry_ir_ir_ir(gtr_u)		entry_ir_ir_im(gti_u)
entry_ir_ir_ir(ner)		entry_ir_ir_im(nei)
entry_ir_ir(movr)
static void
movi(void)
{
    int		 ch;
    label_t	*label;
    void	*value;
    jit_gpr_t	 r0 = get_ireg();
    ch = skipws();
    switch (ch) {
	case '+': case '-':
	case '0' ... '9':
	    ungetch(ch);
	    value = (void *)(jit_word_t)get_uint(skip_none);
	    break;
	case '\'':
	    character();
	    value = (void *)parser.value.i;
	    break;
	case '$':
	    switch (expression()) {
		case tok_int:
		    value = (void *)parser.value.i;
		    break;
		case tok_pointer:
		    value = parser.value.p;
		    break;
		default:
		    error("expecting pointer");
	    }
	    break;
	case '@':
	    dynamic();
	    value = parser.value.p;
	    break;
	default:
	    ungetch(ch);
	    label = get_label(skip_none);
	    if (label->kind == label_kind_code ||
		label->kind == label_kind_code_forward) {
		mov_forward((void *)jit_movi(r0, 0), label);
		return;
	    }
	    value = label->value;
	    break;
    }
    jit_movi(r0, (jit_word_t)value);
}
entry_ir_ir(extr_c)		entry_ir_ir(extr_uc)
entry_ir_ir(extr_s)		entry_ir_ir(extr_us)
#if __WORDSIZE == 64
entry_ir_ir(extr_i)		entry_ir_ir(extr_ui)
#endif
entry_ir_ir(htonr_us)		entry_ir_ir(ntohr_us)
entry_ir_ir(htonr_ui)		entry_ir_ir(ntohr_ui)
#if __WORDSIZE == 64
entry_ir_ir(htonr_ul)		entry_ir_ir(ntohr_ul)
#endif
entry_ir_ir(htonr)		entry_ir_ir(ntohr)
entry_ir_ir(ldr_c)		entry_ir_pm(ldi_c)
entry_ir_ir(ldr_uc)		entry_ir_pm(ldi_uc)
entry_ir_ir(ldr_s)		entry_ir_pm(ldi_s)
entry_ir_ir(ldr_us)		entry_ir_pm(ldi_us)
entry_ir_ir(ldr_i)		entry_ir_pm(ldi_i)
#if __WORDSIZE == 64
entry_ir_ir(ldr_ui)		entry_ir_pm(ldi_ui)
entry_ir_ir(ldr_l)		entry_ir_pm(ldi_l)
#endif
entry_ir_ir(ldr)		entry_ir_pm(ldi)
entry_ir_ir_ir(ldxr_c)		entry_ir_ir_im(ldxi_c)
entry_ir_ir_ir(ldxr_uc)		entry_ir_ir_im(ldxi_uc)
entry_ir_ir_ir(ldxr_s)		entry_ir_ir_im(ldxi_s)
entry_ir_ir_ir(ldxr_us)		entry_ir_ir_im(ldxi_us)
entry_ir_ir_ir(ldxr_i)		entry_ir_ir_im(ldxi_i)
#if __WORDSIZE == 64
entry_ir_ir_ir(ldxr_ui)		entry_ir_ir_im(ldxi_ui)
entry_ir_ir_ir(ldxr_l)		entry_ir_ir_im(ldxi_l)
#endif
entry_ir_ir_ir(ldxr)		entry_ir_ir_im(ldxi)
entry_ir_ir(str_c)		entry_pm_ir(sti_c)
entry_ir_ir(str_s)		entry_pm_ir(sti_s)
entry_ir_ir(str_i)		entry_pm_ir(sti_i)
#if __WORDSIZE == 64
entry_ir_ir(str_l)		entry_pm_ir(sti_l)
#endif
entry_ir_ir(str)		entry_pm_ir(sti)
entry_ir_ir_ir(stxr_c)		entry_im_ir_ir(stxi_c)
entry_ir_ir_ir(stxr_s)		entry_im_ir_ir(stxi_s)
entry_ir_ir_ir(stxr_i)		entry_im_ir_ir(stxi_i)
#if __WORDSIZE == 64
entry_ir_ir_ir(stxr_l)		entry_im_ir_ir(stxi_l)
#endif
entry_ir_ir_ir(stxr)		entry_im_ir_ir(stxi)
entry_lb_ir_ir(bltr)		entry_lb_ir_im(blti)
entry_lb_ir_ir(bltr_u)		entry_lb_ir_im(blti_u)
entry_lb_ir_ir(bler)		entry_lb_ir_im(blei)
entry_lb_ir_ir(bler_u)		entry_lb_ir_im(blei_u)
entry_lb_ir_ir(beqr)		entry_lb_ir_im(beqi)
entry_lb_ir_ir(bger)		entry_lb_ir_im(bgei)
entry_lb_ir_ir(bger_u)		entry_lb_ir_im(bgei_u)
entry_lb_ir_ir(bgtr)		entry_lb_ir_im(bgti)
entry_lb_ir_ir(bgtr_u)		entry_lb_ir_im(bgti_u)
entry_lb_ir_ir(bner)		entry_lb_ir_im(bnei)
entry_lb_ir_ir(bmsr)		entry_lb_ir_im(bmsi)
entry_lb_ir_ir(bmcr)		entry_lb_ir_im(bmci)
entry_lb_ir_ir(boaddr)		entry_lb_ir_im(boaddi)
entry_lb_ir_ir(boaddr_u)	entry_lb_ir_im(boaddi_u)
entry_lb_ir_ir(bxaddr)		entry_lb_ir_im(bxaddi)
entry_lb_ir_ir(bxaddr_u)	entry_lb_ir_im(bxaddi_u)
entry_lb_ir_ir(bosubr)		entry_lb_ir_im(bosubi)
entry_lb_ir_ir(bosubr_u)	entry_lb_ir_im(bosubi_u)
entry_lb_ir_ir(bxsubr)		entry_lb_ir_im(bxsubi)
entry_lb_ir_ir(bxsubr_u)	entry_lb_ir_im(bxsubi_u)
entry_ir(jmpr)			entry_lb(jmpi)
entry_ir(callr)			entry_fn(calli)
entry(prepare)
entry_ir(pushargr)		entry_im(pushargi)
entry_ir(finishr)		entry_fn(finishi)
entry(ret)
entry_ir(retr)			entry_im(reti)
entry_ir(retval_c)		entry_ir(retval_uc)
entry_ir(retval_s)		entry_ir(retval_us)
entry_ir(retval_i)
#if __WORDSIZE == 64
entry_ir(retval_ui)		entry_ir(retval_l)
#endif
entry_ir(retval)
entry(epilog)
entry_ca(arg_f)			entry_fa(getarg_f)
entry_fa(putargr_f)		entry_fma(putargi_f)
entry_fr_fr_fr(addr_f)		entry_fr_fr_fm(addi_f)
entry_fr_fr_fr(subr_f)		entry_fr_fr_fm(subi_f)
entry_fr_fr_fr(rsbr_f)		entry_fr_fr_fm(rsbi_f)
entry_fr_fr_fr(mulr_f)		entry_fr_fr_fm(muli_f)
entry_fr_fr_fr(divr_f)		entry_fr_fr_fm(divi_f)
entry_fr_fr(negr_f)		entry_fr_fr(absr_f)
entry_fr_fr(sqrtr_f)
entry_ir_fr_fr(ltr_f)		entry_ir_fr_fm(lti_f)
entry_ir_fr_fr(ler_f)		entry_ir_fr_fm(lei_f)
entry_ir_fr_fr(eqr_f)		entry_ir_fr_fm(eqi_f)
entry_ir_fr_fr(ger_f)		entry_ir_fr_fm(gei_f)
entry_ir_fr_fr(gtr_f)		entry_ir_fr_fm(gti_f)
entry_ir_fr_fr(ner_f)		entry_ir_fr_fm(nei_f)
entry_ir_fr_fr(unltr_f)		entry_ir_fr_fm(unlti_f)
entry_ir_fr_fr(unler_f)		entry_ir_fr_fm(unlei_f)
entry_ir_fr_fr(uneqr_f)		entry_ir_fr_fm(uneqi_f)
entry_ir_fr_fr(unger_f)		entry_ir_fr_fm(ungei_f)
entry_ir_fr_fr(ungtr_f)		entry_ir_fr_fm(ungti_f)
entry_ir_fr_fr(ltgtr_f)		entry_ir_fr_fm(ltgti_f)
entry_ir_fr_fr(ordr_f)		entry_ir_fr_fm(ordi_f)
entry_ir_fr_fr(unordr_f)	entry_ir_fr_fm(unordi_f)
entry_ir_fr(truncr_f_i)
#if __WORDSIZE == 64
entry_ir_fr(truncr_f_l)
#endif
entry_ir_fr(truncr_f)
entry_fr_ir(extr_f)		entry_fr_fr(extr_d_f)
entry_fr_fr(movr_f)		entry_fr_fm(movi_f)
entry_fr_ir(ldr_f)		entry_fr_pm(ldi_f)
entry_fr_ir_ir(ldxr_f)		entry_fr_ir_im(ldxi_f)
entry_ir_fr(str_f)		entry_pm_fr(sti_f)
entry_ir_ir_fr(stxr_f)		entry_im_ir_fr(stxi_f)
entry_lb_fr_fr(bltr_f)		entry_lb_fr_fm(blti_f)
entry_lb_fr_fr(bler_f)		entry_lb_fr_fm(blei_f)
entry_lb_fr_fr(beqr_f)		entry_lb_fr_fm(beqi_f)
entry_lb_fr_fr(bger_f)		entry_lb_fr_fm(bgei_f)
entry_lb_fr_fr(bgtr_f)		entry_lb_fr_fm(bgti_f)
entry_lb_fr_fr(bner_f)		entry_lb_fr_fm(bnei_f)
entry_lb_fr_fr(bunltr_f)	entry_lb_fr_fm(bunlti_f)
entry_lb_fr_fr(bunler_f)	entry_lb_fr_fm(bunlei_f)
entry_lb_fr_fr(buneqr_f)	entry_lb_fr_fm(buneqi_f)
entry_lb_fr_fr(bunger_f)	entry_lb_fr_fm(bungei_f)
entry_lb_fr_fr(bungtr_f)	entry_lb_fr_fm(bungti_f)
entry_lb_fr_fr(bltgtr_f)	entry_lb_fr_fm(bltgti_f)
entry_lb_fr_fr(bordr_f)		entry_lb_fr_fm(bordi_f)
entry_lb_fr_fr(bunordr_f)	entry_lb_fr_fm(bunordi_f)
entry_fr(pushargr_f)		entry_fm(pushargi_f)
entry_fr(retr_f)		entry_fm(reti_f)
entry_fr(retval_f)
entry_ca(arg_d)			entry_fa(getarg_d)
entry_fa(putargr_d)		entry_fma(putargi_d)
entry_fr_fr_fr(addr_d)		entry_fr_fr_dm(addi_d)
entry_fr_fr_fr(subr_d)		entry_fr_fr_dm(subi_d)
entry_fr_fr_fr(rsbr_d)		entry_fr_fr_dm(rsbi_d)
entry_fr_fr_fr(mulr_d)		entry_fr_fr_dm(muli_d)
entry_fr_fr_fr(divr_d)		entry_fr_fr_dm(divi_d)
entry_fr_fr(negr_d)		entry_fr_fr(absr_d)
entry_fr_fr(sqrtr_d)
entry_ir_fr_fr(ltr_d)		entry_ir_fr_dm(lti_d)
entry_ir_fr_fr(ler_d)		entry_ir_fr_dm(lei_d)
entry_ir_fr_fr(eqr_d)		entry_ir_fr_dm(eqi_d)
entry_ir_fr_fr(ger_d)		entry_ir_fr_dm(gei_d)
entry_ir_fr_fr(gtr_d)		entry_ir_fr_dm(gti_d)
entry_ir_fr_fr(ner_d)		entry_ir_fr_dm(nei_d)
entry_ir_fr_fr(unltr_d)		entry_ir_fr_dm(unlti_d)
entry_ir_fr_fr(unler_d)		entry_ir_fr_dm(unlei_d)
entry_ir_fr_fr(uneqr_d)		entry_ir_fr_dm(uneqi_d)
entry_ir_fr_fr(unger_d)		entry_ir_fr_dm(ungei_d)
entry_ir_fr_fr(ungtr_d)		entry_ir_fr_dm(ungti_d)
entry_ir_fr_fr(ltgtr_d)		entry_ir_fr_dm(ltgti_d)
entry_ir_fr_fr(ordr_d)		entry_ir_fr_dm(ordi_d)
entry_ir_fr_fr(unordr_d)	entry_ir_fr_dm(unordi_d)
entry_ir_fr(truncr_d_i)
#if __WORDSIZE == 64
entry_ir_fr(truncr_d_l)
#endif
entry_ir_fr(truncr_d)
entry_fr_ir(extr_d)		entry_fr_fr(extr_f_d)
entry_fr_fr(movr_d)		entry_fr_dm(movi_d)
entry_fr_ir(ldr_d)		entry_fr_pm(ldi_d)
entry_fr_ir_ir(ldxr_d)		entry_fr_ir_im(ldxi_d)
entry_ir_fr(str_d)		entry_pm_fr(sti_d)
entry_ir_ir_fr(stxr_d)		entry_im_ir_fr(stxi_d)
entry_lb_fr_fr(bltr_d)		entry_lb_fr_dm(blti_d)
entry_lb_fr_fr(bler_d)		entry_lb_fr_dm(blei_d)
entry_lb_fr_fr(beqr_d)		entry_lb_fr_dm(beqi_d)
entry_lb_fr_fr(bger_d)		entry_lb_fr_dm(bgei_d)
entry_lb_fr_fr(bgtr_d)		entry_lb_fr_dm(bgti_d)
entry_lb_fr_fr(bner_d)		entry_lb_fr_dm(bnei_d)
entry_lb_fr_fr(bunltr_d)	entry_lb_fr_dm(bunlti_d)
entry_lb_fr_fr(bunler_d)	entry_lb_fr_dm(bunlei_d)
entry_lb_fr_fr(buneqr_d)	entry_lb_fr_dm(buneqi_d)
entry_lb_fr_fr(bunger_d)	entry_lb_fr_dm(bungei_d)
entry_lb_fr_fr(bungtr_d)	entry_lb_fr_dm(bungti_d)
entry_lb_fr_fr(bltgtr_d)	entry_lb_fr_dm(bltgti_d)
entry_lb_fr_fr(bordr_d)		entry_lb_fr_dm(bordi_d)
entry_lb_fr_fr(bunordr_d)	entry_lb_fr_dm(bunordi_d)
entry_fr(pushargr_d)		entry_dm(pushargi_d)
entry_fr(retr_d)		entry_dm(reti_d)
entry_fr(retval_d)
static void
vastart(void)
{
    jit_gpr_t	r0 = get_ireg();
    jit_va_start(r0);
}
static void
vapush(void)
{
    jit_gpr_t	r0 = get_ireg();
    jit_va_push(r0);
}
static void
vaarg(void)
{
    jit_gpr_t	r0 = get_ireg(), r1 = get_ireg();
    jit_va_arg(r0, r1);
}
static void
vaarg_d(void)
{
    jit_fpr_t	r0 = get_freg();
    jit_gpr_t	r1 = get_ireg();
    jit_va_arg_d(r0, r1);
}
static void
vaend(void)
{
    jit_gpr_t	r0 = get_ireg();
    jit_va_end(r0);
}
#undef entry_fn
#undef entry_fm
#undef entry_dm
#undef entry_lb_fr_fm
#undef entry_lb_fr_dm
#undef entry_lb_fr_fr
#undef entry_im_ir_fr
#undef entry_ir_ir_fr
#undef entry_pm_fr
#undef entry_fr_ir_ir
#undef entry_fr_ir_im
#undef entry_fr_pm
#undef entry_fr_fm
#undef entry_fr_dm
#undef entry_fr_ir
#undef entry_ir_fr
#undef entry_ir_fr_fm
#undef entry_ir_fr_dm
#undef entry_ir_fr_fr
#undef entry_fr_fr
#undef entry_fr_fr_fm
#undef entry_fr_fr_dm
#undef entry_fr_fr_fr
#undef entry_fma
#undef entry_fa
#undef entry_pm
#undef entry_lb
#undef entry_lb_ir_im
#undef entry_lb_ir_ir
#undef entry_im_ir_ir
#undef entry_pm_ir
#undef entry_ir_pm
#undef entry_ir_im
#undef entry_ir_ir
#undef entry_ir_ir_im
#undef entry_ir_ir_ir
#undef entry_ima
#undef entry_ir
#undef entry_im
#undef entry_ia
#undef entry_ca
#undef entry

static void
error(const char *format, ...)
{
    va_list	 ap;
    int		 length;
    char	*string;

    va_start(ap, format);
    message("error", format, ap);
    va_end(ap);
    length = parser.data.length - parser.data.offset;
    string = (char *)(parser.data.buffer + parser.data.offset - 1);
    if (length > 77)
	strcpy(string + 74, "...");
    else
	parser.data.buffer[parser.data.length - 1] = '\0';
    fprintf(stderr, "(%s)\n", string);
    exit(-1);
}

static void
warn(const char *format, ...)
{
    va_list	ap;
    va_start(ap, format);
    message("warning", format, ap);
    va_end(ap);
}

static void
message(const char *kind, const char *format, va_list ap)
{
    fprintf(stderr, "%s:%d: %s: ", parser.name,
	    parser.line - parser.newline, kind);
    vfprintf(stderr, format, ap);
    fputc('\n', stderr);
}

static int
getch(void)
{
    int		ch;

    if (parser.data.offset < parser.data.length)
	ch = parser.data.buffer[parser.data.offset++];
    else {
	/* keep first offset for ungetch */
	if ((parser.data.length = fread(parser.data.buffer + 1, 1,
					sizeof(parser.data.buffer) - 1,
					parser.fp) + 1) <= 1) {
	    ch = EOF;
	    parser.data.offset = 1;
	}
	else {
	    ch = parser.data.buffer[1];
	    parser.data.offset = 2;
	}
    }
    if ((parser.newline = ch == '\n'))
	++parser.line;

    return (ch);
}

static int
getch_noeof(void)
{
    int		ch = getch();

    if (ch == EOF)
	error("unexpected end of file");

    return (ch);
}

static int
ungetch(int ch)
{
    if ((parser.newline = ch == '\n'))
	--parser.line;

    if (parser.data.offset)
	parser.data.buffer[--parser.data.offset] = ch;
    else
	/* overwrite */
	parser.data.buffer[0] = ch;

    return (ch);
}

static int
skipws(void)
{
    int		ch;

    for (ch = getch();; ch = getch()) {
	switch (ch) {
	    case '/':
		ch = skipct();
		break;
	    case '#':
		ch = skipcp();
		break;
	}
	switch (ch) {
	    case ' ': case '\f': case '\r': case '\t':
		break;
	    default:
		return (ch);
	}
    }
}

static int
skipnl(void)
{
    int		ch;

    for (ch = getch();; ch = getch()) {
	switch (ch) {
	    case '/':
		ch = skipct();
		break;
	    case '#':
		ch = skipcp();
		break;
	}
	switch (ch) {
	    case ' ': case '\f': case '\n': case '\r': case '\t':
		break;
		/* handle as newline */
	    case ';':
		break;
	    default:
		return (ch);
	}
    }
}

static int
skipct(void)
{
    int		ch;

    ch = getch();
    switch (ch) {
	case '/':
	    for (ch = getch(); ch != '\n' && ch != EOF; ch = getch())
		;
	    return (ch);
	case '*':
	    for (; ch != '/';) {
		while (getch_noeof() != '*')
		    ;
		while ((ch = getch_noeof()) == '*')
		    ;
	    }
	    return (getch());
	default:
	    ungetch(ch);
	    return ('/');
    }
}

static int
skipcp(void)
{
    int		ch;

    for (ch = getch(); ch != '\n' && ch != EOF; ch = getch()) {
	switch (ch) {
	    case '0' ... '9':
		if ((number(ch)) == tok_int)
		    parser.line = parser.value.i - 1;
		break;
	    case '"':
		string();
		if (parser.offset >= (int)sizeof(parser.name)) {
		    strncpy(parser.name, parser.string, sizeof(parser.name));
		    parser.name[sizeof(parser.name) - 1] = '\0';
		}
		else
		    strcpy(parser.name, parser.string);
		break;
	    default:
		break;
	}
    }

    return (ch);
}

static jit_word_t
get_int(skip_t skip)
{
    switch (primary(skip)) {
	case tok_int:
	    break;
	case tok_pointer:
	    parser.type = type_l;
	    parser.value.i = (jit_word_t)parser.value.p;
	    break;
	default:
	    error("expecting integer");
    }

    return (parser.value.i);
}

static jit_uword_t
get_uint(skip_t skip)
{
    switch (primary(skip)) {
	case tok_char:		case tok_int:
	    break;
	case tok_pointer:
	    parser.type = type_l;
	    parser.value.ui = (jit_uword_t)parser.value.p;
	    break;
	default:
	    error("expecting integer");
    }

    return (parser.value.ui);
}

static double
get_float(skip_t skip)
{
    switch (primary(skip)) {
	case tok_char:
	case tok_int:
	    parser.type = type_d;
	    parser.value.d = parser.value.i;
	    break;
	case tok_float:
	    break;
	default:
	    error("expecting float");
    }

    return (parser.value.d);
}

/* Workaround gcc not converting unordered values from double to
 * float (as done in other architectures) on s390 */
static float
make_float(double d)
{
    /* This is an workaround to a bug in Hercules s390 emulator,
     * and at least HP-UX ia64 not have these */
#if defined(HAVE_ISNAN) && defined(HAVE_ISINF)
    if (isnan(d))	return ( 0.0f/0.0f);
    if (isinf(d)) {
	if (d > 0.0)	return ( 1.0f/0.0f);
	else		return (-1.0f/0.0f);
    }
#endif
    return ((float)d);
}

static void *
get_pointer(skip_t skip)
{
    label_t	*label;
    token_t	 token = primary(skip);

    switch (token) {
	case tok_symbol:
	    label = get_label_by_name(parser.string);
	    if (label == NULL)
		error("bad identifier %s", parser.string);
	    switch (label->kind) {
		case label_kind_data:
		case label_kind_code:
		    break;
		case label_kind_code_forward:
		    /* as expression arguments */
		    error("forward references not implemented");
		    break;
		case label_kind_dynamic:
		    break;
	    }
	    parser.type = type_p;
	    return (parser.value.p = label->value);
	case tok_int:
	    parser.type = type_p;
	    return (parser.value.p = (void *)parser.value.ui);
	case tok_pointer:
	    return (parser.value.p);
	default:		error("bad pointer");
    }
}

static label_t *
get_label(skip_t skip)
{
    label_t	*label;
    int		 ch = skipws();

    switch (ch) {
	case '@':
	    (void)dynamic();
	    break;
	case 'a' ... 'z': case 'A' ... 'Z': case '_':
	    (void)identifier(ch);
	    break;
	default:
	    error("expecting label/immediate");
    }
    if ((label = get_label_by_name(parser.string)) == NULL)
	label = new_label(label_kind_code_forward,
			  parser.string, jit_forward());

    return (label);
}

static token_t
regname(void)
{
    jit_word_t	num;
    int		check = 1, ch = getch();

    switch (ch) {
	case 'r':
	    parser.regtype = type_l;
	    switch (ch = getch()) {
		case '0':	parser.regval = JIT_R0;		break;
		case '1':	parser.regval = JIT_R1;		break;
		case '2':	parser.regval = JIT_R2;		break;
		case '(':
		    num = get_int(skip_none);
		    if (num < 0 || num >= JIT_R_NUM)		goto fail;
		    parser.regval = JIT_R(num);
		    if (getch() != ')')				goto fail;
		    check = 0;
		    break;
		default:					goto fail;
	    }
	    break;
	case 'v':
	    parser.regtype = type_l;
	    switch (ch = getch()) {
		case '0':	parser.regval = JIT_V0;		break;
		case '1':	parser.regval = JIT_V1;		break;
		case '2':	parser.regval = JIT_V2;		break;
		default:					goto fail;
		case '(':
		    num = get_int(skip_none);
		    if (num < 0 || num >= JIT_V_NUM)		goto fail;
		    parser.regval = JIT_V(num);
		    if (getch() != ')')				goto fail;
		    check = 0;
		    break;
	    }
	    break;
	case 'f':
	    parser.regtype = type_d;
	    switch (ch = getch()) {
		case '0':	parser.regval = JIT_F0;		break;
		case '1':	parser.regval = JIT_F1;		break;
		case '2':	parser.regval = JIT_F2;		break;
		case '3':	parser.regval = JIT_F3;		break;
		case '4':	parser.regval = JIT_F4;		break;
		case '5':	parser.regval = JIT_F5;		break;
		case 'p':
		    parser.regtype = type_l;	/* oops */
		    parser.regval = JIT_FP;			break;
		case '(':
		    num = get_int(skip_none);
		    if (num < 0 || num >= JIT_F_NUM)		goto fail;
		    parser.regval = JIT_F(num);
		    if (getch() != ')')				goto fail;
		    check = 0;
		    break;
		default:					goto fail;
	    }
	    break;
	default:
	fail:
	    error("bad register");
    }
    if (check) {
	ch = getch();
	if ((ch >= 'a' && ch <= 'z') ||
	    (ch >= 'A' && ch <= 'Z') ||
	    (ch >= '0' && ch <= '9') ||
	    ch == '_')
	    goto fail;
	ungetch(ch);
    }

    return (tok_register);
}

static token_t
identifier(int ch)
{
    parser.string[0] = ch;
    for (parser.offset = 1;;) {
	switch ((ch = getch())) {
	    case 'a' ... 'z': case 'A' ... 'Z': case '0' ... '9' :  case '_':
		if (parser.offset + 1 >= MAX_IDENTIFIER) {
		    parser.string[parser.offset] = '\0';
		    error("bad identifier %s", parser.string);
		}
		parser.string[parser.offset++] = ch;
		break;
	    default:
		parser.string[parser.offset] = '\0';
		ungetch(ch);
		return (tok_symbol);
	}
    }
}

static void
get_data(type_t type)
{
    int		 ch;
    token_t	 token;
    char	*test = data;

    for (;;) {
	switch (type) {
	    case type_c:
		switch (token = primary(skip_ws)) {
		    case tok_char: case tok_int:
			check_data(sizeof(signed char));
			*(signed char *)(data + data_offset) = parser.value.i;
			data_offset += sizeof(char);
			break;
		    case tok_string:
			check_data(parser.offset);
			memcpy(data + data_offset, parser.string,
			       parser.offset);
			data_offset += parser.offset;
			break;
		    case tok_newline:
		    case tok_semicollon:
			if (test == data)	error("syntax error");
			return;
		    default:			error("bad initializer");
		}
		break;
	    case type_s:
		check_data(sizeof(signed short));
		*(signed short *)(data + data_offset) = get_int(skip_ws);
		data_offset += sizeof(short);
		break;
	    case type_i:
		check_data(sizeof(signed int));
		*(signed int *)(data + data_offset) = get_int(skip_ws);
		data_offset += sizeof(int);
		break;
	    case type_l:
		check_data(sizeof(jit_word_t));
		*(jit_word_t *)(data + data_offset) = get_int(skip_ws);
		data_offset += sizeof(jit_word_t);
		break;
	    case type_f:
		check_data(sizeof(float));
		*(float *)(data + data_offset) = get_float(skip_ws);
		data_offset += sizeof(float);
		break;
	    case type_d:
		check_data(sizeof(double));
		*(double *)(data + data_offset) = get_float(skip_ws);
		data_offset += sizeof(double);
		break;
	    case type_p:
		/* FIXME **patch if realloc** */
		check_data(sizeof(void*));
		*(void **)(data + data_offset) = get_pointer(skip_ws);
		data_offset += sizeof(void*);
		break;
	    default:
		abort();
	}
	ch = skipws();
	if (ch == '\n' || ch == ';' || ch == EOF)
	    break;
	ungetch(ch);
    }
}

static void
dot(void)
{
    int		ch;
    size_t	offset, length;

    switch (ch = getch_noeof()) {
	case '$':
	    /* use .$(expression) for non side effects expression */
	    (void)expression();
	    return;
	case 'a' ... 'z': case 'A' ... 'Z': case '_':
	    (void)identifier(ch);
	    break;
	default:
	    ungetch(ch);
	    if (skipws() != '$')
		error("expecting symbol");
	    /* allow spaces before an expression */
	    (void)expression();
	    return;
    }
    if (parser.string[1] == '\0') {
	switch (parser.string[0]) {
	    case 'c':	get_data(type_c);	break;
	    case 's':	get_data(type_s);	break;
	    case 'i':	get_data(type_i);	break;
	    case 'l':	get_data(type_l);	break;
	    case 'f':	get_data(type_f);	break;
	    case 'd':	get_data(type_d);	break;
	    case 'p':	get_data(type_p);	break;
	    default:	error("bad type .%c", parser.string[0]);
	}
    }
    else if (strcmp(parser.string, "data") == 0) {
	if (parser.parsing != PARSING_NONE)
	    error(".data must be specified once and be the first section");
	parser.parsing = PARSING_DATA;
	data_length = get_int(skip_ws);
	data = (char *)xcalloc(1, data_length);
    }
    else if (strcmp(parser.string, "code") == 0) {
	if (parser.parsing != PARSING_NONE &&
	    parser.parsing != PARSING_DATA)
	    error(".code must be specified once only");
	parser.parsing = PARSING_CODE;
    }
    else if (strcmp(parser.string, "align") == 0) {
	length = get_int(skip_ws);
	if (parser.parsing != PARSING_DATA)
	    error(".align must be in .data");
	if (length > 1 && length <= 4096 && !(length & (length - 1))) {
	    offset = data_offset;
	    offset += length - ((offset + length) % length);
	    check_data(offset - data_offset);
	    data_offset = offset;
	}
	else
	    error("bad .align %ld (must be a power of 2, >= 2 && <= 4096)",
		  (jit_word_t)length);
    }
    else if (strcmp(parser.string, "size") == 0) {
	length = get_int(skip_ws);
	if (parser.parsing != PARSING_DATA)
	    error(".size must be in .data");
	check_data(length);
	data_offset += length;
    }
    else if (strcmp(parser.string, "disasm") == 0)
	flag_disasm = 1;
    else
	error("unknown command .%s", parser.string);
}

static token_t
number(int ch)
{
    char	buffer[1024], *endptr;
    int		integer = 1, offset = 0, neg = 0, e = 0, d = 0, base = 10;

    for (;; ch = getch()) {
	switch (ch) {
	    case '-':
		if (offset == 0) {
		    neg = 1;
		    continue;
		}
		if (offset && buffer[offset - 1] != 'e') {
		    ungetch(ch);
		    goto done;
		}
		break;
	    case '+':
		if (offset == 0)
		    continue;
		if (offset && buffer[offset - 1] != 'e') {
		    ungetch(ch);
		    goto done;
		}
		break;
	    case '.':
		if (d)
		    goto fail;
		d = 1;
		base = 10;
		integer = 0;
		break;
	    case '0':
		if (offset == 0 && base == 10) {
		    base = 8;
		    continue;
		}
		break;
	    case 'b':
		if (offset == 0 && base == 8) {
		    base = 2;
		    continue;
		}
		if (base != 16)
		    goto fail;
		break;
	    case '1':
		break;
	    case '2' ... '7':
		if (base < 8)
		    goto fail;
		break;
	    case '8': case '9':
		if (base < 10)
		    goto fail;
		break;
	    case 'x':
		if (offset == 0 && base == 8) {
		    base = 16;
		    continue;
		}
		goto fail;
	    case 'a': case 'c': case 'd': case 'f':
		if (base < 16)
		    goto fail;
		break;
	    case 'e':
		if (e)
		    goto fail;
		if (base != 16) {
		    e = 1;
		    base = 10;
		    integer = 0;
		}
		break;
	    case '_': case 'g' ... 'w': case 'y': case 'z': case 'A' ... 'Z':
	    fail:
		buffer[offset++] = '\0';
		error("bad constant %s", buffer);
	    default:
		ungetch(ch);
		goto done;
	}
	if (offset + 1 >= (int)sizeof(buffer))
	    goto fail;
	buffer[offset++] = ch;
    }
done:
    /* check for literal 0 */
    if (offset == 0 && base == 8)	buffer[offset++] = '0';
    buffer[offset] = '\0';
    if (integer) {
#if _WIN32
#  define STRTOUL	strtoull
#else
#  define STRTOUL	strtoul
#endif
	parser.value.ui = STRTOUL(buffer, &endptr, base);
	parser.type = type_l;
	if (neg)
	    parser.value.i = -parser.value.i;
    }
    else {
	parser.type = type_d;
	parser.value.d = strtod(buffer, &endptr);
	if (neg)
	    parser.value.d = -parser.value.d;
    }
    if (*endptr)
	goto fail;

    return (integer ? tok_int : tok_float);
}

static int
escape(int ch)
{
    switch (ch) {
	case 'a':	ch = '\a';	break;
	case 'b':	ch = '\b';	break;
	case 'f':	ch = '\f';	break;
	case 'n':	ch = '\n';	break;
	case 'r':	ch = '\r';	break;
	case 't':	ch = '\t';	break;
	case 'v':	ch = '\v';	break;
	default:			break;
    }

    return (ch);
}

static token_t
string(void)
{
    int		ch, esc = 0;

    for (parser.offset = 0;;) {
	switch (ch = getch_noeof()) {
	    case '\\':
		if (esc)		goto append;
		esc = 1;
		break;
	    case '"':
		if (!esc) {
		    parser.string[parser.offset++] = '\0';
		    parser.value.p = parser.string;
		    parser.type = type_p;
		    return (tok_string);
		}
		/* FALLTHROUGH */
	    default:
	    append:
		if (esc) {
		    ch = escape(ch);
		    esc = 0;
		}
		if (parser.offset + 1 >= parser.length) {
		    parser.length += 4096;
		    parser.string = (char *)xrealloc(parser.string,
						     parser.length);
		}
		parser.string[parser.offset++] = ch;
		break;
	}
    }
}

static token_t
character(void)
{
    int		ch, esc = 0;

    if ((ch = getch_noeof()) == '\\') {
	esc = 1;
	ch = getch();
    }
    if (getch_noeof() != '\'')
	error("bad single byte char");
    if (esc)
	ch = escape(ch);
    parser.type = type_l;
    parser.value.i = ch & 0xff;

    return (tok_char);
}

static token_t
dynamic(void)
{
    label_t	*label;
    void	*value;
    char	*string;
    (void)identifier('@');
    if ((label = get_label_by_name(parser.string)) == NULL) {
#if __CYGWIN__ ||_WIN32
	/* FIXME kludge to pass varargs test case, otherwise,
	 * will not print/scan float values */
	if (strcmp(parser.string + 1, "sprintf") == 0)
	    value = sprintf;
	else if (strcmp(parser.string + 1, "sscanf") == 0)
	    value = sscanf;
	else
#endif
	{
	    value = dlsym(DL_HANDLE, parser.string + 1);
	    if ((string = dlerror()))
		error("%s", string);
	}
	label = new_label(label_kind_dynamic, parser.string, value);
    }
    parser.type = type_p;
    parser.value.p = label->value;

    return (tok_pointer);
}

static void
expression_prim(void)
{
    int		 ch;
    token_t	 token;
    label_t	*label;
    symbol_t	*symbol;

    if (parser.putback) {
	parser.expr = parser.putback;
	parser.putback = (expr_t)0;
	return;
    }
    switch (ch = skipws()) {
	case '!':
	    if ((ch = getch_noeof()) == '=')	parser.expr = expr_ne;
	    else {
		ungetch(ch);			parser.expr = expr_not;
	    }
	    break;
	case '~':				parser.expr = expr_com;
	    break;
	case '*':
	    if ((ch = getch_noeof()) == '=')	parser.expr = expr_mulset;
	    else {
		ungetch(ch);			parser.expr = expr_mul;
	    }
	    break;
	case '/':
	    if ((ch = getch_noeof()) == '=')	parser.expr = expr_divset;
	    else {
		ungetch(ch);			parser.expr = expr_div;
	    }
	    break;
	case '%':
	    if ((ch = getch_noeof()) == '=')	parser.expr = expr_remset;
	    else {
		ungetch(ch);			parser.expr = expr_rem;
	    }
	    break;
	case '+':
	    switch (ch = getch_noeof()) {
		case '+':			parser.expr = expr_inc;
		    break;
		case '=':			parser.expr = expr_addset;
		    break;
		default:	ungetch(ch);	parser.expr = expr_add;
		    break;
	    }
	    break;
	case '-':
	    switch (ch = getch_noeof()) {
		case '-':			parser.expr = expr_dec;
		    break;
		case '=':			parser.expr = expr_subset;
		    break;
		default:	ungetch(ch);	parser.expr = expr_sub;
		    break;
	    }
	    break;
	case '<':
	    switch (ch = getch_noeof()) {
		case '=':			parser.expr = expr_le;
		    break;
		case '<':			ch = getch_noeof();
		    if (ch == '=')		parser.expr = expr_lshset;
		    else {
			ungetch(ch);		parser.expr = expr_lsh;
		    }
		    break;
		default:	ungetch(ch);	parser.expr = expr_lt;
		    break;
	    }
	    break;
	case '>':
	    switch (ch = getch_noeof()) {
		case '=':			parser.expr = expr_ge;
		    break;
		case '>':			ch = getch_noeof();
		    if (ch == '=')		parser.expr = expr_rshset;
		    else {
			ungetch(ch);		parser.expr = expr_rsh;
		    }
		    break;
		default:	ungetch(ch);	parser.expr = expr_gt;
		    break;
	    }
	    break;
	case '&':
	    switch (ch = getch_noeof()) {
		case '=':			parser.expr = expr_andset;
		    break;
		case '&':			parser.expr = expr_andand;
		    break;
		default:	ungetch(ch);	parser.expr = expr_and;
		    break;
	    }
	    break;
	case '|':
	    switch (ch = getch_noeof()) {
		case '=':			parser.expr = expr_orset;
		    break;
		case '|':			parser.expr = expr_oror;
		    break;
		default:	ungetch(ch);	parser.expr = expr_or;
		    break;
	    }
	    break;
	case '^':
	    if ((ch = getch_noeof()) == '=')	parser.expr = expr_xorset;
	    else {
		ungetch(ch);			parser.expr = expr_xor;
	    }
	    break;
	case '=':
	    if ((ch = getch_noeof()) == '=')	parser.expr = expr_eq;
	    else {
		ungetch(ch);			parser.expr = expr_set;
	    }
	    break;
	case '(':				parser.expr = expr_lparen;
	    break;
	case ')':				parser.expr = expr_rparen;
	    break;
	case '0' ... '9':
	    token = number(ch);
	    parser.expr = token == tok_int ? expr_int : expr_float;
	    break;
	case '@':
	    (void)dynamic();
	    parser.expr = expr_pointer;
	    break;
	case '$':
	    identifier('$');
	    /* no support for nested expressions */
	    if (parser.string[0] == '\0')
		error("syntax error");
	    parser.expr = expr_symbol;
	    if ((symbol = get_symbol_by_name(parser.string)) != NULL) {
		parser.type = symbol->type;
		parser.value = symbol->value;
	    }
	    else
		/* only create symbol on assignment */
		parser.type = type_none;
	    break;
	case 'a' ... 'z': case 'A' ... 'Z': case '_':
	    identifier(ch);
	    if ((label = get_label_by_name(parser.string))) {
		if (label->kind == label_kind_code_forward)
		    error("forward value for %s not supported",
			  parser.string);
		parser.expr = expr_pointer;
		parser.type = type_p;
		parser.value.p = label->value;
	    }
	    else
		error("invalid identifier %s", parser.string);
	    break;
	case '\'':
	    character();
	    parser.expr = expr_int;
	    break;
	case '"':
	    /* not smart enough to put it in data and/or relocate it, etc */
	    error("must declare strings as data");
	default:
	    error("syntax error");
    }
}

static void
expression_inc(int pre)
{
    symbol_t	*symbol;

    if (pre) {
	expression_prim();
	if (parser.expr != expr_symbol)
	    error("syntax error");
    }
    if ((symbol = get_symbol_by_name(parser.string)) == NULL) {
	if (!parser.short_circuit)
	    error("undefined symbol %s", symbol->name);
    }
    if (!parser.short_circuit) {
	parser.type = symbol->type;
	if (!pre)
	    parser.value = symbol->value;
	switch (symbol->type) {
	    case type_l:
		++symbol->value.i;
		break;
	    case type_d:
		/* should really be an error */
		symbol->value.d += 1.0;
		break;
	    default:
		++parser.value.cp;
		break;
	}
	if (pre)
	    parser.value = symbol->value;
    }
    expression_prim();
}

static void
expression_dec(int pre)
{
    symbol_t	*symbol;

    if (pre) {
	expression_prim();
	if (parser.expr != expr_symbol)
	    error("syntax error");
    }
    if ((symbol = get_symbol_by_name(parser.string)) == NULL) {
	if (!parser.short_circuit)
	    error("undefined symbol %s", symbol->name);
    }
    if (!parser.short_circuit) {
	parser.type = symbol->type;
	if (!pre)
	    parser.value = symbol->value;
	switch (symbol->type) {
	    case type_l:
		--symbol->value.i;
		break;
	    case type_d:
		/* should really be an error */
		symbol->value.d -= 1.0;
		break;
	    default:
		--parser.value.cp;
		break;
	}
	if (pre)
	    parser.value = symbol->value;
    }
    expression_prim();
}

static void
expression_unary(void)
{
    symbol_t	*symbol;
    char	 buffer[256];

    expression_prim();
    switch (parser.expr) {
	case expr_add:
	    expression_unary();
	    switch (parser.type) {
		case type_l:
		case type_d:
		    break;
		default:
		    error("syntax error");
	    }
	    break;
	case expr_sub:
	    expression_unary();
	    switch (parser.type) {
		case type_l:
		    parser.value.i = -parser.value.i;
		    break;
		case type_d:
		    parser.value.d = -parser.value.d;
		    break;
		default:
		    error("syntax error");
	    }
	    break;
	case expr_inc:
	    expression_inc(1);
	    break;
	case expr_dec:
	    expression_dec(1);
	    break;
	case expr_not:
	    expression_unary();
	    switch (parser.type) {
		case type_l:
		    parser.value.i = !parser.value.i;
		    break;
		case type_d:
		    parser.value.i = parser.value.d != 0;
		    break;
		case type_p:
		    parser.value.i = parser.value.p != NULL;
		    break;
		default:
		    error("syntax error");
	    }
	    parser.type = type_l;
	    break;
	case expr_com:
	    expression_unary();
	    if (parser.type != type_l)
		error("syntax error");
	    parser.value.i = ~parser.value.i;
	    break;
	case expr_lparen:
	    expression_cond();
	    if (parser.expr != expr_rparen)
		error("syntax error");
	    expression_prim();
	    break;
	case expr_symbol:
	    strcpy(buffer, parser.string);
	    expression_prim();
	    switch (parser.expr) {
		case expr_set:
		    if ((symbol = get_symbol_by_name(buffer)) == NULL) {
			if (!parser.short_circuit)
			    symbol = new_symbol(buffer);
		    }
		    expression_cond();
		set:
		    if (!parser.short_circuit) {
			if (symbol == NULL)
			    error("syntax error");
			symbol->type = parser.type;
			symbol->value = parser.value;
		    }
		    break;
		case expr_mulset:		parser.putback = expr_mul;
		    goto check;
		case expr_divset:		parser.putback = expr_div;
		    goto check;
		case expr_remset:		parser.putback = expr_rem;
		    goto check;
		case expr_addset:		parser.putback = expr_add;
		    goto check;
		case expr_subset:		parser.putback = expr_sub;
		    goto check;
		case expr_lshset:		parser.putback = expr_lsh;
		    goto check;
		case expr_rshset:		parser.putback = expr_rsh;
		    goto check;
		case expr_andset:		parser.putback = expr_and;
		    goto check;
		case expr_orset:		parser.putback = expr_or;
		    goto check;
		case expr_xorset:		parser.putback = expr_xor;
		check:
		    if ((symbol = get_symbol_by_name(buffer)) == NULL) {
			if (!parser.short_circuit)
			    error("undefined symbol %s", buffer);
			parser.type = type_l;
			parser.value.i = 1;
		    }
		    switch (parser.putback) {
			case expr_mul:	case expr_div:	case expr_rem:
			    expression_mul();
			    break;
			case expr_add:	case expr_sub:
			    expression_add();
			    break;
			case expr_lsh:	case expr_rsh:
			    expression_shift();
			    break;
			case expr_and:	case expr_or:  case expr_xor:
			    expression_bit();
			    break;
			default:
			    abort();
		    }
		    goto set;
		case expr_inc:
		    expression_inc(0);
		    break;
		case expr_dec:
		    expression_dec(0);
		    break;
		default:
		    break;
	    }
	    break;
	case expr_int:
	case expr_float:
	case expr_pointer:
	    /* make next token available */
	    expression_prim();
	default:
	    break;
    }
}

static void
expression_mul(void)
{
    type_t	type;
    value_t	value;

    expression_unary();
    switch (parser.type) {
	case type_l:	case type_d:	case type_p:	break;
	default:					return;
    }
    for (;;) {
	switch (parser.expr) {
	    case expr_mul:
		type = parser.type, value = parser.value;
		expression_unary();
		switch (parser.type) {
		    case type_l:
			if (type == type_l)
			    value.i *= parser.value.i;
			else
			    value.d *= parser.value.i;
			break;
		    case type_d:
			if (type == type_l) {
			    type = type_d;
			    value.d = value.i;
			}
			value.d *= parser.value.d;
			break;
		    default:
			error("invalid operand");
		}
		parser.type = type, parser.value = value;
		break;
	    case expr_div:
		type = parser.type, value = parser.value;
		expression_unary();
		switch (parser.type) {
		    case type_l:
			if (type == type_l) {
			    if (parser.value.i == 0)
				error("divide by zero");
			    value.i /= parser.value.i;
			}
			else
			    value.d /= parser.value.i;
			break;
		    case type_d:
			if (type == type_l) {
			    type = type_d;
			    value.d = value.i;
			}
			value.d /= parser.value.d;
			break;
		    default:
			error("invalid operand");
		}
		parser.type = type, parser.value = value;
		break;
	    case expr_rem:
		type = parser.type, value = parser.value;
		expression_unary();
		switch (parser.type) {
		    case type_l:
			if (type == type_l) {
			    if (parser.value.i == 0)
				error("divide by zero");
			    value.i %= parser.value.i;
			}
			else
			    error("invalid operand");
			break;
		    default:
			error("invalid operand");
		}
		parser.type = type, parser.value = value;
		break;
	    default:
		return;
	}
    }
}

static void
expression_add(void)
{
    type_t	type;
    value_t	value;

    expression_mul();
    switch (parser.type) {
	case type_l:	case type_d:	case type_p:	break;
	default:					return;
    }
    for (;;) {
	switch (parser.expr) {
	    case expr_add:
		type = parser.type, value = parser.value;
		expression_mul();
		switch (parser.type) {
		    case type_l:
			switch (type) {
			    case type_l:
				value.i += parser.value.i;
				break;
			    case type_d:
				value.d += parser.value.i;
				break;
			    default:
				value.cp += parser.value.i;
				break;
			}
			break;
		    case type_d:
			switch (type) {
			    case type_l:
				type = type_d;
				value.d = value.i;
				break;
			    case type_d:
				break;
			    default:
				error("invalid operand");
			}
			value.d += parser.value.d;
			break;
		    case type_p:
			switch (type) {
			    case type_l:
				type = type_p;
				value.cp = value.i + parser.value.cp;
				break;
			    default:
				error("invalid operand");
			}
			break;
		    default:
			error("invalid operand");
		}
		parser.type = type, parser.value = value;
		break;
	    case expr_sub:
		type = parser.type, value = parser.value;
		expression_mul();
		switch (parser.type) {
		    case type_l:
			switch (type) {
			    case type_l:
				value.i -= parser.value.i;
				break;
			    case type_d:
				value.d -= parser.value.i;
				break;
			    default:
				value.cp -= parser.value.i;
				break;
			}
			break;
		    case type_d:
			switch (type) {
			    case type_l:
				type = type_d;
				value.d = value.i;
				break;
			    case type_d:
				break;
			    default:
				error("invalid operand");
			}
			value.d -= parser.value.d;
			break;
		    case type_p:
			switch (type) {
			    case type_p:
				type = type_l;
				value.i = value.cp - parser.value.cp;
				break;
			    default:
				error("invalid operand");
			}
			break;
		    default:
			error("invalid operand");
		}
		parser.type = type, parser.value = value;
		break;
	    default:
		return;
	}
    }
}

static void
expression_shift(void)
{
    jit_word_t	value;
    expression_add();

    switch (parser.type) {
	case type_l:	case type_d:	case type_p:	break;
	default:					return;
    }
    for (;;) {
	switch (parser.expr) {
	    case expr_lsh:
		value = parser.value.i;
		if (parser.type != type_l)
		    error("invalid operand");
		expression_add();
		if (parser.type != type_l)
		    error("invalid operand");
		value <<= parser.value.i;
		parser.value.i = value;
		break;
	    case expr_rsh:
		value = parser.value.i;
		if (parser.type != type_l)
		    error("invalid operand");
		expression_add();
		if (parser.type != type_l)
		    error("invalid operand");
		value >>= parser.value.i;
		parser.value.i = value;
		break;
	    default:
		return;
	}
    }
}

static void
expression_bit(void)
{
    jit_word_t	i;

    expression_shift();
    switch (parser.type) {
	case type_l:	case type_d:	case type_p:	break;
	default:					return;
    }
    for (;;) {
	switch (parser.expr) {
	    case expr_and:
		if (parser.type != type_l)
		    error("invalid operand");
		i = parser.value.i;
		expression_shift();
		if (parser.type != type_l)
		    error("invalid operand");
		i &= parser.value.i;
		parser.value.i = i;
		break;
	    case expr_or:
		if (parser.type != type_l)
		    error("invalid operand");
		i = parser.value.i;
		expression_shift();
		if (parser.type != type_l)
		    error("invalid operand");
		i |= parser.value.i;
		parser.value.i = i;
		break;
	    case expr_xor:
		if (parser.type != type_l)
		    error("invalid operand");
		i = parser.value.i;
		expression_shift();
		if (parser.type != type_l)
		    error("invalid operand");
		i ^= parser.value.i;
		parser.value.i = i;
		break;
	    default:
		return;
	}
    }
}

static void
expression_rel(void)
{
    type_t	type;
    value_t	value;

    expression_bit();
    switch (parser.type) {
	case type_l:	case type_d:	case type_p:	break;
	default:					return;
    }
    for (;;) {
	switch (parser.expr) {
	    case expr_lt:
		type = parser.type, value = parser.value;
		expression_bit();
		switch (parser.type) {
		    case type_l:
			switch (type) {
			    case type_l:
				value.i = value.i < parser.value.i;
				break;
			    case type_d:
				value.i = value.d < parser.value.i;
				break;
			    default:
				value.i = (jit_word_t)value.p < parser.value.i;
				break;
			}
			break;
		    case type_d:
			switch (type) {
			    case type_l:
				value.i = value.i < parser.value.d;
				break;
			    case type_d:
				value.i = value.d < parser.value.d;
				break;
			    default:
				error("invalid operand");
			}
			break;
		    case type_p:
			switch (type) {
			    case type_l:
				value.i = value.i < (jit_word_t)parser.value.p;
				break;
			    case type_d:
				error("invalid operand");
			    default:
				value.i = (jit_word_t)value.p < (jit_word_t)parser.value.p;
				break;
			}
			break;
		    default:
			error("invalid operand");
		}
		parser.type = type_l, parser.value = value;
		break;
	    case expr_le:
		type = parser.type, value = parser.value;
		expression_bit();
		switch (parser.type) {
		    case type_l:
			switch (type) {
			    case type_l:
				value.i = value.i <= parser.value.i;
				break;
			    case type_d:
				value.i = value.d <= parser.value.i;
				break;
			    default:
				value.i = (jit_word_t)value.p <= parser.value.i;
				break;
			}
			break;
		    case type_d:
			switch (type) {
			    case type_l:
				value.i = value.i <= parser.value.d;
				break;
			    case type_d:
				value.i = value.d <= parser.value.d;
				break;
			    default:
				value.i = (jit_word_t)value.p <= parser.value.d;
				break;
			}
			break;
		    case type_p:
			switch (type) {
			    case type_l:
				value.i = value.i <= (jit_word_t)parser.value.p;
				break;
			    case type_d:
				error("invalid operand");
			    default:
				value.i = (jit_word_t)value.p <= (jit_word_t)parser.value.p;
				break;
			}
			break;
		    default:
			error("invalid operand");
		}
		parser.type = type_l, parser.value = value;
		break;
	    case expr_eq:
		type = parser.type, value = parser.value;
		expression_bit();
		switch (parser.type) {
		    case type_l:
			switch (type) {
			    case type_l:
				value.i = value.i == parser.value.i;
				break;
			    case type_d:
				value.i = value.d == parser.value.i;
				break;
			    default:
				value.i = (jit_word_t)value.p == parser.value.i;
				break;
			}
			break;
		    case type_d:
			switch (type) {
			    case type_l:
				value.i = value.i == parser.value.d;
				break;
			    case type_d:
				value.i = value.d == parser.value.d;
				break;
			    default:
				error("invalid operand");
			}
			break;
		    case type_p:
			switch (type) {
			    case type_l:
				value.i = value.i == (jit_word_t)parser.value.p;
				break;
			    case type_d:
				error("invalid operand");
			    default:
				value.i = value.p == parser.value.p;
				break;
			}
			break;
		    default:
			error("invalid operand");
		}
		parser.type = type_l, parser.value = value;
		break;
	    case expr_ge:
		type = parser.type, value = parser.value;
		expression_bit();
		switch (parser.type) {
		    case type_l:
			switch (type) {
			    case type_l:
				value.i = value.i >= parser.value.i;
				break;
			    case type_d:
				value.i = value.d >= parser.value.i;
				break;
			    default:
				value.i = (jit_word_t)value.p >= parser.value.i;
				break;
			}
			break;
		    case type_d:
			switch (type) {
			    case type_l:
				value.i = value.i >= parser.value.d;
				break;
			    case type_d:
				value.i = value.d >= parser.value.d;
				break;
			    default:
				error("invalid operand");
			}
			break;
		    case type_p:
			switch (type) {
			    case type_l:
				value.i = value.i >= (jit_word_t)parser.value.p;
				break;
			    case type_d:
				error("invalid operand");
			    default:
				value.i = (jit_word_t)value.p >= (jit_word_t)parser.value.p;
				break;
			}
			break;
		    default:
			error("invalid operand");
		}
		parser.type = type_l, parser.value = value;
		break;
	    case expr_gt:
		type = parser.type, value = parser.value;
		expression_bit();
		switch (parser.type) {
		    case type_l:
			switch (type) {
			    case type_l:
				value.i = value.i > parser.value.i;
				break;
			    case type_d:
				value.i = value.d > parser.value.i;
				break;
			    default:
				value.i = (jit_word_t)value.p > parser.value.i;
				break;
			}
			break;
		    case type_d:
			switch (type) {
			    case type_l:
				value.i = value.i > parser.value.d;
				break;
			    case type_d:
				value.i = value.d > parser.value.d;
				break;
			    default:
				error("invalid operand");
			}
			break;
		    case type_p:
			switch (type) {
			    case type_l:
				value.i = value.i > (jit_word_t)parser.value.p;
				break;
			    case type_d:
				error("invalid operand");
			    default:
				value.i = (jit_word_t)value.p > (jit_word_t)parser.value.p;
				break;
			}
			break;
		    default:
			error("invalid operand");
		}
		parser.type = type_l, parser.value = value;
		break;
	    case expr_ne:
		type = parser.type, value = parser.value;
		expression_bit();
		switch (parser.type) {
		    case type_l:
			switch (type) {
			    case type_l:
				value.i = value.i != parser.value.i;
				break;
			    case type_d:
				value.i = value.d != parser.value.i;
				break;
			    default:
				value.i = (jit_word_t)value.p != parser.value.i;
				break;
			}
			break;
		    case type_d:
			switch (type) {
			    case type_l:
				value.i = value.i != parser.value.d;
				break;
			    case type_d:
				value.i = value.d != parser.value.d;
				break;
			    default:
				error("invalid operand");
			}
			break;
		    case type_p:
			switch (type) {
			    case type_l:
				value.i = value.i != (jit_word_t)parser.value.p;
				break;
			    case type_d:
				error("invalid operand");
			    default:
				value.i = value.p != parser.value.p;
				break;
			}
			break;
		    default:
			error("invalid operand");
		}
		parser.type = type_l, parser.value = value;
		break;
	    default:
		return;
	}
    }
}

static void
expression_cond(void)
{
    type_t	type;
    value_t	value;
    int		short_circuit;

    expression_rel();
    switch (parser.type) {
	case type_l:	case type_d:	case type_p:	break;
	default:					return;
    }
    for (;;) {
	switch (parser.expr) {
	    case expr_andand:
		type = parser.type, value = parser.value;
		switch (type) {
		    case type_l:
			short_circuit = value.i == 0;
			break;
		    case type_d:
			short_circuit = value.d == 0.0;
			break;
		    default:
			short_circuit = value.p == NULL;
			break;
		}
		parser.short_circuit += short_circuit;
		expression_rel();
		parser.short_circuit -= short_circuit;
		switch (parser.type) {
		    case type_l:
			switch (type) {
			    case type_l:
				value.i = value.i && parser.value.i;
				break;
			    case type_d:
				value.i = value.d && parser.value.i;
				break;
			    default:
				value.i = value.p && parser.value.i;
				break;
			}
			break;
		    case type_d:
			switch (type) {
			    case type_l:
				value.i = value.i && parser.value.d;
				break;
			    case type_d:
				value.i = value.d && parser.value.d;
				break;
			    default:
				value.i = value.p && parser.value.d;
				break;
			}
			break;
		    case type_p:
			switch (type) {
			    case type_l:
				value.i = value.i && parser.value.p;
				break;
			    case type_d:
				value.i = value.d && parser.value.p;
				break;
			    default:
				value.i = value.p && parser.value.p;
				break;
			}
			break;
		    default:
			error("invalid operand");
		}
		parser.type = type_l, parser.value.i = value.i;
		break;
	    case expr_oror:
		type = parser.type, value = parser.value;
		switch (type) {
		    case type_l:
			short_circuit = value.i != 0;
			break;
		    case type_d:
			short_circuit = value.d != 0.0;
			break;
		    default:
			short_circuit = value.p != NULL;
			break;
		}
		parser.short_circuit += short_circuit;
		expression_rel();
		parser.short_circuit -= short_circuit;
		switch (parser.type) {
		    case type_l:
			switch (type) {
			    case type_l:
				value.i = value.i || parser.value.i;
				break;
			    case type_d:
				value.i = value.d || parser.value.i;
				break;
			    default:
				value.i = value.p || parser.value.i;
				break;
			}
			break;
		    case type_d:
			switch (type) {
			    case type_l:
				value.i = value.i || parser.value.d;
				break;
			    case type_d:
				value.i = value.d || parser.value.d;
				break;
			    default:
				value.i = value.p || parser.value.d;
				break;
			}
			break;
		    case type_p:
			switch (type) {
			    case type_l:
				value.i = value.i || parser.value.p;
				break;
			    case type_d:
				value.i = value.d || parser.value.p;
				break;
			    default:
				value.i = value.p || parser.value.p;
				break;
			}
			break;
		    default:
			error("invalid operand");
		}
		parser.type = type_l, parser.value.i = value.i;
		break;
	    default:
		return;
	}
    }
}

static token_t
expression(void)
{
    symbol_t	*symbol;

    (void)identifier('$');
    if (parser.string[1] == '\0') {
	if (getch_noeof() != '(')
	    error("bad symbol or expression");
	parser.type = type_none;
	expression_cond();
	if (parser.expr != expr_rparen)
	    error("bad expression");
	switch (parser.type) {
	    case type_l:
		return (tok_int);
	    case type_d:
		return (tok_float);
	    case type_p:
		return (tok_pointer);
	    default:
		error("bad expression");
	}
    }
    else if ((symbol = get_symbol_by_name(parser.string))) {
	switch (parser.type = symbol->type) {
	    case type_l:
		parser.value.i = symbol->value.i;
		return (tok_int);
	    case type_d:
		parser.value.d = symbol->value.d;
		return (tok_float);
	    default:
		parser.value.p = symbol->value.p;
		return (tok_pointer);
	}
    }
    else
	error("undefined symbol %s", parser.string);
}

static token_t
primary(skip_t skip)
{
    int		ch;

    switch (skip) {
	case skip_none:	ch = getch();	break;
	case skip_ws:	ch = skipws();	break;
	case skip_nl:	ch = skipnl();	break;
	default:			abort();
    }
    switch (ch) {
	case '%':
	    return (regname());
	case 'a' ... 'z': case 'A' ... 'Z': case '_':
	    return (identifier(ch));
	case '0' ... '9': case '+': case '-':
	    return (number(ch));
	case '.':
	    return (tok_dot);
	case '"':
	    return (string());
	case '\'':
	    return (character());
	case '@':
	    return (dynamic());
	case '$':
	    return (expression());
	case EOF:
	    return (tok_eof);
	case '\n':
	    return (tok_newline);
	case ';':
	    return (tok_semicollon);
	default:
	    error("syntax error");
    }
}

static void
parse(void)
{
    int		 ch;
    token_t	 token;
    instr_t	*instr;
    label_t	*label;
    void	*value;

    for (;;) {
	switch (token = primary(skip_nl)) {
	    case tok_symbol:
		ch = getch_noeof();
		if (ch == ':') {
		    if ((label = get_label_by_name(parser.string))) {
			if (label->kind == label_kind_code_forward) {
			    label->kind = label_kind_code;
			    jit_link(label->value);
			    jit_note(parser.name, parser.line);
			}
			else
			    error("label %s: redefined", parser.string);
		    }
		    else {
			if (parser.parsing == PARSING_DATA) {
			    value = data + data_offset;
			    label = new_label(label_kind_data,
					      parser.string, value);
			}
			else if (parser.parsing == PARSING_CODE) {
			    value = jit_label();
			    jit_note(parser.name, parser.line);
			    label = new_label(label_kind_code,
					      parser.string, value);
			}
			else
			    error("label not in .code or .data");
		    }
		    break;
		}
		ungetch(ch);
		if ((instr =
		     (instr_t *)get_hash(instrs, parser.string)) == NULL)
		    error("unhandled symbol %s", parser.string);
		if (parser.parsing != PARSING_CODE)
		    error(".code must be specified before instructions");
		(*instr->function)();
		break;
	    case tok_dot:
		dot();
		break;
	    case tok_eof:
		return;
	    default:
		error("syntax error");
	}
    }
}

static int
execute(int argc, char *argv[])
{
    int		 result;
    label_t	*label;
    function_t	 function;
    patch_t	*patch, *next;

    for (patch = patches; patch; patch = next) {
	next = patch->next;
	label = patch->label;
	if (label->kind == label_kind_code_forward)
	    error("undefined label %s", label->name);
	switch (patch->kind) {
	    case patch_kind_jmp:
	    case patch_kind_mov:
	    case patch_kind_call:
		jit_patch_at(patch->value, label->value);
		break;
	    default:
		abort();
	}
	free(patch);
	patch = next;
    }

    if (flag_data == 0) {
	jit_realize();
	jit_set_data(NULL, 0, JIT_DISABLE_DATA | JIT_DISABLE_NOTE);
    }

    function = jit_emit();
    if (flag_verbose > 1 || flag_disasm) {
	jit_print();
	fprintf(stdout, "  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n");
    }
    if (flag_verbose > 0 || flag_disasm) {
	jit_disassemble();
	fprintf(stdout, "  - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n");
    }

    jit_clear_state();
    if (flag_disasm)
	result = 0;
    else
	result = (*function)(argc, argv);
    jit_destroy_state();

    return (result);
}

static void *
xmalloc(size_t size)
{
    void	*pointer = malloc(size);

    if (pointer == NULL)
	error("out of memory");

    return (pointer);
}

static void *
xrealloc(void *pointer, size_t size)
{
    pointer = realloc(pointer, size);

    if (pointer == NULL)
	error("out of memory");

    return (pointer);
}

static void *
xcalloc(size_t nmemb, size_t size)
{
    void	*pointer = calloc(nmemb, size);

    if (pointer == NULL)
	error("out of memory");

    return (pointer);
}

static label_t *
new_label(label_kind_t kind, char *name, void *value)
{
    label_t	*label;

    label = (label_t *)xmalloc(sizeof(label_t));
    label->kind = kind;
    label->name = strdup(name);
    label->value = value;
    put_hash(labels, (entry_t *)label);
    label_offset++;
    return (label);
}

static patch_t *
new_patch(patch_kind_t kind, label_t *label, void *value)
{
    patch_t	*patch = (patch_t *)xmalloc(sizeof(patch_t));
    patch->kind = kind;
    patch->label = label;
    patch->value = value;
    patch->next = patches;
    patches = patch;

    return (patch);
}

static int
bcmp_symbols(const void *left, const void *right)
{
    return (strcmp((char *)left, (*(symbol_t **)right)->name));
}

static int
qcmp_symbols(const void *left, const void *right)
{
    return (strcmp((*(symbol_t **)left)->name, (*(symbol_t **)right)->name));
}

static symbol_t *
new_symbol(char *name)
{
    symbol_t	*symbol;

    if ((symbol_offset & 15) == 0) {
	if ((symbol_length += 16) == 16)
	    symbols = (symbol_t **)xmalloc(sizeof(symbol_t *) *
					   symbol_length);
	else
	    symbols = (symbol_t **)xrealloc(symbols, sizeof(symbol_t *) *
					    symbol_length);
    }
    symbol = (symbol_t *)xmalloc(sizeof(symbol_t));
    symbol->name = strdup(name);
    symbols[symbol_offset++] = symbol;
    qsort(symbols, symbol_offset, sizeof(symbol_t *), qcmp_symbols);

    return (symbol);
}

static symbol_t *
get_symbol_by_name(char *name)
{
    symbol_t	**symbol_pointer;

    if (symbols == NULL)
	return (NULL);
    symbol_pointer = (symbol_t **)bsearch(name, symbols, symbol_offset,
					  sizeof(symbol_t *), bcmp_symbols);

    return (symbol_pointer ? *symbol_pointer : NULL);
}

static hash_t *
new_hash(void)
{
    hash_t	*hash;

    hash = (hash_t *)xmalloc(sizeof(hash_t));
    hash->count = 0;
    hash->entries = (entry_t **)xcalloc(hash->size = 32, sizeof(void *));

    return (hash);
}

static int
hash_string(char *name)
{
    char	*ptr;
    int		 key;

    for (key = 0, ptr = name; *ptr; ptr++)
	key = (key << (key & 1)) ^ *ptr;

    return (key);
}

static void
put_hash(hash_t *hash, entry_t *entry)
{
    entry_t	*prev, *ptr;
    int		 key = hash_string(entry->name) & (hash->size - 1);

    for (prev = ptr = hash->entries[key]; ptr; prev = ptr, ptr = ptr->next) {
	if (strcmp(entry->name, ptr->name) == 0)
	    error("duplicated entry %s", entry->name);
    }
    if (prev == NULL)
	hash->entries[key] = entry;
    else
	prev->next = entry;
    entry->next = NULL;
    ++hash->count;
    if (hash->count > hash->size * 0.75)
	rehash(hash);
}

static entry_t *
get_hash(hash_t *hash, char *name)
{
    entry_t	*entry;
    int		 key = hash_string(name) & (hash->size - 1);

    for (entry = hash->entries[key]; entry; entry = entry->next) {
	if (strcmp(entry->name, name) == 0)
	    return (entry);
    }
    return (NULL);
}

static void
rehash(hash_t *hash)
{
    int		 i, size, key;
    entry_t	*entry, *next, **entries;

    entries = (entry_t **)xcalloc(size = hash->size * 2, sizeof(void *));
    for (i = 0; i < hash->size; i++) {
	for (entry = hash->entries[i]; entry; entry = next) {
	    next = entry->next;
	    key = hash_string(entry->name) & (size - 1);
	    entry->next = entries[key];
	    entries[key] = entry;
	}
    }
    free(hash->entries);
    hash->entries = entries;
    hash->size = size;
}

static void
usage(void)
{
#if HAVE_GETOPT_LONG_ONLY
    fprintf(stderr, "\
Usage: %s [jit assembler options] file [jit program options]\n\
Jit assembler options:\n\
  -help                    Display this information\n\
  -v[0-3]                  Verbose output level\n\
  -d                       Do not use a data buffer\n\
  -D<macro>[=<val>]        Preprocessor options\n"
#  if defined(__i386__) && __WORDSIZE == 32
"  -mx87=1                  Force using x87 when sse2 available\n"
#  endif
#  if defined(__i386__) || defined(__x86_64__)
"  -msse4_1=0               Do not use sse4_1 instructions when available\n"
#  endif
#  if defined(__arm__)
"  -mcpu=<val>              Force cpu version (4, 5, 6 or 7)\n\
  -mthumb[=0|1]            Enable or disable thumb\n\
  -mvfp=<val>              Set vpf version (0 to disable)\n\
  -mneon[=0|1]             Enable or disable neon\n"
#  endif
	    , progname);
#else
    fprintf(stderr, "\
Usage: %s [jit assembler options] file [jit program options]\n\
Jit assembler options:\n\
  -h                       Display this information\n\
  -v                       Verbose output level\n\
  -D<macro>[=<val>]        Preprocessor options\n", progname);
#endif
    finish_jit();
    exit(1);
}

int
main(int argc, char *argv[])
{
#if HAVE_GETOPT_LONG_ONLY
    static const char	*short_options = "dv::";
    static struct option long_options[] = {
	{ "help",		0, 0, 'h' },
	{ "data",		2, 0, 'd' },
#  if defined(__i386__) && __WORDSIZE == 32
	{ "mx87",		2, 0, '7' },
#  endif
#  if defined(__i386__) || defined(__x86_64__)
	{ "msse4_1",		2, 0, '4' },
#  endif
#  if defined(__arm__)
	{ "mcpu",		2, 0, 'c' },
	{ "mthumb",		2, 0, 't' },
	{ "mvfp",		2, 0, 'f' },
	{ "mneon",		2, 0, 'n' },
#  endif
	{ 0,			0, 0, 0   }
    };
#else
#endif	/* HAVE_GETOPT_LONG_ONLY */
    int			 offset;
    char		*endptr;
    int			 opt_index;
    int			 opt_short;
    char		 cmdline[8192];

#if defined(__CYGWIN__)
    /* Cause a compile warning about redefinition without dllimport
     * attribute, *but* cause correct linkage if liblightning.a is
     * linked to binutils (that happens to have an internal
     * getopt* implementation and an apparently conflicting
     * optind global variable) */
    extern int		 optind;
    optind = 1;
#endif

    progname = argv[0];

    init_jit(progname);

#if defined(__sgi)
    DL_HANDLE = dlopen(NULL, RTLD_LAZY);
#endif

    flag_data = 1;
#if HAVE_GETOPT_LONG_ONLY
    for (;;) {
	if ((opt_short = getopt_long_only(argc, argv, short_options,
					  long_options, &opt_index)) < 0)
	    break;
	switch (opt_short) {
	    case 'h':
	    default:
		usage();
		break;
	    case 'v':
		if (optarg) {
		    flag_verbose = strtol(optarg, &endptr, 10);
		    if (*endptr || flag_verbose < 0)
			usage();
		}
		else
		    flag_verbose = 1;
		break;
	    case 'd':
		flag_data = 0;
		break;
#if defined(__i386__) && __WORDSIZE == 32
	    case '7':
		if (optarg) {
		    if (strcmp(optarg, "") == 0 || strcmp(optarg, "1") == 0)
			jit_cpu.sse2 = 0;
		    else if (strcmp(optarg, "0"))
			usage();
		}
		else
		    jit_cpu.sse2 = 0;
		break;
#endif
#if defined(__i386__) || defined(__x86_64__)
	    case '4':
		if (optarg) {
		    if (strcmp(optarg, "0") == 0)
			jit_cpu.sse4_2 = 0;
		    else if (strcmp(optarg, "1"))
			usage();
		}
		break;
#endif
#if defined(__arm__)
	    case 'c':
		if (optarg) {
		    offset = strtol(optarg, &endptr, 10);
		    if (*endptr || offset < 0)
			usage();
		    if (offset < jit_cpu.version)
			jit_cpu.version = offset;
		}
		break;
	    case 't':
		if (optarg) {
		    if (strcmp(optarg, "0") == 0)
			jit_cpu.thumb = 0;
		    else if (strcmp(optarg, "1") && strcmp(optarg, "2"))
			usage();
		}
		break;
	    case 'f':
#  if !defined(__ARM_PCS_VFP)
		/* Do not allow overrinding hard float abi */
		if (optarg) {
		    offset = strtol(optarg, &endptr, 10);
		    if (*endptr || offset < 0)
			usage();
		    if (offset < jit_cpu.vfp)
			jit_cpu.vfp = offset;
		}
#  endif
		break;
	    case 'n':
		if (optarg) {
		    if (strcmp(optarg, "0") == 0)
			jit_cpu.neon = 0;
		    else if (strcmp(optarg, "1"))
			usage();
		}
		break;
#endif
	}
    }
#else
    while ((opt_short = getopt(argc, argv, "hvd")) >= 0) {
	if (opt_short == 'v')
	    ++flag_verbose;
	else if (opt_short == 'd')
	    flag_data = 0;
	else
	    usage();
    }
#endif

    opt_index = optind;
#if defined(__hpux)
    /* Workaround */
    if (opt_index < argc && argv[opt_index][0] == '-')
	++opt_index;
#endif
    if (opt_index < 0 || opt_index >= argc)
	usage();
    if (strcmp(argv[opt_index], "-") == 0)
	strcpy(parser.name, "<stdin>");
    else {
	if ((endptr = strrchr(argv[opt_index], '/')) == NULL)
	    endptr = argv[opt_index];
	else
	    ++endptr;
	strncpy(parser.name, endptr, sizeof(parser.name));
	parser.name[sizeof(parser.name) - 1] = '\0';
    }
#if __clang__
#  define cc "clang"
#else
#  define cc "gcc"
#endif
    opt_short = snprintf(cmdline, sizeof(cmdline), cc " -E -x c %s", argv[opt_index]);
    for (++opt_index; opt_index < argc; opt_index++) {
	if (argv[opt_index][0] == '-')
	    opt_short += snprintf(cmdline + opt_short,
				  sizeof(cmdline) - opt_short,
				  " %s", argv[opt_index]);
	else {
	    --opt_index;
	    break;
	}
    }
    opt_short += snprintf(cmdline + opt_short,
			  sizeof(cmdline) - opt_short,
			  " -D__WORDSIZE=%d", __WORDSIZE);
    opt_short += snprintf(cmdline + opt_short,
			  sizeof(cmdline) - opt_short,
			  " -D__LITTLE_ENDIAN=%d", __LITTLE_ENDIAN);
    opt_short += snprintf(cmdline + opt_short,
			  sizeof(cmdline) - opt_short,
			  " -D__BIG_ENDIAN=%d", __BIG_ENDIAN);
    opt_short += snprintf(cmdline + opt_short,
			  sizeof(cmdline) - opt_short,
			  " -D__BYTE_ORDER=%d", __BYTE_ORDER);
#if defined(__i386__)
    opt_short += snprintf(cmdline + opt_short,
			  sizeof(cmdline) - opt_short,
			  " -D__i386__=1");
#endif
#if defined(__x86_64__)
    opt_short += snprintf(cmdline + opt_short,
			  sizeof(cmdline) - opt_short,
			  " -D__x86_64__=1");
#endif
#if defined(__mips__)
    opt_short += snprintf(cmdline + opt_short,
			  sizeof(cmdline) - opt_short,
			  " -D__mips__=1");
#endif
#if defined(__arm__)
    opt_short += snprintf(cmdline + opt_short,
			  sizeof(cmdline) - opt_short,
			  " -D__arm__=1");
#endif
#if defined(__powerpc__)
    opt_short += snprintf(cmdline + opt_short,
			  sizeof(cmdline) - opt_short,
			  " -D__ppc__=1");
#endif
#if defined(__sparc__)
    opt_short += snprintf(cmdline + opt_short,
			  sizeof(cmdline) - opt_short,
			  " -D__sparc__=1");
#endif
#if defined(__ia64__)
    opt_short += snprintf(cmdline + opt_short,
			  sizeof(cmdline) - opt_short,
			  " -D__ia64__=1");
#endif
#if defined(__hppa__)
    opt_short += snprintf(cmdline + opt_short,
			  sizeof(cmdline) - opt_short,
			  " -D__hppa__=1");
#endif
#if defined(_AIX)
    opt_short += snprintf(cmdline + opt_short,
			  sizeof(cmdline) - opt_short,
			  " -D_AIX=1");
#endif
#if defined(__sgi__)
    opt_short += snprintf(cmdline + opt_short,
			  sizeof(cmdline) - opt_short,
			  " -D__sgi__=1");
#endif
#if defined(__aarch64__)
    opt_short += snprintf(cmdline + opt_short,
			  sizeof(cmdline) - opt_short,
			  " -D__aarch64__=1");
#endif
#if defined(__s390__) || defined(__s390x__)
    opt_short += snprintf(cmdline + opt_short,
			  sizeof(cmdline) - opt_short,
			  " -D__s390__=1");
#endif
#if defined(__alpha__)
    opt_short += snprintf(cmdline + opt_short,
			  sizeof(cmdline) - opt_short,
			  " -D__alpha__=1");
#endif
    if ((parser.fp = popen(cmdline, "r")) == NULL)
	error("cannot execute %s", cmdline);

    parser.line = 1;
    parser.string = (char *)xmalloc(parser.length = 4096);

#if defined(__linux__) && (defined(__i386__) || defined(__x86_64__))
    /*	double precision		0x200
     *	round nearest			0x000
     *	invalid operation mask		0x001
     *	denormalized operand mask	0x002
     *	zero divide mask		0x004
     *	precision (inexact) mask	0x020
     */
    {
	fpu_control_t fpu_control = 0x027f;
	_FPU_SETCW(fpu_control);
    }
#endif

    _jit = jit_new_state();

    instrs = new_hash();
    for (offset = 0;
	 offset < (int)(sizeof(instr_vector) / sizeof(instr_vector[0]));
	 offset++)
	put_hash(instrs, (entry_t *)(instr_vector + offset));

    labels = new_hash();

    parse();
    pclose(parser.fp);
    parser.fp = NULL;

    for (opt_short = 0; opt_index < argc; opt_short++, opt_index++)
	argv[opt_short] = argv[opt_index];
    argv[opt_short] = NULL;
    argc = opt_short;
    execute(argc, argv);

    finish_jit();

    return (0);
}