/*
 * Intel 16 bit assembler for Plan 9
 * Reference: Intel `The 8086 Family User's Manual, October 1979'
 * While there are more instructions that the modern Intel chips
 * understand, these are the safe ones.
 *
 * The assmebly language is of the Ritchie PDP-11 style.
 *
 * Copyright (c) 2007, Brantley Coile
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the <organization> nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY Brantley Coile ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL <copyright holder> BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#include <u.h>
#include <libc.h>
#include <bio.h>
#include <ctype.h>

enum {
	NSYM = 1000,
	NRELO = 1000,
	NTMP = 500,
	NSSPACE = 50000,
};

#define dbprint print

typedef struct Sym Sym;
typedef struct Exec Exec;
typedef struct Operand Operand;
typedef struct Itab Itab;
typedef struct Tmp Tmp;
typedef struct Relo Relo;
typedef struct R R;
typedef struct Name Name;

struct Name 		/* format in .o */
{	
	int	name;
	int	type;
	int	value;
};

struct Sym 		/* internal format */
{
	Sym	*next;
	char	*name;
	int	 type;
	int	 addr;
};

#define N_UNDEF 	0x0
#define N_ABS 		0x2
#define N_TEXT 		0x4
#define N_DATA 		0x6
#define N_BSS 		0x8
#define N_REG		0xa
#define N_KW		0xe
#define N_INST		0x10
#define N_FN 		0x1f
#define N_EXT		01
#define N_TYPE		0x1e

struct Relo {
	int	r_addr;		
	uint	r_symbolnum:24,
		r_pcrel:1,
		r_length:2,
		r_extern:1,
		:4;
};

struct R {
	R	*next;
	Sym	*what;
	Relo	r;
};

struct Exec {
	int	magic;
	int	text;
	int	data;
	int	bss;
	int	symsz;
	int	entry;
	int	trelo;
	int	drelo;
};

struct Tmp {
	int	loc;
	int	label;
	int	type;
};

struct Operand {
	int 	 mode;
	int 	 type;
	Sym	*sym;
	int	 offset;
	char	 reg;
	char 	 base;
	char	 index;
	char	 scale;
};

struct Itab {
	char	*name;
	char	*fmt;
	int	noperands;
	int	mod;		/* index to mod/rm operand */
	int	omask1, omask2;
};

enum {
	Fxreg	= 1<<0,
	Fareg	= 1<<1,	/* AL, AX, or EAX */
	Fdisp	= 1<<2,	/* displayment */
	Fimm	= 1<<3,
	Fmodrm	= 1<<4,	/* requires mod/rm byte */
	Fsreg	= 1<<9,	/* Seg Register */
	Fabs	= 1<<10,	/* *prefix to operand */
	Freg	= Fxreg|Fareg,
	Fmod 	= Fareg|Freg|Fdisp|Fmodrm,
	
	BX	= 013,
	BP	= 015,
	SI	= 016,
	DI	= 017,
	
	Oindex	= (1<<BX)|(1<<BP)|(1<<SI)|(1<<DI),
};

/*
 * note that the hex for formats must be upper case
 * and other format stuff is lower case.
 */

Itab	itab[] = {
/*	  mne      fmt            nops  mod   omask1      omask2 */
	{ "aam",   "D4 04" },
	{ "adcb",  "14 ib",	   2,   -1,   Fimm,      Fareg },
	{ "adcb",  "80 /2 ib",     2,    1,   Fimm,      Fmod },
	{ "adcb",  "10 /r",        2,    1,   Freg,      Fmod },
	{ "adcb",  "12 /r",        2,    0,   Fmod,      Freg },
	{ "adc",   "15 iw",    	   2,   -1,   Fimm,      Fareg },
	{ "adc",   "81 /2 iw",     2,    1,   Fimm,      Fmod },
	{ "adc",   "11 /r",        2,    1,   Freg,      Fmod },
	{ "adc",   "13 /r",        2,    0,   Fmod,      Freg },

	{ "addb",  "04 ib",        2,   -1,   Fimm,      Fareg },
	{ "addb",  "80 /0 ib",     2,    1,   Fimm,	 Fmod },
	{ "addb",  "00 /r",        2,    1,   Freg,	 Fmod },
	{ "addb",  "02 /r",        2,    0,   Fmod,	 Freg },
	{ "add",   "05 iw",	   2,   -1,   Fimm,	 Fareg },
	{ "add",   "81 /0 iw",     2,    1,   Fimm,	 Fmod },
	{ "add",   "01 /r",	   2,    1,   Freg,	 Fmod },
	{ "add",   "03 /r",	   2,    0,   Fmod,	 Freg },
	{ "addq",  "83 /0 ib",     2,    1,   Fimm,      Fmod },

	{ "andb",  "24 ib",        2,   -1,   Fimm,      Fareg },
	{ "andb",  "80 /4 ib",     2,    1,   Fimm,	 Fmod },
	{ "andb",  "20 /r",        2,    1,   Freg,	 Fmod },
	{ "andb",  "22 /r",        2,    0,   Fmod,	 Freg },
	{ "and",   "25 iw",	   2,   -1,   Fimm,	 Fareg },
	{ "and",   "81 /4 iw",     2,    1,   Fimm,	 Fmod },
	{ "and",   "21 /r",	   2,    1,   Freg,	 Fmod },
	{ "and",   "23 /r",	   2,    0,   Fmod,	 Freg },

	{ "bound", "62 /r",        2,    1,   Freg,      Fmod },

	{ "bswap", "0F C8+r",      1,   -1,   Freg, },
	
	{ "cbw",   "98",           0,   -1   },

	{ "clc",   "F8",           0,   -1 },
	{ "cld",   "FC",           0,   -1 },
	{ "cli",   "FA",           0,   -1 },

	{ "cmc",   "F5",           0,   -1 },

	{ "cmpb",  "3C ib",        2,   -1,   Fimm,      Fareg },
	{ "cmpb",  "80 /7 ib",     2,    1,   Fimm,      Fmod },
	{ "cmpb",  "38 /r",        2,    1,   Freg,      Fmod },
	{ "cmpb",  "3A /r",        2,    0,   Fmod,      Freg },

	{ "cmp",   "3D iw",        2,   -1,   Fimm,      Fareg },
	{ "cmp",   "81 /7 iw",     2,    1,   Fimm,      Fmod },
	{ "cmp",   "39 /r",        2,    1,   Freg,      Fmod },
	{ "cmp",   "3B /r",        2,    0,   Fmod,      Freg },

	{ "cmpsb", "A6" },
	{ "cmpsw", "A7" },


	{ "call",   "E8 cw",       1,   -1,   Fdisp },
	{ "call",   "FF /2",       1,    0,   Fmod|Fabs },

	{ "cpuid", "0F A2",        0,   -1 },

	{ "cwd",   "99",           0,   -1 },

	{ "decb",  "FE /1",        1,    0,   Fmod },
	{ "dec",   "48+r",         1,    1,   Freg },
	{ "dec",   "FF /1",        1,    0,   Fmod },

	{ "divb",   "F6 /6",       1,    0,   Fmod },
	{ "div",    "F7 /6",       1,    0,   Fmod },

	{ "halt",   "F4",          0,   -1 },

	{ "idivb",  "F6 /7",       1,    0,   Fmod },
	{ "idiv",   "F7 /7",       1,    0,   Fmod },

	{ "inb",     "E4 ib",      1,   -1,   Fimm },
	{ "inb",     "EC",         0 },
	{ "in",      "E5 ib",      1,   -1,   Fimm },
	{ "in",      "ED",         0 },

	{ "incb",  "FE /0",        1,    0,   Fmod },
	{ "inc",   "40+r",         1,    1,   Freg },
	{ "inc",   "FF /0",        1,    0,   Fmod },

	{ "insb",  "6C", },
	{ "ins",   "6D" },

	{ "int3",  "CC" },
	{ "int",   "CD ib",        1,    -1,  Fimm },
	{ "into",  "CE" },

	{ "invd",  "0F 08" },

	{ "invlpg", "0F 01 /7",     1,     0,  Fmod },

	{ "iret",  "CF" },

	{ "jcxz",  "E3 cb",     1,    -1,  Fdisp },

	{ "jas",    "77 cb",     1,    -1,  Fdisp },	/* short ones for boot sector code */
	{ "jaes",   "73 cb",     1,    -1,  Fdisp },
	{ "jbs",    "72 cb",     1,    -1,  Fdisp },
	{ "jbes",   "76 cb",     1,    -1,  Fdisp },
	{ "jcs",    "72 cb",     1,    -1,  Fdisp },
	{ "jes",    "74 cb",     1,    -1,  Fdisp },
	{ "jgs",    "7F cb",     1,    -1,  Fdisp },
	{ "jges",   "7D cb",     1,    -1,  Fdisp },
	{ "jls",    "7C cb",     1,    -1,  Fdisp },
	{ "jles",   "7E cb",     1,    -1,  Fdisp },
	{ "jnas",   "76 cb",     1,    -1,  Fdisp },
	{ "jnaes",  "72 cb",     1,    -1,  Fdisp },
	{ "jnbs",   "73 cb",     1,    -1,  Fdisp },
	{ "jnbes",  "77 cb",     1,    -1,  Fdisp },
	{ "jncs",   "73 cb",     1,    -1,  Fdisp },
	{ "jnes",   "75 cb",     1,    -1,  Fdisp },
	{ "jngs",   "7E cb",     1,    -1,  Fdisp },
	{ "jnges",  "7C cb",     1,    -1,  Fdisp },
	{ "jnls",   "7D cb",     1,    -1,  Fdisp },
	{ "jnles",  "7F cb",     1,    -1,  Fdisp },
	{ "jnos",   "71 cb",     1,    -1,  Fdisp },
	{ "jnps",   "7B cb",     1,    -1,  Fdisp },
	{ "jnss",   "79 cb",     1,    -1,  Fdisp },
	{ "jnzs",   "75 cb",     1,    -1,  Fdisp },
	{ "jos",    "70 cb",     1,    -1,  Fdisp },
	{ "jps",    "7A cb",     1,    -1,  Fdisp },
	{ "jpes",   "7A cb",     1,    -1,  Fdisp },
	{ "jpos",   "7B cb",     1,    -1,  Fdisp },
	{ "jss",    "78 cb",     1,    -1,  Fdisp },
	{ "jzs",    "74 cb",     1,    -1,  Fdisp },

	{ "ja",    "0F 87 cw",     1,    -1,  Fdisp },
	{ "jae",   "0F 83 cw",     1,    -1,  Fdisp },
	{ "jb",    "0F 82 cw",     1,    -1,  Fdisp },
	{ "jbe",   "0F 86 cw",     1,    -1,  Fdisp },
	{ "jc",    "0F 82 cw",     1,    -1,  Fdisp },
	{ "je",    "0F 84 cw",     1,    -1,  Fdisp },
	{ "jg",    "0F 8F cw",     1,    -1,  Fdisp },
	{ "jge",   "0F 8D cw",     1,    -1,  Fdisp },
	{ "jl",    "0F 8C cw",     1,    -1,  Fdisp },
	{ "jle",   "0F 8E cw",     1,    -1,  Fdisp },
	{ "jna",   "0F 86 cw",     1,    -1,  Fdisp },
	{ "jnae",  "0F 82 cw",     1,    -1,  Fdisp },
	{ "jnb",   "0F 83 cw",     1,    -1,  Fdisp },
	{ "jnbe",  "0F 87 cw",     1,    -1,  Fdisp },
	{ "jnc",   "0F 83 cw",     1,    -1,  Fdisp },
	{ "jne",   "0F 85 cw",     1,    -1,  Fdisp },
	{ "jng",   "0F 8E cw",     1,    -1,  Fdisp },
	{ "jnge",  "0F 8C cw",     1,    -1,  Fdisp },
	{ "jnl",   "0F 8D cw",     1,    -1,  Fdisp },
	{ "jnle",  "0F 8F cw",     1,    -1,  Fdisp },
	{ "jno",   "0F 81 cw",     1,    -1,  Fdisp },
	{ "jnp",   "0F 8B cw",     1,    -1,  Fdisp },
	{ "jns",   "0F 89 cw",     1,    -1,  Fdisp },
	{ "jnz",   "0F 85 cw",     1,    -1,  Fdisp },
	{ "jo",    "0F 80 cw",     1,    -1,  Fdisp },
	{ "jp",    "0F 8A cw",     1,    -1,  Fdisp },
	{ "jpe",   "0F 8A cw",     1,    -1,  Fdisp },
	{ "jpo",   "0F 8B cw",     1,    -1,  Fdisp },
	{ "js",    "0F 88 cw",     1,    -1,  Fdisp },
	{ "jz",    "0F 84 cw",     1,    -1,  Fdisp },

	{ "jmps",  "EB cb",       1,    -1,  Fdisp },
	{ "jmp",   "E9 cw",       1,    -1,  Fdisp },
	{ "jmp",   "FF /4",       1,     0,  Fmod|Fabs },

	{ "lahf",  "9F" },
	{ "lds",   "C5 /r",	   2,     0,  Fmod,     Freg },
	{ "lea",   "8D /r ",       2,     0,  Fmod,	Freg },

	{ "les",   "C4 /r",	   2,     0,  Fmod,     Freg },
	
	{ "lidt",  "0F 01 /3",     1,     0,  Fmod },
	{ "lgdt",  "0F 01 /2",     1,     0,  Fmod },

	{ "lodsb", "AC" },
	{ "lods",  "AD" },

	{ "loop",  "E2 cb",         1,    -1,  Fdisp },
	{ "loope", "E1 cb",         1,    -1,  Fdisp },
	{ "loopz", "E1 cb",         1,    -1,  Fdisp },
	{ "loopne","E0 cb",         1,    -1,  Fdisp },
	{ "loopnz","E0 cb",         1,    -1,  Fdisp },

	{ "movb",  "B0+r ib",       2,    -1,  Fimm,       Freg },
	{ "movb",  "C6 /0 ib",      2,     1,  Fimm,       Fmod },
	{ "movb",  "8A /r",         2,     0,  Fmod,       Freg },
	{ "movb",  "88 /r",         2,     1,  Freg,       Fmod },

	{ "mov",   "B8+r iw",       2,    -1,  Fimm,       Freg },
	{ "mov",   "C7 /0 iw",      2,     1,  Fimm,       Fmod },
	{ "mov",   "8B /r",         2,     0,  Fmod,       Freg },
	{ "mov",   "89 /r",         2,     1,  Freg,       Fmod },

	{ "mov",   "8C /r",         2,     1,  Fsreg,      Fmod },
	{ "mov",   "8E /r",         2,     0,  Fmod,       Fsreg },

	{ "movsb", "A4" },
	{ "movs",  "A5" },

	{ "movsbl", "0F BE /r",     2,     0,  Fmod,       Freg },
	{ "movsbw", "0F BF /r",     2,     0,  Fmod,       Freg },

	{ "movzbl", "0F B6 /r",     2,     0,  Fmod,       Freg },
	{ "movzbw", "0F B7 /r",     2,     0,  Fmod,       Freg },

	{ "mulb",    "F6 /4",        1,     0,  Fmod },
	{ "mul",     "F7 /4",        1,     0,  Fmod },

	{ "negb",    "F6 /3",        1,     0,  Fmod },
	{ "neg",     "F7 /3",        1,     0,  Fmod },

	{ "nop",     "90" },

	{ "notb",    "F6 /2",        1,     0,  Fmod },
	{ "notw",    "66 F7 /2",     1,     0,  Fmod },
	{ "notl",    "F7 /2",        1,     0,  Fmod },
	{ "opsz",   "66",           0,   -1 },

	{ "orb",     "0C ib",        2,   -1,   Fimm,    Fareg },
	{ "orb",     "80 /1 ib",     2,    1,   Fimm,	 Fmod },
	{ "orb",     "08 /r",        2,    1,   Freg,	 Fmod },
	{ "orb",     "0A /r",        2,    0,   Fmod,	 Freg },
	{ "or",      "0D iw",        2,   -1,   Fimm,	 Fareg },
	{ "or",      "81 /1 iw",     2,    1,   Fimm,	 Fmod },
	{ "or",      "09 /r",        2,    1,   Freg,	 Fmod },
	{ "or",      "0B /r",        2,    0,   Fmod,	 Freg },


	{ "outb",    "E6 ib",        1,   -1,   Fimm },
	{ "outb",    "EE" },
	{ "out",     "E7 ib",        1,   -1,   Fimm },
	{ "out",     "EF" },

	{ "outsb",   "6E" },
 	{ "outs",    "6F" },
 	
	{ "popf",    "9D" },
	{ "pushf",   "9C" },

	/* do rcl/rcr/rol/ror as pseudo op */

	{ "rep",    "F3" },
	{ "repe",   "F3" },
	{ "repne",  "F2" },

	{ "ret",    "C3" },
	{ "ret",    "C2 iw",         1,   -1,   Fimm },
	{ "lret",   "CB" },
	{ "lret",   "CA iw",         1,   -1,   Fimm },

	{ "sahf",   "9E" },

	/* do sal, sar, shal, shr as pseudo op */

	{ "sbbb",    "1C ib",        2,   -1,   Fimm,    Fareg },
	{ "sbbb",    "80 /3 ib",     2,    1,   Fimm,	 Fmod },
	{ "sbbb",    "18 /r",        2,    1,   Freg,	 Fmod },
	{ "sbbb",    "1A /r",        2,    0,   Fmod,	 Freg },
	{ "sbb",     "1D iw",        2,   -1,   Fimm,	 Fareg },
	{ "sbb",     "81 /3 iw",     2,    1,   Fimm,	 Fmod },
	{ "sbb",     "19 /r",        2,    1,   Freg,	 Fmod },
	{ "sbb",     "1B /r",        2,    0,   Fmod,	 Freg },

	{ "scasb",   "AE" },
	{ "scas",    "AF" },

	{ "seges",   "26" },
	{ "segcs",   "2e" },
	{ "segss",   "36" },
	{ "segds",   "3e" },
	
	{ "seta",    "0F 97 /0",     1,     0,  Fmod },
	{ "setae",   "0F 93 /0",     1,     0,  Fmod },
	{ "setb",    "0F 92 /0",     1,     0,  Fmod },
	{ "setbe",   "0F 96 /0",     1,     0,  Fmod },
	{ "setc",    "0F 92 /0",     1,     0,  Fmod },
	{ "sete",    "0F 94 /0",     1,     0,  Fmod },
	{ "setg",    "0F 9F /0",     1,     0,  Fmod },
	{ "setge",   "0F 9D /0",     1,     0,  Fmod },
	{ "setl",    "0F 9C /0",     1,     0,  Fmod },
	{ "setle",   "0F 9E /0",     1,     0,  Fmod },
	{ "setna",   "0F 96 /0",     1,     0,  Fmod },
	{ "setnae",  "0F 92 /0",     1,     0,  Fmod },
	{ "setnb",   "0F 93 /0",     1,     0,  Fmod },
	{ "setnbe",  "0F 97 /0",     1,     0,  Fmod },
	{ "setnc",   "0F 93 /0",     1,     0,  Fmod },
	{ "setne",   "0F 95 /0",     1,     0,  Fmod },
	{ "setng",   "0F 9E /0",     1,     0,  Fmod },
	{ "setnge",  "0F 9C /0",     1,     0,  Fmod },
	{ "setnl",   "0F 9D /0",     1,     0,  Fmod },
	{ "setnle",  "0F 9F /0",     1,     0,  Fmod },
	{ "setno",   "0F 91 /0",     1,     0,  Fmod },
	{ "setnp",   "0F 9B /0",     1,     0,  Fmod },
	{ "setns",   "0F 99 /0",     1,     0,  Fmod },
	{ "setnz",   "0F 95 /0",     1,     0,  Fmod },
	{ "seto",    "0F 90 /0",     1,     0,  Fmod },
	{ "setp",    "0F 9A /0",     1,     0,  Fmod },
	{ "setpe",   "0F 9A /0",     1,     0,  Fmod },
	{ "setpo",   "0F 9B /0",     1,     0,  Fmod },
	{ "sets",    "0F 98 /0",     1,     0,  Fmod },
	{ "setz",    "0F 94 /0",     1,     0,  Fmod },

	{ "stc",     "F9" },
	{ "std",     "FD" },
	{ "sti",     "FB" },
	
	{ "stosb",    "AA" },
	{ "stos",     "AB" },

	{ "str",      "0F 00 /1",   1,      0,  Fmod },

	{ "subb",    "2C ib",        2,   -1,   Fimm,    Fareg },
	{ "subb",    "80 /5 ib",     2,    1,   Fimm,	 Fmod },
	{ "subb",    "28 /r",        2,    1,   Freg,	 Fmod },
	{ "subb",    "2A /r",        2,    0,   Fmod,	 Freg },
	{ "sub",     "2D iw",        2,   -1,   Fimm,	 Fareg },
	{ "sub",     "81 /5 iw",     2,    1,   Fimm,	 Fmod },
	{ "sub",     "29 /r",        2,    1,   Freg,	 Fmod },
	{ "sub",     "2B /r",        2,    0,   Fmod,	 Freg },
	{ "subq",    "83 /5 ib",     2,    1,   Fimm,    Fmod },

	{ "testb",   "A8 ib",        2,   -1,   Fimm,    Fareg },
	{ "testb",   "F6 /0 ib",     2,    1,   Fimm,	 Fmod },
	{ "testb",   "84 /r",        2,    1,   Freg,	 Fmod },
	{ "test",    "A9 iw",        2,   -1,   Fimm,	 Fareg },
	{ "test",    "F7 /0 iw",     2,    1,   Fimm,	 Fmod },
	{ "test",    "85 /r",        2,    1,   Freg,	 Fmod },

	{ "xchgb",   "86 /r",        2,    1,   Freg,    Fmod},
	{ "xchgb",   "86 /r",        2,    0,   Fmod,    Freg },
	{ "xchgl",   "90+r",         2,   -1,   Freg,    Fareg },
	{ "xchgl",   "90+r",         2,   -1,   Fareg,   Freg },
	{ "xchgl",   "87 /r",        2,    1,   Freg,    Fmod },
	{ "xchgl",   "87 /r",        2,    0,   Fmod,    Freg },

	{ "xlatb",   "D7" },

	{ "xorb",    "34 ib",        2,   -1,   Fimm,    Fareg },
	{ "xorb",    "80 /6 ib",     2,    1,   Fimm,	 Fmod },
	{ "xorb",    "30 /r",        2,    1,   Freg,	 Fmod },
	{ "xorb",    "32 /r",        2,    0,   Fmod,	 Freg },
	{ "xor",    "35 iw",        2,   -1,   Fimm,	 Fareg },
	{ "xor",    "81 /6 iw",     2,    1,   Fimm,	 Fmod },
	{ "xor",    "31 /r",        2,    1,   Freg,	 Fmod },
	{ "xor",    "33 /r",        2,    0,   Fmod,	 Freg },

	
	{ 0 }
};

enum {
	TEOF,
	TCONST,
	TNAME,
	TLSHIFT,
	TRSHIFT,
};

enum {
	BLKLEN	= 8*1024,
	NBLKPTRS	= 2,
};

typedef struct Block Block;
struct Block {
	Block	*next;
	int	len;
	char	block[BLKLEN];
};

typedef struct {
	Block *first;
	Block *last;
} Blkptr;

Blkptr	blkptrs[NBLKPTRS];
Sym	*symtab;
Sym	*last_sys_sym;
Sym	*last_sym;
char	*sspace;
Name	*nspace;
Relo	*rspace;
R	*trelo;
R	*drelo;
R	**cur_relo;
Tmp	tmp[NTMP];
int	nxt_tmp;
int	Lflag;
int	lineno;
char	*filename;	
jmp_buf env;
enum	{ NOPRN = 5};
Operand	oprn[NOPRN];
int	noprn;
char	*outfname;
Biobuf	*src;
Blkptr	*tbp, *dbp;
Blkptr	**cur_bp;
Biobuf	*outbp;
char	*lexp;
char	*name;
int	slen;
int	tok;
int	value;
int	in_offset;		/* offset into temp instruction buffer */
int	*cur_loc;
int	locs[3];
int	pass_no;
int	bytes_out;
char	instr[12];
int	errcnt;
int	eof;
int	allow_reg;		/* on means lookup will take names begining with % */
int	debug;

void	init_kw(void);
void	install(char *, ulong, int);
void	fatal(char *, ...);
void	error(char *, ...);
void	warning(char *, ...);
int	get_num(void);
char	*get_ident(void);
char	*get_string(int);
int	get_quoted(void);
void	rlex(void);
void	pr_tok(void);
void	lex(void);
Sym	*lookup(char *);
Itab	*omatch(char *);
void	pass1(void);
void	pass2(void);
void	print_undefs(void);
int	expr(int *, Sym **);
void	parseo(void);
void	mk_code(char *);
int	mag(ulong, int);
void	note_relo(Sym *, int, int, int);
void	put_const(int, int);
void	put(Operand *, int);
int	mk_mode(Operand *);
int	mk_extw(int, Operand *);
int	mk_ea(int, ushort, Operand *, Operand*);
int	number(Operand *);
void	store_image(void);
void	put_string(void);
void	mk_tmp(int);
int	lookup_tmp(int, int, int*);
void	lusyms(void);
void	format(Itab *);
void	write_instr(void);
void	write_string(Blkptr *, char *, int);
void	fixup_undefs(void);
Blkptr	*block_open(void);
void	block_write(Blkptr *, void *, int);
int	block_copyout(Biobuf *, Blkptr *);
int	cur_seg(int);
int	map_type(int);
void	dumpb(char *, int);
void	pr_oper(void);

void
usage(void)
{
	fprint(2, "usage: as [-uLX] [-o outfile] file.s\n");
	exits("usage");
}

void
main(int argc, char *argv[])
{
	int uflag;

	if (argc == 1)
		usage();
	filename = "stdin";
	outfname = "a.out";

	uflag = 0;
	ARGBEGIN{
	case 'o':
		outfname = EARGF(usage());
		break;
	case 'u':
		uflag++;
		break;
	case 'L':
		Lflag++;
		break;
	case 'X':
		debug++;
		break;
	default:
		usage();
	}ARGEND

	init_kw();
	outbp = Bopen(outfname, OWRITE);
	if (outbp == nil) {
		fprint(2, "as: can't open %s: %r\n", outfname);
		exits("open");
	}
	if (argc != 1)
		usage();
	src = Bopen(*argv, OREAD);
	if (src == 0) {
		fprint(2, "as: an't open %s\n", *argv);
		exits("open src");
	}
	tbp = block_open();
	dbp = block_open();
	cur_bp = &tbp;
	cur_relo = &trelo;
	filename = *argv;
	pass1();
	fixup_undefs();
	if (errcnt)
		exits("errs");
	lexp = 0;
	Bseek(src, 0, 0);
	eof = 0;
	pass2();
	if(uflag)
		print_undefs();
	if (errcnt)
		exits("errs");
	store_image();
	exits(nil);
}

void
dump(void *vf, int n)
{
	int *f = vf;
	int i;

	while (n > 0) {
		print("%08p: ", f);
		for (i = 0; i < 8; i++)
			print("%08x ", *f++);
		print("\n");
		n -= 4*8;
	}
}


void
print_undefs(void)
{
	Sym *sp;

	for (sp = last_sys_sym->next; sp; sp = sp->next)
		if ((sp->type&~N_EXT) == N_UNDEF)
			fprint(2, "as: %s: undefined\n", sp->name);
}

void
fixup_undefs(void)	/* make all undefined external */
{
	Sym *sp;

	for (sp = last_sys_sym->next; sp; sp = sp->next)
		if (sp->type == N_UNDEF)
			sp->type |= N_EXT;
}

int
xwrite(Biobuf *bp, void *where, int len)
{
	return Bwrite(bp, where, len);
}

/*
 * we can edit .Ls out because no relocation record points to them
 */

void
edit_names(void)	/* squeeze out .L */
{
	Sym *sp, **sq;

	
	sp = last_sys_sym->next;
	sq = &last_sys_sym->next;
	while (sp) {
		if (strncmp(sp->name, ".L", 2) == 0)
			*sq = sp->next;
		else
			sq = &sp->next;
		sp = sp->next;
	}
}

void
set_relo(Sym *sp, int snum)	/* find an set snum in relocation table */
{
	R *rp;

	for (rp = trelo; rp; rp = rp->next)
		if (sp == rp->what)
			rp->r.r_symbolnum = snum;
	for (rp = drelo; rp; rp = rp->next)
		if (sp == rp->what)
			rp->r.r_symbolnum = snum;
}

int
pack_names(int *nsize)	/* put strings into string space */
{
	char *cp;
	Sym *sp;
	Name *np;
	int ne = 0, slen = 0, cnt;

	/* scan symbol table counting entries and string sizes */
	for (sp = last_sys_sym->next; sp; sp = sp->next) {
		ne++;
		slen += strlen(sp->name)+1;
	}
	sspace = malloc(slen + 4);
	nspace = malloc(ne * sizeof (Name));
	*nsize = ne * sizeof (Name);

	cp = sspace;
	cp += 4;	/* save room for total string length */
	np = nspace;
	cnt = 0;
	for (sp = last_sys_sym->next; sp; sp = sp->next) {
		strcpy(cp, sp->name);
		np->type = sp->type;
		np->value = sp->addr;
		np->name = cp - sspace;
		set_relo(sp, cnt++);
		cp += strlen(cp)+1;
		np++;
	}
	*(int *)sspace = cp - sspace;
	return cp - sspace;
}

int
copyout_relo(Biobuf *bp, R *r)	/* format and copyout relocation information */
{
	int nr = 0;
	R *rp;
	Relo *p;

	for (rp = r; rp; rp = rp->next) {
/*		if (rp->what && rp->r.r_symbolnum == 0)
			fatal("%s: relocation reference", rp->what->name); */
		nr++;
	}
	rspace = (Relo *)malloc(nr * sizeof *rspace);
	p = rspace;
	for (rp = r; rp; rp = rp->next)
		*p++ = rp->r;
	Bwrite(bp, rspace, sizeof *rspace * nr);
	free(rspace);
	return nr * sizeof *rspace;
}

			
void
store_image(void)
{
	Exec e;
	int i, nsyms;

	if (!Lflag)
		edit_names();	/* take out .L symbols */
	i = pack_names(&nsyms);	/* get strings packed up to go */
	e.magic = 0407;
	Bseek(outbp, sizeof e, 0);
	e.text = block_copyout(outbp, tbp);
	e.data = block_copyout(outbp, dbp);
	e.trelo = copyout_relo(outbp, trelo);
	e.drelo = copyout_relo(outbp, drelo);
	xwrite(outbp, nspace, nsyms);
	xwrite(outbp, sspace, i);
	e.bss = (locs[2] + 511) & ~0x1FF;
	e.entry = 0x1023;
	e.symsz = nsyms;
	Bseek(outbp, 0, 0);
	Bwrite(outbp, &e, sizeof e);
}


void dot_byte(char *);
void dot_word(char *);
void dot_long(char *);
void dot_text(char *);
void dot_bss(char *);
void dot_data(char *);
void dot_align(char *);
void dot_space(char *);
void dot_globl(char *);
void dot_lcomm(char *);
void dot_comm(char *);
void not_yet(char *);
void do_imul(char *);
void do_pop(char *);
void do_push(char *);
void do_rot(char *);
void do_shift(char *);
void dot_set(char *);
void do_ljmp(char *);
void do_lcall(char *);

void
init_kw(void)	/* put things in the symbol table */
{
	Itab *ip;

	/*
	 * registers use octal incoding of classes of register
	 * The register value is the least sig 3 bits.

	 * 1	16
	 * 2	8 bit register
	 * 3	segment register
	 */

	install("ax",  010, N_REG);
	install("cx",  011, N_REG);
	install("dx",  012, N_REG);
	install("bx",  013, N_REG);
	install("sp",  014, N_REG);
	install("bp",  015, N_REG);
	install("si",  016, N_REG);
	install("di",  017, N_REG);

	install("al",  020, N_REG);
	install("cl",  021, N_REG);
	install("dl",  022, N_REG);
	install("bl",  023, N_REG);
	install("ah",  024, N_REG);
	install("ch",  025, N_REG);
	install("dh",  026, N_REG);
	install("bh",  027, N_REG);

	install("es",  030, N_REG);
	install("cs",  031, N_REG);
	install("ss",  032, N_REG);
	install("ds",  033, N_REG);
	install("fs",  034, N_REG);	/* with care */

	install(".align", (int)dot_align, N_KW);
	install(".bss", (int)dot_bss, N_KW);
	install(".byte", (int)dot_byte, N_KW);
	install(".comm", (int)dot_comm, N_KW);
	install(".data", (int)dot_data, N_KW);
	install(".globl", (int)dot_globl, N_KW);
	install(".lcomm", (int)dot_lcomm, N_KW);
	install(".set",  (int)dot_set, N_KW);
	install(".size", (int)not_yet, N_KW);
	install(".space", (int)dot_space, N_KW);
	install(".text", (int)dot_text, N_KW);
	install(".type", (int)not_yet, N_KW);
	install(".ident", (int)not_yet, N_KW);
	install(".word", (int)dot_word, N_KW);

	/* instructions that don't fit the pattern matching algorithim */

	install("imul", (int)do_imul, N_KW);
	install("imulb", (int)do_imul, N_KW);
	install("lcall", (int)do_lcall, N_KW);
	install("ljmp",  (int)do_ljmp, N_KW);
	install("pop", (int)do_pop, N_KW);
	install("pushb", (int)do_push, N_KW);
	install("push", (int)do_push, N_KW);
	install("salb", (int) do_shift, N_KW);
	install("sal", (int) do_shift, N_KW);
	install("sarb", (int) do_shift, N_KW);
	install("sar", (int) do_shift, N_KW);
	install("shlb", (int) do_shift, N_KW);
	install("shl", (int) do_shift, N_KW);
	install("shrb", (int) do_shift, N_KW);
	install("shr", (int) do_shift, N_KW);

	install("rclb", (int) do_rot, N_KW);
	install("rcl", (int) do_rot, N_KW);
	install("rcrb", (int) do_rot, N_KW);
	install("rcr", (int) do_rot, N_KW);
	install("rolb", (int) do_rot, N_KW);
	install("rol", (int) do_rot, N_KW);
	install("rorb", (int) do_rot, N_KW);
	install("ror", (int) do_rot, N_KW);

	for (ip = itab; ip->name; ip++)
		install(ip->name, (int)ip, N_INST);

	last_sys_sym = last_sym;
}

void
install(char *name, ulong value, int type)	/* insert symbol table entry */
{
	Sym *sp;

	allow_reg = 1;
	sp = lookup(name);
	allow_reg = 0;
	sp->type = type;
	sp->addr = value;
}

void
fatal(char *msg, ...)
{
	va_list arg;

	fprint(2, "Fatal error: %s:%d: ", filename, lineno);
	va_start(arg, msg);
	vfprint(2, msg, arg);
	va_end(arg);
	fprint(2, "\n");
	*(int *)0 = 0;
	exits("fatal");
}

void
error(char *msg, ...)		// nonfatal error message
{
	va_list arg;

	errcnt++;
	fprint(2, "Error: %s:%d: ", filename, lineno);
	va_start(arg, msg);
	vfprint(2, msg, arg);
	va_end(arg);
	fprint(2, "\n");
	longjmp(env, 1);
}

void
warning(char *msg, ...)
{
	va_list arg;

	fprint(2, "Warning: %s:%d: ", filename, lineno);
	va_start(arg, msg);
	vfprint(2, msg, arg);
	va_end(arg);
	fprint(2, "\n");
}

int
get_num(void)
{
	int val = 0;

	if (*lexp == '0') {
		lexp++;
		if (*lexp == 'x' || *lexp == 'X') {
			lexp++;
			while (isxdigit(*lexp)) {
				val <<= 4;
				if (*lexp >= '0' && *lexp <= '9')
					val += *lexp - '0';
				else if (*lexp >= 'a' && *lexp <= 'f')
					val += *lexp - 'a' + 10;
				else
					val += *lexp - 'A' + 10;
				lexp++;
			}
			return val;
		}
		while (isdigit(*lexp)) {
			val <<= 3;
			val += *lexp++ - '0';
		}
		return val;
	}
	while (isdigit(*lexp)) {
		val *= 10;
		val += *lexp++ - '0';
	}
	return val;
}

char *
get_ident(void)
{
	char *p, buf[512];

	p = buf;
	*p++ = *lexp++;
	while (isalnum(*lexp) || *lexp == '_' || *lexp == '.')
		*p++ = *lexp++;
	*p = 0;
	return strdup(buf);
}

char *
get_string(int closec)
{
	char *p, buf[512];
	int val = 0;

	p = buf;
	while (*lexp && *lexp != closec) {
		if (*lexp != '\\')
			*p++ = *lexp++;
		else if (lexp[1] == '\\')
			*p++ = '\\';
		else
			switch (lexp[1]) {
			case 'b': *p++ = '\b';  lexp += 2; break;
			case 't': *p++ = '\t';  lexp += 2; break;
			case 'r': *p++ = '\r';  lexp += 2; break;
			case 'n': *p++ = '\n'; lexp += 2;  break;
			case '>': *p++ = '>'; lexp += 2; break;
			case '0':
				lexp += 2;
				while (isdigit(*lexp)) {
					val <<= 3;
					val += *lexp - '0';
				}
				*p++ = val;
				break;
			default:
				error("bad char in string");
			}
	}
	*p = 0;
	slen = p - buf;
	if (*lexp == 0)
		error("newline in string");
	lexp++;
	return strdup(buf);
}

int
get_quoted(void)
{
	int val = 0;

	lexp++;
	if (*lexp != '\\')
		val = *lexp++;
	else if (lexp[1] == '\\') {
		lexp += 2;
		val = '\\';
	} else
		switch (lexp[1]) {
			case 'b': val = '\b';  lexp += 2; break;
			case 't': val = '\t';  lexp += 2; break;
			case 'r': val = '\r';  lexp += 2; break;
			case 'n': val = '\n'; lexp += 2;  break;
			case '"': val = '"'; lexp += 2; break;
			case '0':
				lexp += 2;
				while (isdigit(*lexp)) {
					val <<= 3;
					val += *lexp - '0';
					lexp++;
				}
				break;
			default:
				error("bad char in char const");
		}
	if (*lexp != '\'')
		error("buggered-up character constant");
	else
		lexp++;
	return val;
}

char line[256];
int	op;	/* true if we know we are in an operator; for '-' */

void
rlex(void)
{
	if (eof) {
		tok = TEOF;
		return;
	}
	if (lexp == 0) {
read_again:
		lexp = Brdline(src, '\n');
		if (lexp == 0) {
			tok = TEOF;
			eof = 1;
			return;
		}
		lineno++;
	}
again:
	while (*lexp == ' ' || *lexp == '\t')
		lexp++;
	switch (*lexp) {
	case 0:
		goto read_again;
	case '-':
	case ',':
	case '(':
	case ')':
	case ':':
	case '=':
	case '+':
	case '*':
	case '@':
	case '"':	/* XXX should parse string */
	case '$':
		tok = *lexp++;
		return;

	case '/':
		if (lexp[1] == '*') {	/* comments */
			lexp += 2;
			for (;;) {
				while (*lexp != '*' && *lexp != '\n')
					lexp++;
				if (*lexp == '\n') {
					lexp = Brdline(src, '\n');
					if (lexp == 0) {
						tok = TEOF;
						eof = 1;
						return;
					}
					lineno++;
				} else if (lexp[1] == '/') {
					lexp += 2;
					goto again;
				} else
					lexp++;
			}
		}
		while (*lexp != '\n' && *lexp != ';')
			lexp++;
		tok = '\n';
		lexp = 0;
		return;

	case '<':
		if (lexp[1] == '<') {
			lexp += 2;
			tok = TLSHIFT;
			return;
		}
		tok = *lexp++;
		return;

	case '>':
		if (lexp[1] == '>') {
			lexp += 2;
			tok = TRSHIFT;
			return;
		}
		tok = *lexp++;
		return;

	case '\'':
		value = get_quoted();
		tok = TCONST;
		return;

	case '\n':
		tok = *lexp;
		lexp = 0;
		return;

	case '\\':
		if (lexp[1] == '/') {
			lexp += 2;
			tok = '/';
			return;
		}
		goto bad_char;

	case ';':
		lexp++;
		tok = '\n';
		return;

	default:
		if (isdigit(*lexp)) {
			value = get_num();
			tok = TCONST;
			return;
		}
		if (isalpha(*lexp) || *lexp == '_' || *lexp == '.' || *lexp == '%') {
			name = get_ident();
			tok = TNAME;
			return;
		}
bad_char:
		fprint(2, "%s:%d illegal character %c\n", filename, lineno, *lexp);
		lexp++;
		goto again;
	}
}

void
pr_tok(void)
{
	print("%s:%d: ", filename, lineno);
	switch (tok) {
	case ',':
	case '(':
	case ')':
	case ':':
	case ';':
	case '=':
	case '+':
	case '-':
	case '*':
	case '#':
	case '$':
		print(" %c\n", tok);
		break;
	case TCONST:
		print(" TCONST %d\n", value);
		break;
	case TNAME:
		print(" TNAME %s\n", name);
		break;
	case TRSHIFT:
		print(" TRSHIFT\n");
		break;
	case TLSHIFT:
		print(" TLSHIFT\n");
		break;
	case '\n':
		print(" NEWLINE\n");
		break;
	case TEOF:
		print("EOF\n");
		break;
	default:
		print("??? %c\n", tok);
		break;
	}
}

void
lex(void)
{
	rlex();
	if (pass_no == 1 && lineno == 25000000)
		pr_tok();
}

Sym *
lookup(char *name)	/* find non-instruction */
{
	Sym *sp;

	for (sp = symtab; sp; sp = sp->next)
		if (strcmp(sp->name, name) == 0)
		if (sp->type != N_INST)
		if (sp->type != N_KW)
			return sp;
	sp = (Sym *)malloc(sizeof *sp);
	if (last_sym)
		last_sym->next = sp;
	else
		symtab = sp;
	last_sym = sp;
	sp->name = strdup(name);
	sp->type = 0;
	sp->addr = 0;
	sp->next = 0;
	return sp;
}

Sym *
lookupi(char *name)	/* find instruction */
{
	Sym *sp;

	for (sp = symtab; sp; sp = sp->next)
		if (strcmp(sp->name, name) == 0)
		if (sp->type == N_INST || sp->type == N_KW)
			return sp;
	return 0;
}

Itab *
omatch(char *name)
{
	Operand *p;
	Itab *ip;

	for (ip = itab; ip->name; ip++)
		if (strcmp(ip->name, name) == 0)
			break;
	if (ip->name == 0)
		error("illegal opcode <%s>", name);
	for ( ; ip->name && strcmp(ip->name, name) == 0; ip++) {
		if (noprn != ip->noperands)
			continue;
		p = oprn;
		if (noprn > 0
		&& ((p->mode & ip->omask1) == 0 || p->mode & ~ip->omask1))
			continue;
		if ((p->mode & Fabs) && (ip->omask1 & Fabs) == 0)
			continue;
		if (noprn > 1
		&& ((p[1].mode & ip->omask2) == 0 || p[1].mode & ~ip->omask2))
			continue;
		if ((p[1].mode & Fabs) && (ip->omask2 & Fabs) == 0)
			continue;
		return ip;
	}
	pr_oper();
	error("illegal operand");
	return 0;
}


/*
 * build the symbol table
 */

void
pass1(void)
{
	char *np;
	Sym *sp, *sp2;
	int n;

	pass_no = 1;
	lineno = 0;
	locs[0] = locs[1] = locs[2] = 0;
	cur_loc = locs;
	if (setjmp(env)) {
		while (!eof && tok != '\n')
			lex();
	}
	lex();
loop:
	if (tok == TEOF)
		return;
	if (tok == '\n') {
		lex();
		goto loop;
	}
	if (tok == TNAME) {
		np = name;
		lex();
		if (tok == ':') {
			sp = lookup(np);
			if ((sp->type&N_TYPE) != N_UNDEF)
				error("symbol already defined!");
			sp->type = map_type(cur_loc - locs);
			sp->addr = *cur_loc;
			lex();
			goto loop;
		}
		if (tok == '=') {
			sp = lookup(np);
			if (sp->type != N_UNDEF)
				error("symbol already defined!");
			lex();
			sp->addr = expr(&sp->type, &sp2);
			goto loop;
		}
		sp = lookupi(np);
		if (sp == 0)
			error("illegal instruction");
		if (sp->type == N_KW) {
			(*(void(*)(char *))sp->addr)(np);
			goto loop;
		}
		if (sp->type == N_INST) {
			parseo();
			mk_code(np);
			if (tok != '\n')
				error("extra stuff");
			goto loop;
		}
		error("illegal instruction");
	}
	if (tok == TCONST) {
		n = value;
		lex();
		if (value >= 0 && value < 10)
		if (tok == ':') {
			mk_tmp(n);
			lex();
			goto loop;
		}
		*cur_loc += 4;
		goto loop;
	}
	if (tok == '<') {
		get_string('>');
		*cur_loc += slen;
		lex();
		goto loop;
	}
	error("syntax");
}

/*
 * pass over text again, this time generating the binary
 */

void
pass2(void)
{
	char *np;
	Sym *sp, *sp2;
	int n;

	pass_no = 2;
	lineno = 0;
	locs[0] = locs[1] = locs[2] = 0;
	cur_loc = locs;
	cur_bp = &tbp;
	cur_relo = &trelo;
	if (setjmp(env)) {
		while (tok != '\n')
			lex();
	}
	lex();
loop:
	if (tok == TEOF)
		return;
	if (tok == '\n') {
		lex();
		goto loop;
	}
	if (tok == TNAME) {
		np = name;
		lex();
		if (tok == ':') {
			sp = lookup(np);
			if (sp->addr != *cur_loc && errcnt == 0)
				fatal("out of phase: %08x %08x", sp->addr, *cur_loc);
			lex();
			goto loop;
		}
		if (tok == '=') {
			sp = lookup(np);
			lex();
			sp->addr = expr(&sp->type, &sp2);
			goto loop;
		}
		sp = lookupi(np);
		if (sp == 0)
			error("illegal instruction");
		if (sp->type == N_KW) {
			(*(void(*)(char *))sp->addr)(np);
			goto loop;
		}
		if (sp->type == N_INST) {
			parseo();
			mk_code(np);
			if (tok != '\n')
				error("extra stuff");
			goto loop;
		}
	}
	if (tok == TCONST) {
		n = value;
		lex();
		if (value >= 0 && value < 10)
		if (tok == ':') {
			/* maybe I could check that the labels match */
			lex();
			goto loop;
		}
		put_const(n, 4);
		write_instr();
		goto loop;
	}
	if (tok == '<') {
		char *cp;

		cp = get_string('>');
		write_string(*cur_bp, cp, slen);
		*cur_loc += slen;
		lex();
		goto loop;
	}
	error("syntax");
}

void
mk_tmp(int n)
{
	Tmp *p;

	assert(nxt_tmp < NTMP);
	p = &tmp[nxt_tmp++];
	p->loc = *cur_loc;
	p->type = map_type(cur_loc - locs);
	p->label = n;
}

int
map_type(int loc_sub)	/* map location counter subscript into type */
{
	return (loc_sub << 1) + N_TEXT;
}

int
lookup_tmp(int n, int before, int *type)
{
	Tmp *p, *q, *e;

	q = 0;
	e = &tmp[nxt_tmp];
	if (before) {
		for (p = tmp; p < e; p++) {
			if (!cur_seg(p->type))
				continue;
			if (p->loc > *cur_loc)
				break;
			if (p->label == n)
				q = p;
		}
		if (q == 0)
			error("missing temporary label %db", n);
		*type = q->type;
		return q->loc;
	}		
	/* else after */
	if (pass_no == 1) {
		*type = N_UNDEF;
		return 0;
	}
	for (p = tmp; p < e; p++) {
		if (!cur_seg(p->type))
			continue;
		if (p->loc >= *cur_loc)
			break;
	}
	if (p >= e)
		error("temporary %df not found", n);
	while (p < e) {
		if (p->label == n) {
			*type = p->type;
			return p->loc;
		}
		p++;
	}
	error("temporary %df not found", n);
	return 0;
}

int
term(int *type_p, Sym **spp)	/* parse and evaluate expression */
{
	Sym *sp;
	int n;

	*spp = 0;
	if (tok == '-') {
		lex();
		if (tok != TCONST)
			error("can only do unary minus with constant for now");
		*type_p = N_ABS;
		n = value;
		lex();
		return -n;
	}
	if (tok == TNAME) {
		sp = lookup(name);
		*type_p = sp->type;
		switch (sp->type & N_TYPE) {
		case N_TEXT:
		case N_DATA:
		case N_BSS:
		case N_ABS:
		case N_UNDEF:
			break;
		default:
			if (pass_no > 1)
				error("illegal type in expression");
		}
		*spp = sp;
		lex();
		if (sp->type & N_EXT)
			return 0;
		return sp->addr;
	}
	if (tok == TCONST) {
		if (value >= 0 && value <= 9) {
			n = value;
			lex();
			if (tok == TNAME)
			if (name[0] == 'f' || name[0] == 'b')
			if (name[1] == 0) {
				lex();
				if (pass_no != 2)
					return 0;
				return lookup_tmp(n, *name == 'b', type_p);
			}
			*type_p = N_ABS;
			return n;
		}
		*type_p = N_ABS;
		lex();
		return value;
	}
	pr_tok();
	error("syntax in expression");
	return 0;
}

int
prop_type(int t1, int t2, int op)	/* propagate type */
{
	int a, b;

	if (pass_no == 1)
		return t1;
	a = t1 & N_TYPE;
	b = t2 & N_TYPE;
	if (a == N_UNDEF || b == N_UNDEF)
		return N_UNDEF;
	if (a == N_ABS && b == N_ABS)
		return N_ABS;
	switch (op) {
	case '+':
		if (a == N_TEXT || a == N_DATA || a == N_BSS || t1 == N_UNDEF+N_EXT) {
			if (b != N_ABS)
				error("illegal expression");
			return t1;
		}
		if (b == N_TEXT || b == N_DATA || b == N_BSS || t2 == N_UNDEF+N_EXT) {
			if (a != N_ABS)
				error("illegal expression");
			return t2;
		}
		error("illegal expression");
	case '-':
		if (a == N_TEXT || a == N_DATA || a == N_BSS) {
			if (b == N_ABS)
				return t1;
			if (b == N_TEXT || b == N_DATA || b == N_BSS)
				return N_ABS;
		}
		/* fall thru */
	default:
		error("illegal expression");
	}
	return 0;
}

/* for now, we cheat and use the type of the first term */
int
expr(int *type_p, Sym **spp)	/* evaluate simple expressions */
{
	int t1, t2, v1, v2;
	Sym *sp1, *sp2;

	v1 = term(&t1, &sp1);
	op = 1;
again:
	switch (tok) {
	case '+':
		lex();
		op = 0;
		v2 = term(&t2, &sp2);
		t1 = prop_type(t1, t2, '+');
		v1 += v2;
		if (sp1 && sp2)
			sp1 = 0;
		if (sp2)
			sp1 = sp2;
		break;

	case '-':
		lex();
		op = 0;
		v2 = term(&t2, &sp2);
		t1 = prop_type(t1, t2, '-');
		v1 -= v2;
		if (sp1 && sp2)
			sp1 = 0;
		if (sp2)
			sp1 = sp2;
		break;

	case TLSHIFT:
		lex();
		op = 0;
		v2 = term(&t2, &sp2);
		t1 = prop_type(t1, t2, 0);
		v1 <<= v2;
		sp1 = 0;
		break;

	case TRSHIFT:
		lex();
		op = 0;
		v2 = term(&t2, &sp2);
		t1 = prop_type(t1, t2, 0);
		v1 >>= v2;
		sp1 = 0;
		break;
	default:
		*type_p = t1;
		*spp = sp1;
		return v1;
	}
	goto again;
}

/*
 * Intel 486 syntax
 */

void
parseo(void)	/* parse zero, one or two operands */
{
	int i;
	Operand *p;
	Sym *sp;

	memset(oprn, 0, sizeof oprn);
	p = oprn;
	noprn = 0;
	i = 0;
	if (tok == '\n')
		return;
	for (;;) {
		if (tok == '*') {
			p->mode |= Fabs;
			lex();
		}
		switch (tok) {
		case TNAME:
			sp = lookup(name);
			if (sp->type != N_REG)
				goto offset;
			if (sp->type == N_UNDEF)
				error("illegal register name:%s", name);
			p->type = N_REG;
			switch (sp->addr >> 3 & 7) {
			case 1:
			case 2:
				p->mode |= (sp->addr & 7) == 0 ? Fareg : Fxreg;
				break;
			case 3:
				p->mode |= Fsreg;
				break;
			default:
				error("illegal value for register (%s)", name);
			}
			p->reg = sp->addr;
			lex();
			break;

		case '$':
			lex();
			if (tok != TCONST && tok != TNAME && tok != '-')
				error("syntax");
			p->mode |= Fimm;
			p->offset = expr(&p->type, &p->sym);
			break;

		case TCONST:
		case '-':
		offset:
			p->mode |= Fdisp;
			p->offset = expr(&p->type, &p->sym);
			if (tok != '(')
				break;
			/* fall thru */
		case '(':
			p->index = 0;
			lex();
			if (tok == TNAME) {
				sp = lookup(name);
				if (sp->type != N_REG)
					error("syntax0");
				if ((sp->addr & 070) != 010)
					error("syntax1");
				p->mode |= Fmodrm;
				p->base = sp->addr;
				lex();
				if (!((1<<p->base) & Oindex))
					error("illegal index");
			}
			if (tok == ',') {
				lex();
				if (tok != TNAME)
					error("syntax2");
				sp = lookup(name);
				if (sp->type != N_REG)
					error("synxtax3");
				if ((sp->addr & 070) != 010)
					error("syntax4");
				p->index = sp->addr;
				if (!((1<<p->index) & Oindex))
					error("illegal index");
				if (p->base == p->index)
					error("duplicate index registers");
				lex();
			}
			if (tok != ')')
				error("syntax");
			lex();
			break;
		default:
			error("syntax in operand");
		}
		if (p < &oprn[NOPRN])
			p++;
		i++;
		if (tok != ',')
			break;
		lex();
	}
	noprn = i;
}

void
dbwrite(int loc, char *where, int len)
{
	print("%8.8ux: %d: ", loc, len);
	while (len--)
		print("%2.2x", *where++ & 0xFF);
	print("\n");
}

void
mk_code(char *name)
{
	Itab *ip;

	ip = omatch(name);
	format(ip);
	write_instr();
}

void
write_string(Blkptr *bp, char *where, int len)
{
	block_write(bp, where, len);
}

void
write_instr(void)
{
	if (pass_no == 2)
		block_write(*cur_bp, instr, in_offset);
	*cur_loc += in_offset;
	in_offset = 0;
}

int	
cur_seg(int type)	/* is this type the same as the current segment? */
{
	return cur_loc == &locs[type - N_TEXT >> 1];
}

int	
mag(ulong v, int bytes)
{
	ulong m;

	m = ~((1<<(bytes << 3-1)) - 1);	/* msb in mask */
	v &= m;
	if (v != 0 && (v ^ m) != 0)
		return 0;	// too big
	return 1;
}

void	/* make note of relocation requirement */
note_relo(Sym *sp, int type, int bytes, int pcrel)
{
	R *rp;

	if (pass_no != 2)
		return;
	rp = (R *)malloc(sizeof *rp);
	memset(rp, 0, sizeof *rp);
	assert (bytes == 1 || bytes == 2);
	rp->r.r_pcrel = pcrel;
	rp->r.r_length = (bytes == 1 ? 0 : bytes == 2 ? 1 : 3);
	rp->r.r_addr = *cur_loc + in_offset;
	rp->r.r_symbolnum = 0;
	if (sp && sp->type & N_EXT) {
		rp->what = sp;
		rp->r.r_extern = sp->type & N_EXT;
	} else
		rp->r.r_symbolnum = type;
	rp->next = *cur_relo;
	*cur_relo = rp;
}

void
put_const(int value, int bytes)	/* stick into instruction space */
{
	assert(in_offset < sizeof instr);
	switch (bytes) {	/* little endian */
	case 2:
		instr[in_offset++] = value;
		value >>= 8;
	case 1:
		instr[in_offset++] = value;
	}
}

void
rput(int offset, int type, int mode, Sym *sym, int n)
{
	assert (n == 1 || n == 2);
	if (pass_no == 1) {
		in_offset += n;
		return;
	}
	type &= N_TYPE;
	if (mode & (Fdisp | Fimm))
	if (type == N_TEXT || type == N_DATA || type == N_BSS || type == N_UNDEF)
		note_relo(sym, type, n, 0);
	put_const(offset, n);
}

void
put(Operand *p, int n)
{
	rput(p->offset, p->type, p->mode, p->sym, n);
}

void
disp8(Operand *p)		/* must be in same segment */
{
	int d, v;
	Sym *sp = p->sym;

	if (pass_no == 1) {
		put_const(0, 1);
		return;
	}
	if (sp) {
		if ((sp->type & N_TYPE) == N_UNDEF)
			error("disp8 undefined");
		if (!cur_seg(sp->type & N_TYPE))
			error("symbol in different segment");
		v = sp->addr;
	} else
		v = p->offset;
	d = v - (*cur_loc+in_offset+1);
	if (d < -128 || d > 127)
		error("too far");
	put_const(d, 1);
}		
	
void
disp_16(Operand *p)
{
	int d, v;
	Sym *sp = p->sym;

	if (pass_no == 1) {
		put_const(0, 2);	/* just to advance location counter */
		return;
	}
	if (sp) {
		if (!(sp->type & N_EXT) && !cur_seg(sp->type & N_TYPE))
			error("symbol in different segment");
		v = sp->addr;
	} else
		v = p->offset;
	d = v - (*cur_loc+in_offset+2);
	if (d < -0x7fff || d > 0x7fff)
		error("disp too large");
	if (sp && sp->type & N_EXT) {
		note_relo(sp, sp->type, 2, 1);
		put_const(0, 2);
	} else
		put_const(d, 2);
}

typedef struct {
	int	mask;
	int	rm;
} RM;

RM rm[] = {
	{ 1<<BX|1<<SI, 0 },
	{ 1<<BX|1<<DI, 1 },
	{ 1<<BP|1<<SI, 2 },
	{ 1<<BP|1<<DI, 3 },
	{ 1<<SI,	   4 },
	{ 1<<DI,	   5 },
	{ 1<<BP,	   6 },
	{ 1<<BX,	   7 },
	{ 0, -1 },
};

int
put_modrm(int reg, Operand *p)
{
	uchar b0;
	int m;
	RM *rp;

	b0 = reg << 3 & 070;
	if (!(p->mode & (Fdisp|Fmodrm))) {
		b0 |= p->reg & 7;
		b0 |= 0300;
		put_const(b0, 1);
		return 1;
	}
	if (!(p->mode & Fmodrm)) {
		b0 |= 6;
		put_const(b0, 1);
		put(p, 2);
		return 3;
	}

	/* [disp](base[,index]) */

	if (p->index == 0 && p->base == BP && !(p->mode & Fdisp)) {
		b0 |= 0106;
		put_const(b0, 1);
		put_const(0, 1);
		return 2;
	}

	m = 1<<p->base;
	if (p->index != 0)
		m |= 1<<p->index;
	for (rp = rm; rp->mask > 0; rp++)
		if (m == rp->mask)
			break;
	assert(rp->rm != -1);
	b0 |= rp->rm;
	if (p->mode & Fdisp) {
		b0 |= 0200;
		put_const(b0, 1);
		put(p, 2);
		return 3;
	}
	put_const(b0, 1);
	return 1;
}

int
map_size(char let)
{
	switch (let) {
	case 'b':
		return 1;
	case 'w':
		return 2;
	default:
		assert(0);
	}
	return 0;
}

/*
 * this function fills in the instruction buffer by
 * scanning the fmt string in the intstruction entry
 */

#define Fall_regs	(Freg|Fsreg)

void
format(Itab *ip)	/* format instruction using operands */
{
	Operand *reg = 0, *mod = 0, *imm, *disp = 0;
	char *cp;
	uchar byte;

	/*
	 * this is a little tricky.
	 * deduce where various things are.
	 */

	if (ip->mod > -1) {
		mod = &oprn[ip->mod];
		if (mod->mode & Fdisp)
			disp = mod;
		if (ip->noperands > 1)
		if (oprn[ip->mod ^ 1].mode & Fall_regs)	/* assume only two operands */
			reg = &oprn[ip->mod ^ 1];
	} else
		disp = &oprn[ip->noperands - 1];	/* always last */
	imm = oprn;					/* always first */

	if (ip->noperands == 1)
		reg = oprn;
	if (ip->noperands == 2 && oprn->mode & Fimm && oprn[1].mode & Freg)
		reg = &oprn[1];
	if (reg == 0)
		if (ip->omask1 & Fxreg)
			reg = oprn;
		else if (ip->omask2 & Fxreg)
			reg = &oprn[1];

	/* now, loop over format string */

	for (cp = ip->fmt; *cp; cp++) {
		switch (*cp) {
		case '0': case '1': case '2': case '3':
		case '4': case '5': case '6': case '7':
		case '8': case '9': case 'A': case 'B':
		case 'C': case 'D': case 'E': case 'F':
			byte = *cp <= '9' ? *cp - '0' : *cp - 'A' + 10;
			byte <<= 4;
			byte |= *++cp <= '9' ? *cp - '0' : *cp - 'A' + 10;
			put_const(byte, 1);
			break;

		case ' ':
			break;

		case '/':
			assert(mod);
			switch (*++cp) {
			case '0': case '1': case '2': case '3':
			case '4': case '5': case '6': case '7':
				put_modrm(*cp - '0', mod);
				break;

			case 'r':
				assert(reg);
				put_modrm(reg->reg, mod);
				break;

			default:
				assert(0);
			}
			break;

		case 'i':	/* immediate stuff at the end */
			assert(imm);
			switch (*++cp) {
			case 'b':
				if (imm->offset <0 || imm->offset > 0xff)
					error("immediate too large");
				put(imm, map_size(*cp));
				break;
			case 'w':
				if (imm->offset < -0x7fff || imm->offset > 0xffff)
					error("immediate too large");
				put(imm, map_size(*cp));
				break;
			case 'd':
				put(imm, map_size(*cp));
				break;

			default:
				assert(0);
			}
			break;

		case 'c':	/* call/jmp offsets */
			assert(disp);
			/*
			 *  could make backward jmp's smaller by
			 * doing some sort of checks here
			 */
			switch (*++cp) {
			case 'b':
				if (disp->mode & Fabs)
					error("too short for abs");
				disp8(disp);
				break;

			case 'w':
				disp_16(disp);
				break;

			default:
				assert(0);
			}
			break;
		case '+':
			cp++;
			switch (*cp) {
			case 'r':
				assert(reg);
				instr[in_offset-1] += reg->reg & 7;
				break;

			default:
				assert(0);
			}
			break;
		default:
			assert(0);
		}
	}
}


/*
 * pseudo instruction
 */

void
dot_word(char *)
{
	int t, n;
	Sym *sp;

	for(;;) {
		n = expr(&t, &sp);
		rput(n, t, Fdisp, sp, 2);
		write_instr();
		if (tok != ',')
			break;
		lex();
	};
}

void
dot_byte(char *)
{
	int t, n;
	Sym *sp;

	for (;;) {
		n = expr(&t, &sp);
		put_const(n, 1);
		write_instr();
		if (tok != ',')
			break;
		lex();
	}
}

/* 
 * by aligning with 0x90 (nop) we can reliabily dis-assemble the text
 * segments
 */

void
dot_align(char *)	/* .align <byte_align> */
{
	int n;

	if (tok != TCONST)
		error("align expects constant");
	if (value < 1 || value > 16 * 1024)
		error("align value out of range");
	n = value;
	if (n == 0)
		return;
	if (pass_no == 2 && cur_loc != &locs[2])
		while (*cur_loc % n) {
			block_write(*cur_bp, "\x90", 1);
			(*cur_loc)++;
		}
	else
		while (*cur_loc % n)
			(*cur_loc)++;
	lex();
}

void
dot_lcomm(char *)
{
	Sym *sp;

	if (cur_loc != &locs[2])
		error(".lcomm not in bss");
	if (tok != TNAME)
		error("missing name in .lcomm");
	sp = lookup(name);
	sp->addr = *cur_loc;
	sp->type = N_BSS;
	lex();
	if (tok != ',')
		error("syntax");
	lex();
	if (tok == TNAME) {
		sp = lookup(name);
		if ((sp->type & N_TYPE) == N_UNDEF)
			error(".lcomm size must be defined in first pass");
		*cur_loc += sp->addr;
		return;
	}
	if (tok == TCONST) {
		*cur_loc += value;
		lex();
		return;
	}
	error("syntax");
}

void
dot_set(char *)
{
	Sym *sp0, *sp;

	if (tok != TNAME)
		error("missing name in .set");
	sp = lookup(name);
	lex();
	if (tok != ',')
		error("syntax");
	lex();
	sp->addr = expr(&sp->type, &sp0);
}

void
dot_space(char *)
{
	Sym *sp;
	int len, size;

	SET(size);
	if (tok == TNAME) {
		sp = lookup(name);
		if ((sp->type & N_TYPE) == N_UNDEF)
			error(".space parameter must be defined in first pass");
		size = sp->addr;
	} else if (tok == TCONST)
		size = value;
	else
		error("syntax");
	if (pass_no == 2 && cur_loc != &locs[2]) {
		for (len = size; len > 4; len -= 4)
			block_write(*cur_bp, "\0\0\0\0", 4);
		if (len)
			block_write(*cur_bp, "\0\0\0\0", len);
	}
	*cur_loc += size;
	lex();
}

void
dot_globl(char *)
{
	Sym *sp;

	while (tok == TNAME) {
		sp = lookup(name);
		sp->type |= N_EXT;
		lex();
		if (tok != ',')
			break;
		lex();
	}
}

void
dot_comm(char *)
{
	Sym *sp, *sp2;
	int type;

	if (pass_no == 2) {
		while (tok != '\n')
			lex();
		return;
	}
	if (tok != TNAME)
		error(".comm expected name");
	sp = lookup(name);
	if ((sp->type & N_TYPE) != N_UNDEF)
		error("%s already defined", name);
	lex();
	if (tok != ',')
		error(".comm expected ','");
	lex();
	sp->addr = expr(&type, &sp2);
	sp->type |= N_EXT;
}

void
dot_text(char *)
{
	cur_bp = &tbp;
	cur_relo = &trelo;
	cur_loc = locs;
}

void
dot_data(char *)
{
	cur_bp = &dbp;
	cur_relo = &drelo;
	cur_loc = &locs[1];
}

void
dot_bss(char *)
{
	cur_bp = 0;
	cur_loc = &locs[2];
}

void
not_yet(char *)
{
	while (tok != '\n')
		lex();
}


void
lusyms(void)	/* list the user's symbols */
{
	Sym *sp;

	for (sp = last_sys_sym->next; sp; sp = sp->next)
		print("%08p(%04ld): %08x %08x %s\n", sp, sp - symtab, sp->type, sp->addr, sp->name);
}

/* stuff to save temporary code and relocation bits */

Blkptr *
block_open(void)	/* get new open block */
{
	Blkptr *bp;

	for (bp = blkptrs; bp->first; bp++)
		;
	if (bp == &blkptrs[NBLKPTRS])
		abort();
	bp->last = bp->first = malloc(sizeof *bp->first);
	bp->last->len = 0;
	bp->last->next = 0;
	return bp;
}

void
block_write(Blkptr *bp, void *what, int len)	/* write into block */
{
	Block *p;

	p = bp->last;
	if (len <= BLKLEN - p->len) {
		memcpy(&p->block[p->len], what, len);
		p->len += len;
		return;
	}
	bp->last->next = malloc(sizeof *bp->last->next);
	bp->last = bp->last->next;
	p = bp->last;
	p->len = len;
	p->next = 0;
	memcpy(p->block, what, len);
}

int
block_copyout(Biobuf *bp, Blkptr *blkp)	/* put block into file */
{
	int size;
	Block *p;

	size = 0;
	for (p = blkp->first; p; p = p->next) {
		size += p->len;
		Bwrite(bp, p->block, p->len);
	}
	return size;
}

void
dumpb(char *p, int len)
{
	while (len--)
		print("%02x%c", *p++ & 0xff, ((int)p & 0xF) == 0 ? '\n' : ' ');
	print("\n");
}

void
pr_oper(void)
{
	int n;
	Operand *p;

	for (n = noprn, p = oprn; n--; p++)
		print("mode 0x%x, type %x, sym %s, offset %x, reg %o, base %o, index %o, scale %d\n",
			p->mode, p->type,
			p->sym ? p->sym->name : "nil",
			p->offset, p->reg, p->base, p->index, p->scale);
}

/*
 * instructions that don't fit well into the search algorithm
 */

void
do_imul(char *name)
{
	int size, m0, m1;

	if (strcmp(name, "imul") == 0)
		size = 'w';
	else
		size = name[strlen(name)-1];
	parseo();
	switch (noprn) {
	case 1:
		switch (size) {
		case 'b':
			put_const(0xF6, 1);
			put_modrm(5, oprn);
			break;
		case 'w':
			put_const(0xF7, 1);
			put_modrm(5, oprn);
			break;
		default:
			assert(0);
		}
		break;
	case 2:
		m0 = oprn[0].mode;
		m1 = oprn[1].mode;
		if (oprn->mode == Fimm && (oprn[1].mode == Fareg || oprn[1].mode == Fxreg)) {
			switch (size) {
			case 'w':
				put_const(0x69, 1);
				put_modrm(oprn[1].reg, &oprn[1]);
				put(oprn, size == 'l' ? 4 : 2);
				break;
			default:
				goto err;
			}
		} else if ((m1 == Fareg || m1 == Fxreg) && (m0 & Fmod)) {
			switch (size) {
			case 'w':
				put_const(0x0F, 1);
				put_const(0xAF, 1);
				put_modrm(oprn[1].reg, oprn);
				break;
			default:
				goto err;
			}
		} else
			goto err;
		break;
	case 3:
		if (oprn->mode != Fimm)
			goto err;
		if ((oprn[1].mode & Fmod) == 0 || (oprn[1].mode & ~Fmod))
			goto err;
		if (oprn[2].mode != Fareg && oprn[2].mode != Fxreg)
			goto err;
		if (size != 'w')
		if (size != 'l')
			goto err;
		put_const(0x69, 1);
		put_modrm(oprn[2].reg, &oprn[1]);
		put(oprn, size == 'l' ? 4 : 2);
		break;
	default:
	err:
		pr_oper();
		error("illegal operand");
	}
	write_instr();
}

void
do_pop(char *)
{
	int size;

	size = 'w';
	parseo();
	if (noprn != 1)
		error("illegal operands");
	if (oprn->mode == Fxreg || oprn->mode == Fareg)
		put_const(0x58 + (oprn->reg & 7), 1);
	else if ((oprn->mode & Fmod) && (oprn->mode & ~Fmod) == 0) {
		if (size == 'b')
			error("illegal operand");
		put_const(0x8f, 1);
		put_modrm(0, oprn);
	} else if (oprn->mode == Fsreg) {
		switch (oprn->reg) {
		case 030:	/* ES */
			put_const(7, 1);
			break;
		case 031:	/* CS */
			error("illegal operand");
		case 032:	/* SS */
			put_const(0x17, 1);
			break;
		case 033:	/* DS */
			put_const(0x1F, 1);
			break;
		case 034:	/* FS */
			put_const(0xF, 1);
			put_const(0xA1, 1);
			break;
		case 035:	/* GS */
			put_const(0xf, 1);
			put_const(0xA9, 1);
			break;
		default:
			error("illegal operand");
		}
	} else
		error("illegal operand");
	write_instr();
}

void
do_push(char *name)
{
	int size;

	size = name[strlen(name)-1];
	if (size != 'b')
		size = 'w';
	parseo();
	if (noprn != 1)
		error("illegal operands");
	if (oprn->mode == Fxreg || oprn->mode == Fareg) {
		put_const(0x50 + (oprn->reg & 7), 1);
	} else if ((oprn->mode & Fmod) && (oprn->mode & ~Fmod) == 0) {
		if (size == 'b')
			error("illegal operand");
		put_const(0xff, 1);
		put_modrm(6, oprn);
	} else if (oprn->mode == Fsreg) {
		if (size != 'l')
			error("illegal operand");
		switch (oprn->reg) {
		case 030:	/* ES */
			put_const(6, 1);
			break;
		case 031:	/* CS */
			put_const(0xe, 1);
			break;
		case 032:	/* SS */
			put_const(0x16, 1);
			break;
		case 033:	/* DS */
			put_const(0x1e, 1);
			break;
		case 034:	/* FS */
			put_const(0xF, 1);
			put_const(0xA0, 1);
			break;
		case 035:	/* GS */
			put_const(0xf, 1);
			put_const(0xA8, 1);
			break;
		default:
			error("illegal operand");
		}
	} else if (oprn->mode == Fimm) {
		switch (size) {
		case 'b':
			put_const(0x6a, 1);
			put(oprn, 1);
			break;
		case 'w':
			put_const(0x68, 1);
			put(oprn, size == 'w' ? 2 : 4);
			break;
		}
	} else
		error("illegal operand");
	write_instr();
}

void
do_rot(char *name)
{
	int op, s;

	s = name[strlen(name)-1];
	if (s != 'b')
		s = 'w';
	parseo();
	if (noprn != 2)
		goto err;
	if (strncmp(name, "rcl", 3) == 0)
		op = 2;
	else if (strncmp(name, "rcr", 3) == 0)
		op = 3;
	else if (strncmp(name, "rol", 3) == 0)
		op = 0;
	else if (strncmp(name, "ror", 3) == 0)
		op = 1;
	else
		goto err;
	if ((oprn[1].mode & Fmod) == 0 || oprn[1].mode & ~Fmod)
		goto err;
	if (oprn->mode & Fimm) {
		if (oprn->offset == 1) {
			switch (s) {
			case 'b':
				put_const(0xd0, 1);
				put_modrm(op, &oprn[1]);
				break;
			case 'w':
				put_const(0xd1, 1);
				put_modrm(op, &oprn[1]);
				break;
			}
		} else if (oprn->offset < 128) {
			switch (s) {
			case 'b':
				put_const(0xc0, 1);
				put_modrm(op, &oprn[1]);
				put(oprn, 1);
				break;
			case 'w':
				put_const(0xc1, 1);
				put_modrm(op, &oprn[1]);
				put(oprn, 1);
				break;
			}
		} else
			goto err;
	} else if (oprn->mode & Fxreg && oprn->reg == 021) { /* CL */
		switch (s) {
		case 'b':
			put_const(0xd2, 1);
			put_modrm(op, &oprn[1]);
			break;
		case 'w':
			put_const(0xd3, 1);
			put_modrm(op, &oprn[1]);
			break;
		}
	} else
		goto err;
	write_instr();
	return;
err:
	error("illegal operand");
}

void
do_shift(char *name)
{
	int op, s;

	s = name[strlen(name)-1];
	if (s != 'b')
		s = 'w';
	parseo();
	if (noprn != 2)
		goto err;
	if (strncmp(name, "sal", 3) == 0)
		op = 4;
	else if (strncmp(name, "sar", 3) == 0)
		op = 7;
	else if (strncmp(name, "shl", 3) == 0)
		op = 4;
	else if (strncmp(name, "shr", 3) == 0)
		op = 5;
	else
		goto err;
	if ((oprn[1].mode & Fmod) == 0 || oprn[1].mode & ~Fmod)
		goto err;
	if (oprn->mode & Fimm) {
		if (oprn->offset == 1) {
			switch (s) {
			case 'b':
				put_const(0xd0, 1);
				put_modrm(op, &oprn[1]);
				break;
			case 'w':
				put_const(0xd1, 1);
				put_modrm(op, &oprn[1]);
				break;
			}
		} else if (oprn->offset < 128) {
			switch (s) {
			case 'b':
				put_const(0xc0, 1);
				put_modrm(op, &oprn[1]);
				put(oprn, 1);
				break;
			case 'w':
				put_const(0xc1, 1);
				put_modrm(op, &oprn[1]);
				put(oprn, 1);
				break;
			}
		} else
			goto err;
	} else if (oprn->mode & Fxreg && oprn->reg == 021) { /* CL */
		switch (s) {
		case 'b':
			put_const(0xd2, 1);
			put_modrm(op, &oprn[1]);
			break;
		case 'w':
			put_const(0xd3, 1);
			put_modrm(op, &oprn[1]);
			break;
		}
	} else
		goto err;
	write_instr();
	return;
err:
	error("illegal operand");
}

void
do_ljmp(char *)
{
	int sel;
	Sym *sp;

	if (tok != TCONST)
		goto err;
	sel = value;
	lex();
	if (tok != ':')
		goto err;
	lex();
	if (tok != TNAME)
		goto err;
	sp = lookup(name);
	put_const(0xEA, 1);
	rput(sp->addr, sp->type, Fdisp, sp, 2);
	put_const(sel, 2);
	while (tok != '\n')
		lex();
	write_instr();
	return;
err:
	error("syntax");
}

void
do_lcall(char *)
{
	int sel;
	Sym *sp;

	if (tok != TCONST)
		goto err;
	sel = value;
	lex();
	if (tok != ':')
		goto err;
	lex();
	if (tok != TNAME)
		goto err;
	sp = lookup(name);
	put_const(0x9A, 1);
	rput(sp->addr, sp->type, Fdisp, sp, 2);
	put_const(sel, 2);
	while (tok != '\n')
		lex();
	write_instr();
	return;
err:
	error("syntax");
}