First instruction completion implementation

+ strating args completion

Makefile.am

@@ -1,6 +1,6 @@
 bin_PROGRAMS = asmsh child
 
-libcheck_asmsh_a_SOURCES = mmap_parse.c asm_env.c compile.c logger.c
+libcheck_asmsh_a_SOURCES = mmap_parse.c asm_env.c compile.c logger.c completion.c
 
 asmsh_SOURCES = asmsh.c $(libcheck_asmsh_a_SOURCES)
 child_SOURCES = child.s

asm_env.c

@@ -157,7 +157,7 @@ int asmsh_env_step(asmsh_env_t *env, int *status)
 	}
 	if(status) { *status = env->status; }
 
-	if(!WIFSTOPPED(env->status))
+	if(!WIFSTOPPED(env->status) || env->status >> 8 != 5)
 	{
 		goto err_wstatus;
 	}
@@ -183,7 +183,9 @@ err_wstatus:
 	}
 	else if(WIFSTOPPED(env->status))
 	{
-		dprintf(2, "Child stopped by sig %d\n", WSTOPSIG(env->status));
+		dprintf(2, "Child stopped by %s(sig#%d)\n",
+				strsignal(WSTOPSIG(env->status)),
+				WSTOPSIG(env->status));
 	}
 	else
 	{

asmsh.c

@@ -7,6 +7,7 @@
 
 #include "asm_env.h"
 #include "compile.h"
+#include "completion.h"
 
 static void print_regs(asmsh_env_t *env)
 {
@@ -35,6 +36,10 @@ flags: %c%c%c%c|%c%c%c\n\
 #undef FLG
 }
 
+/*
+static char *asm_startmatch_gen(const char *text, int state)
+{
+}
 
 static char *asm_match_generator(const char *text, int state)
 {
@@ -47,8 +52,17 @@ static char **asmsh_completion(const char *text, int start, int end)
 {
 	rl_attempted_completion_over = 1;
 	//dprintf(2,"\n'%s' '%s' %d %d\n", rl_line_buffer, text, start, end);
+	//if(start == 0)
+	//{
+	//	return rl_completion_matches(text, asm_startmatch_gen);
+	//}
+	//else
+	//{
+	//	return rl_completion_matches(text, asm_match_generator);
+	//}
 	return rl_completion_matches(text, asm_match_generator);
 }
+*/
 
 
 int main(int argc, char *argv[], char *envp[])
@@ -59,6 +73,8 @@ int main(int argc, char *argv[], char *envp[])
 
 	int ret, status;
 	char *cmd;
+	char prompt[64];
+	bzero(prompt, sizeof(prompt));
 
 	if(!(env = asmsh_env(CHILD_EXEC_PATH)))
 	{
@@ -70,12 +86,17 @@ int main(int argc, char *argv[], char *envp[])
 		perror("Unable to init compilation ctx");
 	}
 
-	rl_attempted_completion_function =  asmsh_completion;
+	rl_attempted_completion_function =  asmsh_rl_completion;
+
+	status = 0;
 
 	while(1)
 	{
 		print_regs(env);
-		cmd = readline("asmsh> ");
+		snprintf(prompt, sizeof(prompt)-1,
+				"asmsh@%p > ",
+				env->regs.rip, status >> 8);
+		cmd = readline(prompt);
 		if(!cmd)
 		{
 			break;
@@ -98,20 +119,7 @@ int main(int argc, char *argv[], char *envp[])
 		ret = asmsh_env_step(env, &status);
 		if(ret)
 		{
-			if(WIFEXITED(status))
-			{
-				printf("exited with status %d\n", WEXITSTATUS(status));
-			}
-			else if(WCOREDUMP(status))
-			{
-				printf("SEGFAULT");
-				goto err;
-			}
-			else
-			{
-				printf("Unknown status %d\n", status);
-				goto err;
-			}
+			dprintf(2, "Child is dead...\n");
 			break;
 		}
 		add_history(cmd);

completion.c

@@ -0,0 +1,263 @@
+#include "completion.h"
+
+/// Replace uppper char leading macro if needed
+static int _completion_upper_macro(const char *macro, const char *start, char **ret, size_t *i);
+
+char **asmsh_completion(const char *buf, const char *text, int start, int end)
+{
+	if(end == 0)
+	{
+		// TODO catenate all !
+		return asmsh_compl_instr(text);
+	}
+	if(*buf != '.')
+	{
+		if(start == 0)
+		{
+			return asmsh_compl_instr(text);
+		}
+		return asmsh_compl_arg(buf, text, start);
+	}
+	// command completion handling
+}
+
+
+char **asmsh_compl_instr(const char *start)
+{
+	const size_t icount = sizeof(x86_64_instr)/sizeof(*x86_64_instr);
+	size_t i,j;
+	char **ret;
+	int start_len, cmp;
+	ret = malloc(icount * 2 * sizeof(char*));
+	bzero(ret, icount * sizeof(char*));
+	if(!ret)
+	{
+		perror("Unable to allocate completion result");
+		return NULL;
+	}
+	if(!start || !*start)
+	{
+		i=0;
+		for(j=0; j<icount; j++)
+		{
+			if(x86_64_instr[j].mnemo)
+			{
+				int mret = _completion_upper_macro(
+					x86_64_instr[j].mnemo,
+					"", ret, &i);
+				if(mret < 0)
+				{
+					goto err_strdup;
+				}
+				else if(mret == 0)
+				{
+					ret[i] = strdup(x86_64_instr[j].mnemo);
+					if(!ret[i])
+					{
+						goto err_strdup;
+					}
+					i++;
+				}
+			}
+			else
+			{
+				ret[i] = NULL;
+			}
+		}
+		return ret;
+	}
+	else
+	{
+		start_len = strlen(start);
+		i=0;
+		for(j=0; x86_64_instr[j].mnemo; j++)
+		{
+
+			int mret = _completion_upper_macro(
+					x86_64_instr[j].mnemo,
+					start, ret, &i);
+			if(mret < 0)
+			{
+				goto err_strdup;
+			}
+			else if(mret > 0)
+			{
+				continue; // handled by macro
+			}
+			// normal comparison
+			cmp = strncmp(start, x86_64_instr[j].mnemo, start_len);
+			if(cmp == 0)
+			{
+				ret[i]=strdup(x86_64_instr[j].mnemo);
+				if(!ret[i])
+				{
+					goto err_strdup;
+				}
+				i++;
+			}
+			else if (cmp < 0)
+			{
+				break;
+			}
+		}
+	}
+	return ret;
+
+err_strdup:
+	perror("Error while copying string for completion");
+	i--;
+	do
+	{
+		free(ret[i]);
+	}while(i>0);
+	free(ret);
+	return NULL;
+}
+
+
+
+char **asmsh_compl_arg(const char *buf, const char *text, int start)
+{
+	char **ret;
+
+	int match = -1;
+
+	for(int i=0; i<(sizeof(x86_64_instr)/sizeof(*x86_64_instr))-1; i++)
+	{
+		const char *instr = x86_64_instr[i].mnemo;
+		int ilen = strlen(instr);
+		int macro = 0;
+		if(instr[ilen-1] >= 'A' && instr[ilen-1] <= 'Z')
+		{
+			ilen--;
+			macro = 1;
+		}
+		int cmp = strncmp(buf, instr, ilen);
+		if(cmp < 0)
+		{
+			break;
+		}
+		else if(cmp > 0)
+		{
+			continue;
+		}
+		else if(!macro && (buf[ilen] != ' ' && buf[ilen] != '\t'))
+		{
+			continue; //not a full match
+		}
+		// match or approximate macro match
+		match = i;
+		break;
+	}
+	if(match < 0)
+	{
+		ret = malloc(sizeof(char*));
+		*ret = NULL;
+		return ret;
+	}
+	
+	return ret;
+}
+
+
+
+static int _completion_upper_macro(const char *macro, const char *start, char **ret, size_t *i)
+{
+	int stlen, len, oi, need_cmp;
+	char buf[32]; /* large enough */
+	char fmt[32];
+	oi = *i;
+	len = strlen(macro);
+	stlen = strlen(start);
+
+	switch(macro[len-1])
+	{
+		case 'C':
+		case 'S':
+			break;
+		default:
+			return 0;
+	}
+
+	need_cmp=1;
+	if(len > stlen)
+	{
+		if(strncmp(start, macro, stlen) == 0)
+		{
+			need_cmp = 0;
+		}
+		else
+		{
+			return 0;
+		}
+	}
+	else
+	{
+		if(strncmp(start, macro, len-1))
+		{
+			return 0;
+		}
+	}
+	
+	switch(macro[len-1])
+	{
+		case 'C':
+			memcpy(fmt, macro, len-1);
+			fmt[len-1]='%';
+			fmt[len]='s';
+			fmt[len+1]='\0';
+			for(const char * const *cc=M_conds; *cc; cc++)
+			{
+				int r = snprintf(buf, 31, fmt, *cc);
+				if(r < 0) { return -1; }
+				buf[r] = '\0';
+				if(!need_cmp || strncmp(start, buf, r<stlen?r:stlen) == 0)
+				{
+					ret[*i] = strdup(buf);
+					(*i)++;
+				}
+			}
+			break;
+		case 'S':
+			if(!need_cmp)
+			{
+				ret[*i] = strdup(macro);
+				ret[*i][len-1] = '\0';
+				(*i)++;
+				for(const char *s=M_sizes; *s; s++)
+				{
+					if(!(ret[*i] = strdup(macro)))
+					{
+						return -1;
+					}
+					ret[*i][len-1] = *s;
+					(*i)++;
+				}
+			}
+			else if(stlen == len-1)
+			{
+				ret[*i] = strdup(macro);
+				ret[*i][len-1] = '\0';
+				(*i)++;
+			}
+			else if(stlen == len)
+			{
+				for(const char *s=M_sizes; *s; s++)
+				{
+					if(*s == start[len-1])
+					{
+						if(!(ret[*i]=strdup(macro)))
+						{
+							return -1;
+						}
+						ret[*i][len-1]=*s;
+						(*i)++;
+						break;
+					}
+				}
+			}
+			break;
+	}
+	return 1;
+}
+

completion.h

@@ -0,0 +1,292 @@
+#ifndef ASMSH_COMPLETION_H
+#define ASMSH_COMPLETION_H
+#include "config.h"
+#include <errno.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#if HAVE_LIBREADLINE == 1
+#include <readline/readline.h>
+#include <readline/history.h>
+#endif
+
+#define ASHCOMP_NOARG	0x00
+#define ASHCOMP_REG8	0x01
+#define ASHCOMP_REG16	0x02
+#define ASHCOMP_REG32	0x04
+#define ASHCOMP_REG64	0x08
+#define ASHCOMP_REGALL	0x0F
+#define ASHCOMP_SEGREG	0x10
+#define ASHCOMP_IMM	0x20
+#define ASHCOMP_ADDR	0x40
+#define ASHCOMP_XMM	0x100
+#define ASHCOMP_XMM2	0x200
+#define ASHCOMP_YMM	0x400
+#define ASHCOMP_XALL	0x700
+
+typedef struct asmsh_completion_s asmsh_completion_t;
+typedef struct asmsh_compinstr_s asmsh_compinstr_t;
+typedef unsigned int flag_t;
+
+struct asmsh_compinstr_s
+{
+	const char *mnemo;
+	flag_t arg1;
+	flag_t arg2;
+};
+
+struct asmsh_completion_s
+{
+	flag_t regs;
+};
+
+char **asmsh_completion(const char *buf, const char *text, int start, int end);
+
+#if HAVE_LIBREADLINE == 1
+static char **_asmsh_completion_res;
+static char **_asmsh_completion_cur;
+static int _asmsh_completion_st[2];
+static char *asmsh_rl_completion_gen(const char *text, int state)
+{
+	if(!state)
+	{
+		_asmsh_completion_res = asmsh_completion(rl_line_buffer,
+							text,
+							_asmsh_completion_st[0],
+							_asmsh_completion_st[1]);
+		_asmsh_completion_cur = _asmsh_completion_res;
+		if(!_asmsh_completion_res)
+		{
+			return NULL;
+		}
+	}
+	char *res = *_asmsh_completion_cur;
+	if(!*_asmsh_completion_cur)
+	{
+		free(_asmsh_completion_res);
+	}
+	else
+	{
+		*_asmsh_completion_cur = NULL;
+		_asmsh_completion_cur++;
+	}
+	return res;
+}
+static char **asmsh_rl_completion(const char *text, int start, int end)
+{
+	rl_attempted_completion_over = 1;
+	_asmsh_completion_st[0]=start;
+	_asmsh_completion_st[1]=end;
+	return rl_completion_matches(text, asmsh_rl_completion_gen);
+}
+#endif
+
+/** Return all possible instructions given a start */
+char **asmsh_compl_instr(const char *start);
+
+char **asmsh_compl_arg(const char *buf, const char *text, int start);
+
+static const char * const M_conds[] = {"o","no","b","c","nae","ae","nb","nc","e","z","ne","nz","be","na","a","nbe","s","ns","p","pe","np","po","l","nge","ge","nl","le","ng","g","nle", NULL};
+static const char *M_sizes = "bwdq";
+/* Upper case letters are flags pointing to
+ * more complex completion (like conditions)
+ * C -> CMOVcc cc conditions
+ * S -> a size descriptor or nothing
+ */
+static const asmsh_compinstr_t x86_64_instr[] = {
+	{"aaa", 0, 0},
+	{"aad", ASHCOMP_IMM, 0},
+	{"aam", ASHCOMP_IMM, 0},
+	{"aas", 0, 0},
+	{"adc", 0xff, 0xff},
+	{"add", 0xff, 0xff},
+	{"and", 0xff, 0xff},
+	{"andn", 0xff, 0xff},
+	{"bextr", 0xff, 0xff},
+	{"blcfill", 0xff, 0xff},
+	{"blci", 0xff, 0xff},
+	{"blcic", 0xff, 0xff},
+	{"blcmsk", 0xff, 0xff},
+	{"blcs", 0xff, 0xff},
+	{"blsfill", 0xff, 0xff},
+	{"blsi", 0xff, 0xff},
+	{"blsic", 0xff, 0xff},
+	{"blsmsk", 0xff, 0xff},
+	{"blsr", 0xff, 0xff},
+	{"bound", 0x6|0x40, 0x6|0x40},
+	{"bsf", 0xff, 0xff},
+	{"bsr", 0xff, 0xff},
+	{"bswap", ASHCOMP_REG32 | ASHCOMP_REG64, 0},
+	{"bt", 0xff, 0},
+	{"btc", 0xff, 0},
+	{"btr", 0xff, 0},
+	{"bts", 0xff, 0},
+	{"call", 0xff, 0},
+	{"cbw", 0, 0},
+	{"cdq", 0, 0},
+	{"cdqe", 0, 0},
+	{"clc", 0, 0},
+	{"cld", 0, 0},
+	{"clflush", 0, 0},
+	{"cli", 0, 0},
+	{"cmc", 0, 0},
+	{"cmovC", 0xff, 0xff},
+	{"cmp", 0xff, 0xff},
+	{"cmpsS", 0, 0},
+	{"cmpxchg", 0xff, 0xff},
+	{"cmpxchg16b", 0xff, 0xff},
+	{"cmpxchg8b", 0xff, 0xff},
+	{"cpuid", 0, 0},
+	{"cqo", 0, 0},
+	{"crc32", 0xff, 0xff},
+	{"cwd", 0, 0},
+	{"daa", 0, 0},
+	{"das", 0, 0},
+	{"dec", 0xff, 0},
+	{"div", 0xff, 0},
+	{"enter", 0xff, 0xff},
+	{"idiv", 0xff, 0},
+	{"imul", 0xff, 0},
+	{"in", ASHCOMP_IMM, 0},
+	{"inc", 0xff, 0},
+	{"ins", 0, 0},
+	{"insd", 0, 0},
+	{"insw", 0, 0},
+	{"int", ASHCOMP_IMM, 0},
+	{"into", 0, 0},
+	{"iret", 0, 0},
+	{"iretd", 0, 0},
+	{"jC", 0xff, 0},
+	{"jmp", 0xff, 0},
+	{"lahf", 0, 0},
+	{"lds", ASHCOMP_REGALL, ASHCOMP_ADDR},
+	{"lea", ASHCOMP_REGALL, ASHCOMP_ADDR},
+	{"leave", 0xff, 0xff},
+	{"lfence", 0, 0},
+	{"lfs", ASHCOMP_REGALL, ASHCOMP_ADDR},
+	{"lgs", ASHCOMP_REGALL, ASHCOMP_ADDR},
+	{"lodsS", 0, 0},
+	{"loopC", 0xff, 0},
+	{"lss", ASHCOMP_REGALL, ASHCOMP_ADDR},
+	{"lzcnt", 0xff, 0xff},
+	{"mfence", 0, 0},
+	{"movS", 0xff, 0xff},
+	{"movbe", 0xff, 0xff},
+	{"movd", 0xff, 0xff},
+	{"movmskpd", ASHCOMP_REGALL, ASHCOMP_XALL},
+	{"movmsksps", ASHCOMP_REGALL, ASHCOMP_XALL},
+	{"movnti", 0xff, 0xff},
+	{"movsS", 0, 0},
+	{"movsx", 0xff, 0xff},
+	{"movzx", 0xff, 0xff},
+	{"mul", 0xff, 0},
+	{"neg", 0xff, 0},
+	{"nop", 0, 0},
+	{"not", 0xff, 0xff},
+	{"or", 0xff, 0xff},
+	{"out", ASHCOMP_IMM, 0},
+	{"outs", 0, 0},
+	{"outsb", 0, 0},
+	{"outsd", 0, 0},
+	{"outsw", 0, 0},
+	{"pop", 0xff, 0},
+	{"popa", 0xff, 0},
+	{"popad", 0xff, 0},
+	{"popcnt", 0xff, 0xff},
+	{"popfd", 0, 0},
+	{"popfq", 0, 0},
+	{"prefetch", ASHCOMP_ADDR, 0},
+	{"prefetch0", ASHCOMP_ADDR, 0},
+	{"prefetch1", ASHCOMP_ADDR, 0},
+	{"prefetch2", ASHCOMP_ADDR, 0},
+	{"prefetchw", ASHCOMP_ADDR, 0},
+	{"pusha", 0xff, 0},
+	{"pushad", 0xff, 0},
+	{"pushf", 0, 0},
+	{"pushfd", 0, 0},
+	{"pushfq", 0, 0},
+	{"rcl", 0xff, 0},
+	{"rcr", 0xff, 0},
+	{"ret", 0xff, 0},
+	{"rol", 0xff, 0},
+	{"ror", 0xff, 0},
+	{"sahf", 0, 0},
+	{"sal", 0xff, 0},
+	{"sar", 0xff, 0},
+	{"sbb", 0xff, 0xff},
+	{"scasS", 0, 0},
+	{"setC", 0xff, 0},
+	{"sfence", 0, 0},
+	{"shl", 0xff, 0},
+	{"shld", 0xff, 0},
+	{"shr", 0xff, 0},
+	{"shrd", 0xff, 0},
+	{"stc", 0, 0},
+	{"std", 0, 0},
+	{"sti", 0, 0},
+	{"stosS", 0, 0},
+	{"sub", 0xff, 0},
+	{"syscall", 0, 0},
+	{"sysenter", 0, 0},
+	{"sysexit", 0, 0},
+	{"t1mskc", 0xff, 0xff},
+	{"test", 0xff, 0xff},
+	{"tzcnt", 0xff, 0xff},
+	{"tzmsk", 0xff, 0xff},
+	{"vmovmksps", ASHCOMP_REGALL, ASHCOMP_XALL},
+	{"vmovmskpd", ASHCOMP_REGALL, ASHCOMP_XALL},
+	{"xadd", 0xff, 0xff},
+	{"xchg", 0xff, 0xff},
+	{"xlat", 0, 0},
+	{"xor", 0xff, 0xff},
+	{NULL,0,0}
+};
+
+static const char * const asmsh_sym_regs64[] = {
+	"rax", "rbx", "rcx", "rdx", "rbp", "rsi", "rdi", "rsp",
+	"r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",
+};
+static const char * const asmsh_sym_regs32[] = {
+	"eax", "ebx", "ecx", "edx", "esi", "edi", "ebp", "esp",
+};
+static const char * const asmsh_sym_regs16[] = {
+	"ax", "bx", "cx", "dx", "si", "di", "bp", "sp",
+};
+static const char * const asmsh_sym_regs8[] = {
+	"ah", "al", "bh", "bl", "ch", "cl", "dh", "dl"
+};
+static const char * const asmsh_sym_regsseg[] = {
+	"cs", "ds", "es", "fs", "gs", "ss",
+};
+static const char * const asmsh_sym_imm[] = {
+	"$", "$0x", "$0o",
+};
+static const char * const asmsh_sym_xmm[] = {
+	"xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
+};
+static const char * const asmsh_sym_xmm2[] = {
+	"xmm8", "xmm9", "xmm10", "xmm11", "xmm12", "xmm13", "xmm14", "xmm15",
+};
+static const char * const asmsh_sym_ymm[] = {
+	"ymm0", "ymm1", "ymm2", "ymm3", "ymm4", "ymm5", "ymm6", "ymm7",
+};
+
+typedef struct {
+	const int flag;
+	const char * const * const regs;
+} asmsh_symtable_elt_t;
+
+static const asmsh_symtable_elt_t asmsh_symtable[] = {
+	{ ASHCOMP_REG8, asmsh_sym_regs8},
+	{ ASHCOMP_REG16, asmsh_sym_regs16},
+	{ ASHCOMP_REG32, asmsh_sym_regs32},
+	{ ASHCOMP_REG64, asmsh_sym_regs64},
+	{ ASHCOMP_SEGREG, asmsh_sym_regsseg},
+	{ ASHCOMP_IMM, asmsh_sym_imm},
+	{ ASHCOMP_XMM, asmsh_sym_xmm},
+	{ ASHCOMP_XMM2, asmsh_sym_xmm2},
+	{ ASHCOMP_YMM, asmsh_sym_ymm},
+};
+
+#endif

tests/tests_completion.c

@@ -0,0 +1,48 @@
+#include "config.h"
+
+#include <check.h>
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+
+#include "asmsh_check.h"
+#include "completion.h"
+
+const char *icompl_a[] = {"a", "aaa", "aad", "aam", "aas", "adc", "add", "and", "andn", NULL};
+const char *icompl_x[] = {"x", "xadd", "xchg", "xlat", "xor", NULL};
+const char *icompl_j[] = {"j", "jo", "jno", "jb", "jc", "jnae", "jae", "jnb", "jnc", "je", "jz", "jne", "jnz", "jbe", "jna", "ja", "jnbe", "js", "jns", "jp", "jpe", "jnp", "jpo", "jl", "jnge", "jge", "jnl", "jle", "jng", "jg", "jnle", "jmp", NULL};
+const char *icompl_xa[] = {"xr", NULL};
+const char *icompl_ro[] = {"ro", "rol", "ror", NULL};
+const char *icompl_movs[] = {"movs", "movs", "movsb", "movsw", "movsd", "movsq", "movsx", NULL};
+const char *icompl_movb[] = {"movb", "movb", "movbe", NULL};
+const char **icompl[] = {icompl_a, icompl_x, icompl_j, icompl_xa, icompl_ro, icompl_movs, icompl_movb};
+int icompl_sz = sizeof(icompl)/sizeof(*icompl);
+
+START_TEST(test_instr_completions)
+{
+	const char **curcomp = icompl[_i];
+	char **ret;
+	int i;
+	ret = asmsh_compl_instr(curcomp[0]);
+	ck_assert_ptr_nonnull(ret);
+
+	i=0;
+	while(1)
+	{
+		if(!ret[i] || !curcomp[i+1])
+		{
+			ck_assert_ptr_null(ret[i]);
+			ck_assert_ptr_null(curcomp[i+1]);
+			break;
+		}
+		ck_assert_str_eq(ret[i], curcomp[i+1]);
+		free(ret[i]);
+		i++;
+	}
+	free(ret);
+}
+END_TEST
+
+ASMSH_CHECK_START("testing completion", "Testing completion features")
+	ASMSH_ADD_LOOP_TEST(test_instr_completions, 0, icompl_sz);
+ASMSH_CHECK_END