name mangling, process control

src/libmach/manglegcc2.c

@@ -0,0 +1,337 @@
+/*
+ * gcc2 name demangler.
+ */
+#include <u.h>
+#include <libc.h>
+#include <bio.h>
+#include <mach.h>
+
+#define debug 0
+
+typedef struct Chartab Chartab;
+struct Chartab
+{
+	char c;
+	char *s;
+};
+
+static char*
+chartabsearch(Chartab *ct, int c)
+{
+	for(; ct->c; ct++)
+		if(ct->c == c)
+			return ct->s;
+	return nil;
+}
+
+typedef struct Gccstate Gccstate;
+struct Gccstate
+{
+	char *name[128];
+	int nname;
+};
+static int gccname(char**, char**, Gccstate*);
+char*
+demanglegcc2(char *s, char *buf)
+{
+	char *p, *os, *name, *t;
+	int namelen;
+	Gccstate state;
+	
+	state.nname = 0;
+	os = s;
+	p = buf;
+
+	if(memcmp(os, "_._", 3) == 0){
+		name = "destructor";
+		namelen = strlen(name);
+		s = os+3;
+	}else{
+		/* the mangled part begins with the final __ */
+		if((s = strstr(os, "__")) == nil)
+			return os;
+		do{
+			t = s;
+			if(strchr("123456789FHQt", s[2]))
+				break;
+		}while((s = strstr(t+1, "__")) != nil);
+		
+		s = t;
+		name = os;
+		namelen = t - os;
+		if(namelen == 0){
+			name = "constructor";
+			namelen = strlen(name);
+		}
+		s += 2;
+	}
+
+	switch(*s){
+	default:
+		return os;
+
+	case 'F':	/* plain function */
+		s++;
+		break;
+	
+	case 'Q':
+	case 'H':
+	case 't':
+	case '1': case '2': case '3': case '4':
+	case '5': case '6': case '7': case '8': case '9':
+		if(!gccname(&s, &p, &state)){
+			if(debug) fprint(2, "bad name: %s\n", os);
+			return os;
+		}
+		strcpy(p, "::");
+		p += 2;
+		break;
+	}
+
+	memmove(p, name, namelen);
+	p += namelen;
+
+	if(*s && *s != '_'){
+		/* the rest of the name is the argument types */
+		*p++ = '(';
+		while(*s != 0 && *s != '_' && gccname(&s, &p, &state))
+			*p++ = ',';
+		if(*(p-1) == ',')
+			p--;
+		*p++ = ')';
+	}
+	
+	if(*s == '_'){
+		/* the remainder is the type of the return value */
+	}
+
+	*p = 0;
+	return buf;
+}
+
+static Chartab typetab[] =
+{
+	'b',	"bool",
+	'c',	"char",
+	'd',	"double",
+	'i',	"int",
+	'l',	"long",
+	'v',	"void",
+	0, 0
+};
+
+static int
+gccnumber(char **ps, int *pn)
+{
+	char *s;
+	int n;
+	
+	s = *ps;
+	if(!isdigit((uchar)*s))
+		return 0;
+	n = strtol(s, &s, 10);
+	if(*s == '_')
+		s++;
+	*ps = s;
+	*pn = n;
+	return 1;
+}
+
+/*
+ * Pick apart the next mangled name section.
+ * Names and types are treated as the same.
+ * Let's see how far we can go before that becomes a problem.
+ */
+static int
+gccname(char **ps, char **pp, Gccstate *state)
+{
+	int i, n, m, val;
+	char c, *os, *s, *t, *p;
+	
+	s = *ps;
+	os = s;
+	p = *pp;
+
+/*	print("\tgccname: %s\n", s); */
+
+#if 0
+	/* overloaded operators */
+	for(i=0; operators[i].shrt; i++){
+		if(memcmp(operators[i].shrt, s, 2) == 0){
+			strcpy(p, "operator$");
+			strcat(p, operators[i].lng);
+			p += strlen(p);
+			s += 2;
+			goto suffix;
+		}
+	}
+#endif
+	/* basic types */
+	if((t = chartabsearch(typetab, *s)) != nil){
+		s++;
+		strcpy(p, t);
+		p += strlen(t);
+		goto suffix;
+	}
+
+	switch(*s){
+	default:
+	bad:
+		if(debug) fprint(2, "gccname: %s (%s)\n", os, s);
+		return 0;
+
+	case '1': case '2': case '3': case '4':	/* name length */
+	case '5': case '6': case '7': case '8': case '9':
+		n = strtol(s, &s, 10);
+		memmove(p, s, n);
+		p += n;
+		s += n;
+		break;
+
+	case 'C':	/* const */
+		s++;
+		strcpy(p, "const ");
+		p += strlen(p);
+		if(!gccname(&s, &p, state))
+			return 0;
+		break;
+
+	case 'U':	/* unsigned */
+		s++;
+		strcpy(p, "unsigned ");
+		p += strlen(p);
+		if(!gccname(&s, &p, state))
+			return 0;
+		break;
+
+#if 0
+	case 'L':	/* default value */
+		t = s;
+		s++;
+		if(!gccname(&s, &p, state))
+			return 0;
+		if(!isdigit((uchar)*s)){
+			fprint(2, "bad value: %s\n", t);
+			return 0;
+		}
+		n = strtol(s, &s, 10);
+		if(*s != 'E'){
+			fprint(2, "bad value2: %s\n", t);
+			return 0;
+		}
+		sprint(p, "=%d", n);
+		p += strlen(p);
+		s++;
+		break;
+#endif
+
+	case 'N':	/* repeated name/type */
+	case 'X':
+		c = *s++;
+		if(!isdigit((uchar)*s) || !isdigit((uchar)*(s+1)))
+			goto bad;
+		n = *s++ - '0';
+		m = *s++ - '0';
+		sprint(p, "%c%d/%d", c, n, m);
+		p += strlen(p);
+		break;
+
+	case 'Q':	/* hierarchical name */
+		s++;
+		if(!isdigit((uchar)*s))
+			goto bad;
+		n = *s++ - '0';
+		for(i=0; i<n; i++){
+			if(!gccname(&s, &p, state)){
+				if(debug) fprint(2, "bad name in hierarchy: %s in %s\n", s, os);
+				return 0;
+			}
+			if(i+1 < n){
+				strcpy(p, "::");
+				p += 2;
+			}
+		}
+		break;
+	
+	case 'P':	/* pointer to */
+		s++;
+		if(!gccname(&s, &p, state))
+			return 0;
+		*p++ = '*';
+		break;
+
+	case 'R':	/* reference to */
+		s++;
+		if(!gccname(&s, &p, state))
+			return 0;
+		*p++ = '&';
+		break;
+
+	case 'S':	/* standard or previously-seen name */
+		s++;
+		if('0' <= *s && *s <= '9'){
+			/* previously seen */
+			t = s-1;
+			n = strtol(s, &s, 10);
+			if(*s != '_'){
+				fprint(2, "bad S: %s\n", t);
+				return 0;
+			}
+			s++;
+			sprint(p, "S%d_", n);
+			p += strlen(p);
+			break;
+		}
+		goto bad;
+
+	case 't':	/* named template */
+		c = *s++;
+		if(!gccname(&s, &p, state))
+			return 0;
+		goto template;
+	case 'H':	/* nameless template */
+		c = *s++;
+	template:
+		if(!gccnumber(&s, &n))
+			goto bad;
+		*p++ = '<';
+		for(i=0; i<n; i++){
+			val = 1;
+			if(*s == 'Z'){
+				val = 0;
+				s++;
+			}
+			if(!gccname(&s, &p, state))
+				goto bad;
+			if(val){
+				if(!gccnumber(&s, &m))
+					goto bad;
+				sprint(p, "=%d", m);
+				p += strlen(p);
+			}
+			if(i+1 < n)
+				*p++ = ',';
+		}
+		*p++ = '>';
+		if(c == 'H'){
+			if(*s != '_')
+				goto bad;
+			s++;
+		}
+		break;
+
+	case 'T':	/* previously-seen type??? e.g., T2 */
+		t = s;
+		for(s++; isdigit((uchar)*s); s++)
+			;
+		memmove(p, t, s-t);
+		p += s-t;
+		break;		
+	}
+
+suffix:	
+	*ps = s;
+	*pp = p;
+	return 1;
+}
+