src/cmd/godefs/main.c

// Copyright 2009 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Godefs takes as input a host-compilable C file that includes
// standard system headers.  From that input file, it generates
// a standalone (no #includes) C or Go file containing equivalent
// definitions.
//
// The input C file is expected to define new types and enumerated
// constants whose names begin with $ (a legal identifier character
// in gcc).  The output is the standalone definitions of those names,
// with the $ removed.
//
// For example, if this is x.c:
//
//	#include <sys/stat.h>
//
//	typedef struct timespec $Timespec;
//	typedef struct stat $Stat;
//	enum {
//		$S_IFMT = S_IFMT,
//		$S_IFIFO = S_IFIFO,
//		$S_IFCHR = S_IFCHR,
//	};
//
// then "godefs x.c" generates:
//
//	// godefs x.c
//
//	// MACHINE GENERATED - DO NOT EDIT.
//
//	// Constants
//	enum {
//		S_IFMT = 0xf000,
//		S_IFIFO = 0x1000,
//		S_IFCHR = 0x2000,
//	};
//
//	// Types
//	#pragma pack on
//
//	typedef struct Timespec Timespec;
//	struct Timespec {
//		int32 tv_sec;
//		int32 tv_nsec;
//	};
//
//	typedef struct Stat Stat;
//	struct Stat {
//		int32 st_dev;
//		uint32 st_ino;
//		uint16 st_mode;
//		uint16 st_nlink;
//		uint32 st_uid;
//		uint32 st_gid;
//		int32 st_rdev;
//		Timespec st_atimespec;
//		Timespec st_mtimespec;
//		Timespec st_ctimespec;
//		int64 st_size;
//		int64 st_blocks;
//		int32 st_blksize;
//		uint32 st_flags;
//		uint32 st_gen;
//		int32 st_lspare;
//		int64 st_qspare[2];
//	};
//	#pragma pack off
//
// The -g flag to godefs causes it to generate Go output, not C.
// In the Go output, struct fields have leading xx_ prefixes removed
// and the first character capitalized (exported).
//
// Godefs works by invoking gcc to compile the given input file
// and then parses the debug info embedded in the assembly output.
// This is far easier than reading system headers on most machines.
//
// The -c flag sets the compiler (default "gcc").
//
// The -f flag adds a flag to pass to the compiler (e.g., -f -m64).

#include "a.h"

#ifdef __MINGW32__
int
spawn(char *prog, char **argv)
{
	return _spawnvp(P_NOWAIT, prog, (const char**)argv);
}
#undef waitfor
void
waitfor(int pid)
{
	_cwait(0, pid, 0);
}
#else
int
spawn(char *prog, char **argv)
{
	int pid = fork();
	if(pid < 0)
		sysfatal("fork: %r");
	if(pid == 0) {
		exec(argv[0], argv);
		fprint(2, "exec gcc: %r\n");
		exit(1);
	}
	return pid;
}
#endif

void
usage(void)
{
	fprint(2, "usage: godefs [-g package] [-c cc] [-f cc-arg] [defs.c ...]\n");
	exit(1);
}

int gotypefmt(Fmt*);
int ctypefmt(Fmt*);
int prefixlen(Type*);
int cutprefix(char*);

Lang go =
{
	"const (\n",
	"\t%s = %#llx;\n",
	")\n",

	"type",
	"\n",

	"type %s struct {\n",
	"type %s struct {\n",
	"\tPad%d [%d]byte;\n",
	"}\n",

	gotypefmt,
};

Lang c =
{
	"enum {\n",
	"\t%s = %#llx,\n",
	"};\n",

	"typedef",
	";\n",

	"typedef struct %s %s;\nstruct %s {\n",
	"typedef union %s %s;\nunion %s {\n",
	"\tbyte pad%d[%d];\n",
	"};\n",

	ctypefmt,
};

char *pkg;

int oargc;
char **oargv;
Lang *lang = &c;

Const *con;
int ncon;

Type **typ;
int ntyp;

void
waitforgcc(void)
{
	waitpid();
}

void
main(int argc, char **argv)
{
	int p[2], pid, i, j, n, off, npad, prefix;
	char **av, *q, *r, *tofree, *name;
	char nambuf[100];
	Biobuf *bin, *bout;
	Type *t;
	Field *f;
	int orig_output_fd;

	quotefmtinstall();

	oargc = argc;
	oargv = argv;
	av = emalloc((30+argc)*sizeof av[0]);
	atexit(waitforgcc);

	n = 0;
	av[n++] = "gcc";
	av[n++] = "-fdollars-in-identifiers";
	av[n++] = "-S";	// write assembly
	av[n++] = "-gstabs";	// include stabs info
	av[n++] = "-o";	// to ...
	av[n++] = "-";	// ... stdout
	av[n++] = "-xc";	// read C

	ARGBEGIN{
	case 'g':
		lang = &go;
		pkg = EARGF(usage());
		break;
	case 'c':
		av[0] = EARGF(usage());
		break;
	case 'f':
		av[n++] = EARGF(usage());
		break;
	default:
		usage();
	}ARGEND

	if(argc == 0)
		av[n++] = "-";
	else
		av[n++] = argv[0];
	av[n] = nil;

	orig_output_fd = dup(1, -1);
	for(i=0; i==0 || i < argc; i++) {
		// Some versions of gcc do not accept -S with multiple files.
		// Run gcc once for each file.
		// Write assembly and stabs debugging to p[1].
		if(pipe(p) < 0)
			sysfatal("pipe: %r");
		dup(p[1], 1);
		close(p[1]);
		if (argc)
			av[n-1] = argv[i];
		pid = spawn(av[0], av);
		dup(orig_output_fd, 1);

		// Read assembly, pulling out .stabs lines.
		bin = Bfdopen(p[0], OREAD);
		while((q = Brdstr(bin, '\n', 1)) != nil) {
			//	.stabs	"float:t(0,12)=r(0,1);4;0;",128,0,0,0
			tofree = q;
			while(*q == ' ' || *q == '\t')
				q++;
			if(strncmp(q, ".stabs", 6) != 0)
				goto Continue;
			q += 6;
			while(*q == ' ' || *q == '\t')
				q++;
			if(*q++ != '\"') {
Bad:
				sysfatal("cannot parse .stabs line:\n%s", tofree);
			}

			r = strchr(q, '\"');
			if(r == nil)
				goto Bad;
			*r++ = '\0';
			if(*r++ != ',')
				goto Bad;
			if(*r < '0' || *r > '9')
				goto Bad;
			if(atoi(r) != 128)	// stabs kind = local symbol
				goto Continue;

			parsestabtype(q);

Continue:
			free(tofree);
		}
		Bterm(bin);
		waitfor(pid);
	}
	close(orig_output_fd);

	// Write defs to standard output.
	bout = Bfdopen(1, OWRITE);
	fmtinstall('T', lang->typefmt);

	// Echo original command line in header.
	Bprint(bout, "//");
	for(i=0; i<oargc; i++)
		Bprint(bout, " %q", oargv[i]);
	Bprint(bout, "\n");
	Bprint(bout, "\n");
	Bprint(bout, "// MACHINE GENERATED - DO NOT EDIT.\n");
	Bprint(bout, "\n");

	if(pkg)
		Bprint(bout, "package %s\n\n", pkg);

	// Constants.
	Bprint(bout, "// Constants\n");
	if(ncon > 0) {
		Bprint(bout, lang->constbegin);
		for(i=0; i<ncon; i++) {
			// Go can handle negative constants,
			// but C enums may not be able to.
			if(lang == &go)
				Bprint(bout, lang->constfmt, con[i].name, con[i].value);
			else
				Bprint(bout, lang->constfmt, con[i].name, con[i].value & 0xFFFFFFFF);
		}
		Bprint(bout, lang->constend);
	}
	Bprint(bout, "\n");

	// Types

	// push our names down
	for(i=0; i<ntyp; i++) {
		t = typ[i];
		name = t->name;
		while(t && t->kind == Typedef)
			t = t->type;
		if(t)
			t->name = name;
	}

	Bprint(bout, "// Types\n");

	// Have to turn off structure padding in Plan 9 compiler,
	// mainly because it is more aggressive than gcc tends to be.
	if(lang == &c)
		Bprint(bout, "#pragma pack on\n");

	for(i=0; i<ntyp; i++) {
		Bprint(bout, "\n");
		t = typ[i];
		name = t->name;
		while(t && t->kind == Typedef) {
			if(name == nil && t->name != nil) {
				name = t->name;
				if(t->printed)
					break;
			}
			t = t->type;
		}
		if(name == nil && t->name != nil) {
			name = t->name;
			if(t->printed)
				continue;
			t->printed = 1;
		}
		if(name == nil) {
			fprint(2, "unknown name for %T", typ[i]);
			continue;
		}
		if(name[0] == '$')
			name++;
		npad = 0;
		off = 0;
		switch(t->kind) {
		case 0:
			fprint(2, "unknown type definition for %s\n", name);
			break;
		default:	// numeric, array, or pointer
		case Array:
		case Ptr:
			Bprint(bout, "%s %lT%s", lang->typdef, name, t, lang->typdefend);
			break;
		case Union:
			// In Go, print union as struct with only first element,
			// padded the rest of the way.
			Bprint(bout, lang->unionbegin, name, name, name);
			goto StructBody;
		case Struct:
			Bprint(bout, lang->structbegin, name, name, name);
		StructBody:
			prefix = 0;
			if(lang == &go)
				prefix = prefixlen(t);
			for(j=0; j<t->nf; j++) {
				f = &t->f[j];
				// padding
				if(t->kind == Struct || lang == &go) {
					if(f->offset%8 != 0 || f->size%8 != 0) {
						fprint(2, "ignoring bitfield %s.%s\n", t->name, f->name);
						continue;
					}
					if(f->offset < off)
						sysfatal("%s: struct fields went backward", t->name);
					if(off < f->offset) {
						Bprint(bout, lang->structpadfmt, npad++, (f->offset - off) / 8);
						off = f->offset;
					}
					off += f->size;
				}
				name = f->name;
				if(cutprefix(name))
					name += prefix;
				if(strcmp(name, "") == 0) {
					snprint(nambuf, sizeof nambuf, "Pad%d", npad++);
					name = nambuf;
				}
				Bprint(bout, "\t%#lT;\n", name, f->type);
				if(t->kind == Union && lang == &go)
					break;
			}
			// final padding
			if(t->kind == Struct || lang == &go) {
				if(off/8 < t->size)
					Bprint(bout, lang->structpadfmt, npad++, t->size - off/8);
			}
			Bprint(bout, lang->structend);
		}
	}
	if(lang == &c)
		Bprint(bout, "#pragma pack off\n");
	Bterm(bout);
	exit(0);
}

char *kindnames[] = {
	"void",	// actually unknown, but byte is good for pointers
	"void",
	"int8",
	"uint8",
	"int16",
	"uint16",
	"int32",
	"uint32",
	"int64",
	"uint64",
	"float32",
	"float64",
	"ptr",
	"struct",
	"array",
	"union",
	"typedef",
};

int
ctypefmt(Fmt *f)
{
	char *name, *s;
	Type *t;

	name = nil;
	if(f->flags & FmtLong) {
		name = va_arg(f->args, char*);
		if(name == nil || name[0] == '\0')
			name = "_anon_";
	}
	t = va_arg(f->args, Type*);
	while(t && t->kind == Typedef)
		t = t->type;
	switch(t->kind) {
	case Struct:
	case Union:
		// must be named
		s = t->name;
		if(s == nil) {
			fprint(2, "need name for anonymous struct\n");
			goto bad;
		}
		else if(s[0] != '$')
			fprint(2, "need name for struct %s\n", s);
		else
			s++;
		fmtprint(f, "%s", s);
		if(name)
			fmtprint(f, " %s", name);
		break;

	case Array:
		if(name)
			fmtprint(f, "%T %s[%d]", t->type, name, t->size);
		else
			fmtprint(f, "%T[%d]", t->type, t->size);
		break;

	case Ptr:
		if(name)
			fmtprint(f, "%T *%s", t->type, name);
		else
			fmtprint(f, "%T*", t->type);
		break;

	default:
		fmtprint(f, "%s", kindnames[t->kind]);
		if(name)
			fmtprint(f, " %s", name);
		break;

	bad:
		if(name)
			fmtprint(f, "byte %s[%d]", name, t->size);
		else
			fmtprint(f, "byte[%d]", t->size);
		break;
	}

	return 0;
}

int
gotypefmt(Fmt *f)
{
	char *name, *s;
	Type *t;

	if(f->flags & FmtLong) {
		name = va_arg(f->args, char*);
		if('a' <= name[0] && name[0] <= 'z')
			name[0] += 'A' - 'a';
		if(name[0] == '_' && (f->flags & FmtSharp))
			fmtprint(f, "X");
		fmtprint(f, "%s ", name);
	}
	t = va_arg(f->args, Type*);
	while(t && t->kind == Typedef)
		t = t->type;

	switch(t->kind) {
	case Struct:
	case Union:
		// must be named
		s = t->name;
		if(s == nil) {
			fprint(2, "need name for anonymous struct\n");
			fmtprint(f, "STRUCT");
		}
		else if(s[0] != '$') {
			fprint(2, "warning: missing name for struct %s\n", s);
			fmtprint(f, "[%d]byte /* %s */", t->size, s);
		} else
			fmtprint(f, "%s", s+1);
		break;

	case Array:
		fmtprint(f, "[%d]%T", t->size, t->type);
		break;

	case Ptr:
		fmtprint(f, "*%T", t->type);
		break;

	default:
		s = kindnames[t->kind];
		if(strcmp(s, "void") == 0)
			s = "byte";
		fmtprint(f, "%s", s);
	}

	return 0;
}

// Is this the kind of name we should cut a prefix from?
// The rule is that the name cannot begin with underscore
// and must have an underscore eventually.
int
cutprefix(char *name)
{
	char *p;

	// special case: orig_ in register struct
	if(strncmp(name, "orig_", 5) == 0)
		return 0;

	for(p=name; *p; p++) {
		if(*p == '_')
			return p-name > 0;
	}
	return 0;
}

// Figure out common struct prefix len
int
prefixlen(Type *t)
{
	int i;
	int len;
	char *p, *name;
	Field *f;

	len = 0;
	name = nil;
	for(i=0; i<t->nf; i++) {
		f = &t->f[i];
		if(!cutprefix(f->name))
			continue;
		p = strchr(f->name, '_');
		if(p == nil)
			return 0;
		if(name == nil) {
			name = f->name;
			len = p+1 - name;
		}
		else if(strncmp(f->name, name, len) != 0)
			return 0;
	}
	return len;
}