0.3.3.2/src/cpu_alpha.c

/*
 *  Copyright (C) 2005  Anders Gavare.  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. 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.
 *  3. The name of the author may not be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 THE AUTHOR OR CONTRIBUTORS 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.
 *
 *
 *  $Id: cpu_alpha.c,v 1.4 2005/06/01 22:09:40 debug Exp $
 *
 *  Alpha CPU emulation.
 *
 *  TODO: This is just a dummy so far.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

#include "misc.h"


#ifndef ENABLE_ALPHA


#include "cpu_alpha.h"


/*
 *  alpha_cpu_family_init():
 *
 *  Bogus, when ENABLE_ALPHA isn't defined.
 */
int alpha_cpu_family_init(struct cpu_family *fp)
{
        return 0;
}


#else   /*  ENABLE_ALPHA  */


#include "cpu.h"
#include "cpu_alpha.h"
#include "machine.h"
#include "memory.h"
#include "symbol.h"


extern volatile int single_step;
extern int old_show_trace_tree;   
extern int old_instruction_trace;
extern int old_quiet_mode;
extern int quiet_mode;


/*
 *  alpha_cpu_new():
 *
 *  Create a new Alpha cpu object.
 */
struct cpu *alpha_cpu_new(struct memory *mem, struct machine *machine,
        int cpu_id, char *cpu_type_name)
{
        struct cpu *cpu;

        if (cpu_type_name == NULL || (
            strcasecmp(cpu_type_name, "ev4") != 0 &&
            strcasecmp(cpu_type_name, "ev5") != 0 &&
            strcasecmp(cpu_type_name, "ev6") != 0 &&
            strcasecmp(cpu_type_name, "ev7") != 0 &&
            strcasecmp(cpu_type_name, "pca56") != 0) )
                return NULL;

        cpu = malloc(sizeof(struct cpu));
        if (cpu == NULL) {
                fprintf(stderr, "out of memory\n");
                exit(1);
        }

        memset(cpu, 0, sizeof(struct cpu));
        cpu->memory_rw          = alpha_memory_rw;
        cpu->name               = cpu_type_name;
        cpu->mem                = mem;
        cpu->machine            = machine;
        cpu->cpu_id             = cpu_id;
        cpu->byte_order         = EMUL_BIG_ENDIAN;
        cpu->bootstrap_cpu_flag = 0;
        cpu->running            = 0;

        /*  Only show name and caches etc for CPU nr 0 (in SMP machines):  */
        if (cpu_id == 0) {
                debug("%s", cpu->name);
        }

        return cpu;
}


/*
 *  alpha_cpu_dumpinfo():
 */
void alpha_cpu_dumpinfo(struct cpu *cpu)
{
        debug("\n");

        /*  TODO  */
}


/*
 *  alpha_cpu_list_available_types():
 *
 *  Print a list of available Alpha CPU types.
 */
void alpha_cpu_list_available_types(void)
{
        /*  TODO  */

        debug("EV4       EV5       EV6       EV7       PCA56\n");
}


/*
 *  alpha_cpu_register_match():
 */
void alpha_cpu_register_match(struct machine *m, char *name,
        int writeflag, uint64_t *valuep, int *match_register)
{
        int cpunr = 0;

        /*  CPU number:  */

        /*  TODO  */

        /*  Register name:  */
        if (strcasecmp(name, "pc") == 0) {
                if (writeflag) {
                        m->cpus[cpunr]->pc = *valuep;
                } else
                        *valuep = m->cpus[cpunr]->pc;
                *match_register = 1;
        }

        /*  TODO: _LOTS_ of stuff.  */
}


#define MEMORY_RW       alpha_memory_rw
#define MEM_ALPHA
#include "memory_rw.c"
#undef MEM_ALPHA
#undef MEMORY_RW


/*
 *  alpha_cpu_family_init():
 *
 *  Fill in the cpu_family struct for Alpha.
 */
int alpha_cpu_family_init(struct cpu_family *fp)
{
        fp->name = "Alpha";
        fp->cpu_new = alpha_cpu_new;
        fp->list_available_types = alpha_cpu_list_available_types;
        fp->register_match = alpha_cpu_register_match;
        /*  fp->disassemble_instr = alpha_cpu_disassemble_instr;  */
        /*  fp->register_dump = alpha_cpu_register_dump;  */
        /*  fp->run = alpha_cpu_run;  */
        fp->dumpinfo = alpha_cpu_dumpinfo;
        /*  fp->show_full_statistics = alpha_cpu_show_full_statistics;  */
        /*  fp->tlbdump = alpha_cpu_tlbdump;  */
        /*  fp->interrupt = alpha_cpu_interrupt;  */
        /*  fp->interrupt_ack = alpha_cpu_interrupt_ack;  */
        return 1;
}

#endif  /*  ENABLE_ALPHA  */
1	dpavlin	2	/*
2			* Copyright (C) 2005 Anders Gavare. All rights reserved.
3			*
4			* Redistribution and use in source and binary forms, with or without
5			* modification, are permitted provided that the following conditions are met:
6			*
7			* 1. Redistributions of source code must retain the above copyright
8			* notice, this list of conditions and the following disclaimer.
9			* 2. Redistributions in binary form must reproduce the above copyright
10			* notice, this list of conditions and the following disclaimer in the
11			* documentation and/or other materials provided with the distribution.
12			* 3. The name of the author may not be used to endorse or promote products
13			* derived from this software without specific prior written permission.
14			*
15			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
16			* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17			* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18			* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
19			* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
20			* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
21			* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
22			* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
23			* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24			* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25			* SUCH DAMAGE.
26			*
27			*
28	dpavlin	6	* $Id: cpu_alpha.c,v 1.4 2005/06/01 22:09:40 debug Exp $
29	dpavlin	2	*
30			* Alpha CPU emulation.
31			*
32			* TODO: This is just a dummy so far.
33			*/
34
35			#include <stdio.h>
36			#include <stdlib.h>
37			#include <string.h>
38			#include <ctype.h>
39
40			#include "misc.h"
41
42
43			#ifndef ENABLE_ALPHA
44
45
46			#include "cpu_alpha.h"
47
48
49			/*
50			* alpha_cpu_family_init():
51			*
52			* Bogus, when ENABLE_ALPHA isn't defined.
53			*/
54			int alpha_cpu_family_init(struct cpu_family *fp)
55			{
56			return 0;
57			}
58
59
60			#else /* ENABLE_ALPHA */
61
62
63			#include "cpu.h"
64			#include "cpu_alpha.h"
65			#include "machine.h"
66			#include "memory.h"
67			#include "symbol.h"
68
69
70			extern volatile int single_step;
71			extern int old_show_trace_tree;
72			extern int old_instruction_trace;
73			extern int old_quiet_mode;
74			extern int quiet_mode;
75
76
77			/*
78			* alpha_cpu_new():
79			*
80			* Create a new Alpha cpu object.
81			*/
82			struct cpu alpha_cpu_new(struct memory mem, struct machine *machine,
83			int cpu_id, char *cpu_type_name)
84			{
85			struct cpu *cpu;
86
87			if (cpu_type_name == NULL \|\| (
88			strcasecmp(cpu_type_name, "ev4") != 0 &&
89			strcasecmp(cpu_type_name, "ev5") != 0 &&
90			strcasecmp(cpu_type_name, "ev6") != 0 &&
91			strcasecmp(cpu_type_name, "ev7") != 0 &&
92			strcasecmp(cpu_type_name, "pca56") != 0) )
93			return NULL;
94
95			cpu = malloc(sizeof(struct cpu));
96			if (cpu == NULL) {
97			fprintf(stderr, "out of memory\n");
98			exit(1);
99			}
100
101			memset(cpu, 0, sizeof(struct cpu));
102			cpu->memory_rw = alpha_memory_rw;
103			cpu->name = cpu_type_name;
104			cpu->mem = mem;
105			cpu->machine = machine;
106			cpu->cpu_id = cpu_id;
107			cpu->byte_order = EMUL_BIG_ENDIAN;
108			cpu->bootstrap_cpu_flag = 0;
109			cpu->running = 0;
110
111			/* Only show name and caches etc for CPU nr 0 (in SMP machines): */
112			if (cpu_id == 0) {
113			debug("%s", cpu->name);
114			}
115
116			return cpu;
117			}
118
119
120			/*
121			* alpha_cpu_dumpinfo():
122			*/
123			void alpha_cpu_dumpinfo(struct cpu *cpu)
124			{
125			debug("\n");
126
127			/* TODO */
128			}
129
130
131			/*
132			* alpha_cpu_list_available_types():
133			*
134			* Print a list of available Alpha CPU types.
135			*/
136			void alpha_cpu_list_available_types(void)
137			{
138			/* TODO */
139
140			debug("EV4 EV5 EV6 EV7 PCA56\n");
141			}
142
143
144			/*
145			* alpha_cpu_register_match():
146			*/
147			void alpha_cpu_register_match(struct machine m, char name,
148			int writeflag, uint64_t valuep, int match_register)
149			{
150			int cpunr = 0;
151
152			/* CPU number: */
153
154			/* TODO */
155
156			/* Register name: */
157			if (strcasecmp(name, "pc") == 0) {
158			if (writeflag) {
159			m->cpus[cpunr]->pc = *valuep;
160			} else
161			*valuep = m->cpus[cpunr]->pc;
162			*match_register = 1;
163			}
164
165			/* TODO: _LOTS_ of stuff. */
166			}
167
168
169			#define MEMORY_RW alpha_memory_rw
170			#define MEM_ALPHA
171			#include "memory_rw.c"
172			#undef MEM_ALPHA
173			#undef MEMORY_RW
174
175
176			/*
177			* alpha_cpu_family_init():
178			*
179			* Fill in the cpu_family struct for Alpha.
180			*/
181			int alpha_cpu_family_init(struct cpu_family *fp)
182			{
183			fp->name = "Alpha";
184			fp->cpu_new = alpha_cpu_new;
185			fp->list_available_types = alpha_cpu_list_available_types;
186			fp->register_match = alpha_cpu_register_match;
187			/* fp->disassemble_instr = alpha_cpu_disassemble_instr; */
188			/* fp->register_dump = alpha_cpu_register_dump; */
189			/* fp->run = alpha_cpu_run; */
190			fp->dumpinfo = alpha_cpu_dumpinfo;
191			/* fp->show_full_statistics = alpha_cpu_show_full_statistics; */
192			/* fp->tlbdump = alpha_cpu_tlbdump; */
193			/* fp->interrupt = alpha_cpu_interrupt; */
194			/* fp->interrupt_ack = alpha_cpu_interrupt_ack; */
195			return 1;
196			}
197
198			#endif /* ENABLE_ALPHA */