[mirror_qemu.git] / Makefile

include config.mak

CFLAGS=-Wall -O2 -g
LDFLAGS=-g
LIBS=
DEFINES=-DHAVE_BYTESWAP_H
HELPER_CFLAGS=$(CFLAGS)

ifdef CONFIG_STATIC
LDFLAGS+=-static
endif

ifeq ($(ARCH),i386)
CFLAGS+=-fomit-frame-pointer
OP_CFLAGS=$(CFLAGS) -mpreferred-stack-boundary=2
ifeq ($(GCC_MAJOR),3)
OP_CFLAGS+= -falign-functions=0
else
OP_CFLAGS+= -malign-functions=0
endif
ifdef TARGET_GPROF
LDFLAGS+=-Wl,-T,i386.ld
else
# WARNING: this LDFLAGS is _very_ tricky : qemu is an ELF shared object
# that the kernel ELF loader considers as an executable. I think this
# is the simplest way to make it self virtualizable!
LDFLAGS+=-Wl,-shared
endif
endif

ifeq ($(ARCH),ppc)
OP_CFLAGS=$(CFLAGS)
LDFLAGS+=-Wl,-T,ppc.ld
endif

ifeq ($(ARCH),s390)
OP_CFLAGS=$(CFLAGS)
LDFLAGS+=-Wl,-T,s390.ld
endif

ifeq ($(ARCH),sparc)
CFLAGS+=-m32 -ffixed-g1 -ffixed-g2 -ffixed-g3 -ffixed-g6
LDFLAGS+=-m32
OP_CFLAGS=$(CFLAGS) -fno-delayed-branch -ffixed-i0
HELPER_CFLAGS=$(CFLAGS) -ffixed-i0 -mflat
LDFLAGS+=-Wl,-T,sparc.ld
endif

ifeq ($(ARCH),sparc64)
CFLAGS+=-m64 -ffixed-g1 -ffixed-g2 -ffixed-g3 -ffixed-g6
LDFLAGS+=-m64
OP_CFLAGS=$(CFLAGS) -fno-delayed-branch -ffixed-i0
endif

ifeq ($(ARCH),alpha)
# -msmall-data is not used because we want two-instruction relocations
# for the constant constructions
OP_CFLAGS=-Wall -O2 -g
# Ensure there's only a single GP
CFLAGS += -msmall-data
LDFLAGS+=-Wl,-T,alpha.ld
endif

ifeq ($(ARCH),ia64)
OP_CFLAGS=$(CFLAGS)
endif

ifeq ($(ARCH),arm)
OP_CFLAGS=$(CFLAGS) -mno-sched-prolog
LDFLAGS+=-Wl,-T,arm.ld
endif

ifeq ($(GCC_MAJOR),3)
# very important to generate a return at the end of every operation
OP_CFLAGS+=-fno-reorder-blocks -fno-optimize-sibling-calls
endif

#########################################################

DEFINES+=-D_GNU_SOURCE
LIBS+=-lm

# profiling code
ifdef TARGET_GPROF
LDFLAGS+=-p
main.o: CFLAGS+=-p
endif

OBJS= elfload.o main.o syscall.o mmap.o signal.o path.o
ifeq ($(TARGET_ARCH), i386)
OBJS+= vm86.o
endif
SRCS:= $(OBJS:.o=.c)
OBJS+= libqemu.a

# cpu emulator library
LIBOBJS=thunk.o exec.o translate.o cpu-exec.o 

ifeq ($(TARGET_ARCH), i386)
LIBOBJS+=translate-i386.o op-i386.o helper-i386.o
endif
ifeq ($(TARGET_ARCH), arm)
LIBOBJS+=translate-arm.o op-arm.o
endif

# NOTE: the disassembler code is only needed for debugging
LIBOBJS+=disas.o 
ifeq ($(findstring i386, $(TARGET_ARCH) $(ARCH)),i386)
LIBOBJS+=i386-dis.o
endif
ifeq ($(findstring alpha, $(TARGET_ARCH) $(ARCH)),alpha)
LIBOBJS+=alpha-dis.o
endif
ifeq ($(findstring ppc, $(TARGET_ARCH) $(ARCH)),ppc)
LIBOBJS+=ppc-dis.o
endif
ifeq ($(findstring sparc, $(TARGET_ARCH) $(ARCH)),sparc)
LIBOBJS+=sparc-dis.o
endif
ifeq ($(findstring arm, $(TARGET_ARCH) $(ARCH)),arm)
LIBOBJS+=arm-dis.o
endif

ifeq ($(ARCH),ia64)
OBJS += ia64-syscall.o
endif

all: qemu qemu-doc.html

qemu: $(OBJS)
	$(CC) $(LDFLAGS) -o $@ $^  $(LIBS)
ifeq ($(ARCH),alpha)
# Mark as 32 bit binary, i. e. it will be mapped into the low 31 bit of
# the address space (31 bit so sign extending doesn't matter)
	echo -ne '\001\000\000\000' | dd of=qemu bs=1 seek=48 count=4 conv=notrunc
endif

depend: $(SRCS)
	$(CC) -MM $(CFLAGS) $^ 1>.depend

# libqemu 

libqemu.a: $(LIBOBJS)
	rm -f $@
	$(AR) rcs $@ $(LIBOBJS)

dyngen: dyngen.c
	$(HOST_CC) -O2 -Wall -g $< -o $@

translate-$(TARGET_ARCH).o: translate-$(TARGET_ARCH).c gen-op-$(TARGET_ARCH).h opc-$(TARGET_ARCH).h cpu-$(TARGET_ARCH).h

translate.o: translate.c op-$(TARGET_ARCH).h opc-$(TARGET_ARCH).h cpu-$(TARGET_ARCH).h

op-$(TARGET_ARCH).h: op-$(TARGET_ARCH).o dyngen
	./dyngen -o $@ $<

opc-$(TARGET_ARCH).h: op-$(TARGET_ARCH).o dyngen
	./dyngen -c -o $@ $<

gen-op-$(TARGET_ARCH).h: op-$(TARGET_ARCH).o dyngen
	./dyngen -g -o $@ $<

op-$(TARGET_ARCH).o: op-$(TARGET_ARCH).c
	$(CC) $(OP_CFLAGS) $(DEFINES) -c -o $@ $<

helper-$(TARGET_ARCH).o: helper-$(TARGET_ARCH).c
	$(CC) $(HELPER_CFLAGS) $(DEFINES) -c -o $@ $<

op-i386.o: op-i386.c opreg_template.h ops_template.h

op-arm.o: op-arm.c op-arm-template.h

%.o: %.c
	$(CC) $(CFLAGS) $(DEFINES) -c -o $@ $<

clean:
	$(MAKE) -C tests clean
	rm -f *.o  *.a *~ qemu dyngen TAGS

distclean: clean
	rm -f config.mak config.h

install: qemu
	install -m 755 -s qemu $(prefix)/bin

# various test targets
test speed: qemu
	make -C tests $@

TAGS: 
	etags *.[ch] tests/*.[ch]

# documentation
qemu-doc.html: qemu-doc.texi
	texi2html -monolithic -number $<

FILES= \
README README.distrib COPYING COPYING.LIB TODO Changelog VERSION \
configure \
dyngen.c dyngen.h dyngen-exec.h ioctls.h syscall_types.h \
Makefile elf.h elfload.c main.c signal.c qemu.h \
syscall.c syscall_defs.h vm86.c path.c mmap.c \
ppc.ld alpha.ld s390.ld sparc.ld arm.ld\
thunk.c cpu-exec.c translate.c cpu-all.h thunk.h exec.h\
exec.c cpu-exec.c\
cpu-i386.h op-i386.c helper-i386.c syscall-i386.h translate-i386.c \
exec-i386.h ops_template.h op_string.h opreg_template.h \
cpu-arm.h syscall-arm.h exec-arm.h op-arm.c translate-arm.c op-arm-template.h \
dis-asm.h disas.c disas.h alpha-dis.c ppc-dis.c i386-dis.c sparc-dis.c \
arm-dis.c \
tests/Makefile \
tests/test-i386.c tests/test-i386-shift.h tests/test-i386.h \
tests/test-i386-muldiv.h tests/test-i386-code16.S tests/test-i386-vm86.S \
tests/hello.c tests/hello \
tests/hello-arm.c tests/hello-arm \
tests/sha1.c \
tests/testsig.c tests/testclone.c tests/testthread.c \
tests/runcom.c tests/pi_10.com \
tests/test_path.c \
qemu-doc.texi qemu-doc.html

FILE=qemu-$(VERSION)

tar:
	rm -rf /tmp/$(FILE)
	mkdir -p /tmp/$(FILE)
	cp -P $(FILES) /tmp/$(FILE)
	( cd /tmp ; tar zcvf ~/$(FILE).tar.gz $(FILE) )
	rm -rf /tmp/$(FILE)

# generate a binary distribution including the test binary environnment 
BINPATH=/usr/local/qemu-i386

tarbin:
	tar zcvf /tmp/qemu-$(VERSION)-i386-glibc21.tar.gz \
                 $(BINPATH)/etc $(BINPATH)/lib $(BINPATH)/bin $(BINPATH)/usr
	tar zcvf /tmp/qemu-$(VERSION)-i386-wine.tar.gz \
                 $(BINPATH)/wine

ifneq ($(wildcard .depend),)
include .depend
endif
Commit	Line	Data
	1	include config.mak
	2
	3	CFLAGS=-Wall -O2 -g
	4	LDFLAGS=-g
	5	LIBS=
	6	DEFINES=-DHAVE_BYTESWAP_H
	7	HELPER_CFLAGS=$(CFLAGS)
	8
	9	ifdef CONFIG_STATIC
	10	LDFLAGS+=-static
	11	endif
	12
	13	ifeq ($(ARCH),i386)
	14	CFLAGS+=-fomit-frame-pointer
	15	OP_CFLAGS=$(CFLAGS) -mpreferred-stack-boundary=2
	16	ifeq ($(GCC_MAJOR),3)
	17	OP_CFLAGS+= -falign-functions=0
	18	else
	19	OP_CFLAGS+= -malign-functions=0
	20	endif
	21	ifdef TARGET_GPROF
	22	LDFLAGS+=-Wl,-T,i386.ld
	23	else
	24	# WARNING: this LDFLAGS is _very_ tricky : qemu is an ELF shared object
	25	# that the kernel ELF loader considers as an executable. I think this
	26	# is the simplest way to make it self virtualizable!
	27	LDFLAGS+=-Wl,-shared
	28	endif
	29	endif
	30
	31	ifeq ($(ARCH),ppc)
	32	OP_CFLAGS=$(CFLAGS)
	33	LDFLAGS+=-Wl,-T,ppc.ld
	34	endif
	35
	36	ifeq ($(ARCH),s390)
	37	OP_CFLAGS=$(CFLAGS)
	38	LDFLAGS+=-Wl,-T,s390.ld
	39	endif
	40
	41	ifeq ($(ARCH),sparc)
	42	CFLAGS+=-m32 -ffixed-g1 -ffixed-g2 -ffixed-g3 -ffixed-g6
	43	LDFLAGS+=-m32
	44	OP_CFLAGS=$(CFLAGS) -fno-delayed-branch -ffixed-i0
	45	HELPER_CFLAGS=$(CFLAGS) -ffixed-i0 -mflat
	46	LDFLAGS+=-Wl,-T,sparc.ld
	47	endif
	48
	49	ifeq ($(ARCH),sparc64)
	50	CFLAGS+=-m64 -ffixed-g1 -ffixed-g2 -ffixed-g3 -ffixed-g6
	51	LDFLAGS+=-m64
	52	OP_CFLAGS=$(CFLAGS) -fno-delayed-branch -ffixed-i0
	53	endif
	54
	55	ifeq ($(ARCH),alpha)
	56	# -msmall-data is not used because we want two-instruction relocations
	57	# for the constant constructions
	58	OP_CFLAGS=-Wall -O2 -g
	59	# Ensure there's only a single GP
	60	CFLAGS += -msmall-data
	61	LDFLAGS+=-Wl,-T,alpha.ld
	62	endif
	63
	64	ifeq ($(ARCH),ia64)
	65	OP_CFLAGS=$(CFLAGS)
	66	endif
	67
	68	ifeq ($(ARCH),arm)
	69	OP_CFLAGS=$(CFLAGS) -mno-sched-prolog
	70	LDFLAGS+=-Wl,-T,arm.ld
	71	endif
	72
	73	ifeq ($(GCC_MAJOR),3)
	74	# very important to generate a return at the end of every operation
	75	OP_CFLAGS+=-fno-reorder-blocks -fno-optimize-sibling-calls
	76	endif
	77
	78	#########################################################
	79
	80	DEFINES+=-D_GNU_SOURCE
	81	LIBS+=-lm
	82
	83	# profiling code
	84	ifdef TARGET_GPROF
	85	LDFLAGS+=-p
	86	main.o: CFLAGS+=-p
	87	endif
	88
	89	OBJS= elfload.o main.o syscall.o mmap.o signal.o path.o
	90	ifeq ($(TARGET_ARCH), i386)
	91	OBJS+= vm86.o
	92	endif
	93	SRCS:= $(OBJS:.o=.c)
	94	OBJS+= libqemu.a
	95
	96	# cpu emulator library
	97	LIBOBJS=thunk.o exec.o translate.o cpu-exec.o
	98
	99	ifeq ($(TARGET_ARCH), i386)
	100	LIBOBJS+=translate-i386.o op-i386.o helper-i386.o
	101	endif
	102	ifeq ($(TARGET_ARCH), arm)
	103	LIBOBJS+=translate-arm.o op-arm.o
	104	endif
	105
	106	# NOTE: the disassembler code is only needed for debugging
	107	LIBOBJS+=disas.o
	108	ifeq ($(findstring i386, $(TARGET_ARCH) $(ARCH)),i386)
	109	LIBOBJS+=i386-dis.o
	110	endif
	111	ifeq ($(findstring alpha, $(TARGET_ARCH) $(ARCH)),alpha)
	112	LIBOBJS+=alpha-dis.o
	113	endif
	114	ifeq ($(findstring ppc, $(TARGET_ARCH) $(ARCH)),ppc)
	115	LIBOBJS+=ppc-dis.o
	116	endif
	117	ifeq ($(findstring sparc, $(TARGET_ARCH) $(ARCH)),sparc)
	118	LIBOBJS+=sparc-dis.o
	119	endif
	120	ifeq ($(findstring arm, $(TARGET_ARCH) $(ARCH)),arm)
	121	LIBOBJS+=arm-dis.o
	122	endif
	123
	124	ifeq ($(ARCH),ia64)
	125	OBJS += ia64-syscall.o
	126	endif
	127
	128	all: qemu qemu-doc.html
	129
	130	qemu: $(OBJS)
	131	$(CC) $(LDFLAGS) -o $@ $^ $(LIBS)
	132	ifeq ($(ARCH),alpha)
	133	# Mark as 32 bit binary, i. e. it will be mapped into the low 31 bit of
	134	# the address space (31 bit so sign extending doesn't matter)
	135	echo -ne '\001\000\000\000' \| dd of=qemu bs=1 seek=48 count=4 conv=notrunc
	136	endif
	137
	138	depend: $(SRCS)
	139	$(CC) -MM $(CFLAGS) $^ 1>.depend
	140
	141	# libqemu
	142
	143	libqemu.a: $(LIBOBJS)
	144	rm -f $@
	145	$(AR) rcs $@ $(LIBOBJS)
	146
	147	dyngen: dyngen.c
	148	$(HOST_CC) -O2 -Wall -g $< -o $@
	149
	150	translate-$(TARGET_ARCH).o: translate-$(TARGET_ARCH).c gen-op-$(TARGET_ARCH).h opc-$(TARGET_ARCH).h cpu-$(TARGET_ARCH).h
	151
	152	translate.o: translate.c op-$(TARGET_ARCH).h opc-$(TARGET_ARCH).h cpu-$(TARGET_ARCH).h
	153
	154	op-$(TARGET_ARCH).h: op-$(TARGET_ARCH).o dyngen
	155	./dyngen -o $@ $<
	156
	157	opc-$(TARGET_ARCH).h: op-$(TARGET_ARCH).o dyngen
	158	./dyngen -c -o $@ $<
	159
	160	gen-op-$(TARGET_ARCH).h: op-$(TARGET_ARCH).o dyngen
	161	./dyngen -g -o $@ $<
	162
	163	op-$(TARGET_ARCH).o: op-$(TARGET_ARCH).c
	164	$(CC) $(OP_CFLAGS) $(DEFINES) -c -o $@ $<
	165
	166	helper-$(TARGET_ARCH).o: helper-$(TARGET_ARCH).c
	167	$(CC) $(HELPER_CFLAGS) $(DEFINES) -c -o $@ $<
	168
	169	op-i386.o: op-i386.c opreg_template.h ops_template.h
	170
	171	op-arm.o: op-arm.c op-arm-template.h
	172
	173	%.o: %.c
	174	$(CC) $(CFLAGS) $(DEFINES) -c -o $@ $<
	175
	176	clean:
	177	$(MAKE) -C tests clean
	178	rm -f .o .a *~ qemu dyngen TAGS
	179
	180	distclean: clean
	181	rm -f config.mak config.h
	182
	183	install: qemu
	184	install -m 755 -s qemu $(prefix)/bin
	185
	186	# various test targets
	187	test speed: qemu
	188	make -C tests $@
	189
	190	TAGS:
	191	etags .[ch] tests/.[ch]
	192
	193	# documentation
	194	qemu-doc.html: qemu-doc.texi
	195	texi2html -monolithic -number $<
	196
	197	FILES= \
	198	README README.distrib COPYING COPYING.LIB TODO Changelog VERSION \
	199	configure \
	200	dyngen.c dyngen.h dyngen-exec.h ioctls.h syscall_types.h \
	201	Makefile elf.h elfload.c main.c signal.c qemu.h \
	202	syscall.c syscall_defs.h vm86.c path.c mmap.c \
	203	ppc.ld alpha.ld s390.ld sparc.ld arm.ld\
	204	thunk.c cpu-exec.c translate.c cpu-all.h thunk.h exec.h\
	205	exec.c cpu-exec.c\
	206	cpu-i386.h op-i386.c helper-i386.c syscall-i386.h translate-i386.c \
	207	exec-i386.h ops_template.h op_string.h opreg_template.h \
	208	cpu-arm.h syscall-arm.h exec-arm.h op-arm.c translate-arm.c op-arm-template.h \
	209	dis-asm.h disas.c disas.h alpha-dis.c ppc-dis.c i386-dis.c sparc-dis.c \
	210	arm-dis.c \
	211	tests/Makefile \
	212	tests/test-i386.c tests/test-i386-shift.h tests/test-i386.h \
	213	tests/test-i386-muldiv.h tests/test-i386-code16.S tests/test-i386-vm86.S \
	214	tests/hello.c tests/hello \
	215	tests/hello-arm.c tests/hello-arm \
	216	tests/sha1.c \
	217	tests/testsig.c tests/testclone.c tests/testthread.c \
	218	tests/runcom.c tests/pi_10.com \
	219	tests/test_path.c \
	220	qemu-doc.texi qemu-doc.html
	221
	222	FILE=qemu-$(VERSION)
	223
	224	tar:
	225	rm -rf /tmp/$(FILE)
	226	mkdir -p /tmp/$(FILE)
	227	cp -P $(FILES) /tmp/$(FILE)
	228	( cd /tmp ; tar zcvf ~/$(FILE).tar.gz $(FILE) )
	229	rm -rf /tmp/$(FILE)
	230
	231	# generate a binary distribution including the test binary environnment
	232	BINPATH=/usr/local/qemu-i386
	233
	234	tarbin:
	235	tar zcvf /tmp/qemu-$(VERSION)-i386-glibc21.tar.gz \
	236	$(BINPATH)/etc $(BINPATH)/lib $(BINPATH)/bin $(BINPATH)/usr
	237	tar zcvf /tmp/qemu-$(VERSION)-i386-wine.tar.gz \
	238	$(BINPATH)/wine
	239
	240	ifneq ($(wildcard .depend),)
	241	include .depend
	242	endif