3_test: prep for praes tomorrow
[calu.git] / 3b_sim / sim.cpp
1 #include <iostream>
2 #include <iomanip>
3 #include <fstream>
4 #include <boost/tokenizer.hpp>
5 #include <boost/program_options.hpp>
6 #include <boost/lexical_cast.hpp>
7 #include <string>
8 #include <map>
9 #include <list>
10
11 #include <boost/function.hpp>
12 #include <boost/functional.hpp>
13 #include <boost/tuple/tuple.hpp>
14
15 #include "disasm.h"
16 #include "ccpu.hpp"
17 #include "CInstrFactory.hpp"
18 #include "uint32_from_hex.hpp"
19
20 #include "SReadline/SReadline.h"
21 using namespace swift;
22
23 #define RAM_END (1000)
24 #define PROG_END (1000)
25 #define REG_COUNT (16)
26
27 typedef boost::function<void (const vector<string> &)> Func;
28 typedef boost::tuple<string, Func, string> CompleterElement;
29
30 typedef list<CompleterElement> MyCompleterContainer;
31
32 class LookupFunctor
33 {
34         public:
35                 // Creates a functor and memorises tokens
36                 LookupFunctor(const vector<string>&  tokens) : Tokens(tokens) {}
37
38                 // Compares the first token only
39                 bool operator()(const CompleterElement& ele) const
40                 {
41                         return (strncmp(Tokens.begin()->c_str(), ele.get<0>().c_str(), Tokens.begin()->size()) == 0);
42                 }
43
44         private:
45                 const vector<string> &Tokens;
46 };
47
48
49
50
51 class CHelpExec
52 {
53         private:
54                 const MyCompleterContainer &m_completers;
55
56         public:
57                 CHelpExec(const MyCompleterContainer &cont) : m_completers(cont) {}
58
59                 void operator() (const vector<string>&)
60                 {
61                         cout << "Available commands: " << endl;
62                         for(auto iter = m_completers.begin(); iter != m_completers.end(); ++iter) {
63                                 cout << setw(19) << setfill(' ') << (*iter).get<0>() << ": " << (*iter).get<2>() << endl;
64                         }
65                 }
66 };
67
68 void close_prog(const std::vector<std::string> &);
69
70 CCpu* Iinstr::m_cpu;
71 disasm* Iinstr::m_disasm;
72
73 CCpu* global_cpu = NULL;
74
75 vector<CDat> breakpoints;
76
77 bool ignoreBreak = false;
78
79 void doExit(const vector<string>&)
80 {
81         exit(EXIT_SUCCESS);
82 }
83
84 unsigned int convertStringToNum(const std::string& in)
85 {
86         if(in.substr(0,2) == "0x") {
87                 return lexical_cast<uint32_from_hex>(in);
88         }
89         else {
90                 return lexical_cast<unsigned int>(in);
91         }
92 }
93
94
95 void execStep(const vector<string>& in)
96 {
97         int count = 1;
98         if(in.size() == 2) {
99                 try {
100                         count = convertStringToNum(in.back());
101                 }
102                 catch(bad_cast&) {
103                         cerr << "given parameter to step is not a number" << endl;
104                 }
105         }
106         while(count > 0) {
107                 try {
108                         auto breakp = find(breakpoints.begin(), breakpoints.end(), global_cpu->getNextPC());
109                         if(breakp == breakpoints.end() || ignoreBreak) {
110                                 global_cpu->tick();
111                                 ignoreBreak = false;
112                         }
113                         else {
114                                 ignoreBreak = true;
115                                 cout << "Breakpoint 0x" << std::hex << setw(8) << setfill('0') << *breakp << std::hex << " hit" << endl;
116                                 break;
117                         }
118                 }
119                 catch(std::string& e) {
120                         cerr << e << endl;
121                 }
122                 count--;
123         }
124 }
125
126 void execRun(const vector<string>&)
127 {
128         while(1) {
129                 try {
130                         auto breakp = find(breakpoints.begin(), breakpoints.end(), global_cpu->getNextPC());
131                         if(breakp == breakpoints.end() || ignoreBreak) {
132                                 global_cpu->tick();
133                                 ignoreBreak = false;
134                         }
135                         else {
136                                 ignoreBreak = true;
137                                 cout << "Breakpoint 0x" << std::hex << setw(8) << setfill('0') << *breakp << std::hex << " hit" << endl;
138                                 return;
139                         }
140                 }
141                 catch(std::string& e) {
142                         cerr << e << endl;
143                         return;
144                 }
145         }
146 }
147
148 void setPC(const vector<string>& in)
149 {
150         CDat addr = 0;
151         if(in.size() == 2) {
152                 try {
153                         addr = convertStringToNum(in.back());
154                 }
155                 catch(bad_cast&) {
156                         cerr << "given parameter is not a number" << endl;
157                         return;
158                 }
159         }
160         global_cpu->setNextPC(addr);
161         cout << "Set programcounter to 0x" << std::hex << setw(8) << setfill('0') << addr << std::dec << endl;
162 }
163
164
165 void printReg(const vector<string>& in)
166 {
167         int i, start = 0, end = REG_COUNT-1;
168         /* Todo: 
169          * 1) make 2 columns
170          */
171
172         if(in.size() >= 2) {
173                 try {
174                         start = convertStringToNum(in[1]);
175                         if(start < 0 || start > (REG_COUNT-1)) {
176                                 cerr << "start is out of range" << endl;
177                                 return;
178                         }
179                         end = start;
180                 }
181                 catch(bad_cast&) {
182                         cerr << "given parameter is not a number" << endl;
183                         return;
184                 }
185         }
186
187         if(in.size() >= 3) {
188                 try {
189                         end = convertStringToNum(in[2]);
190                         if(start > end || end > (REG_COUNT-1)) {
191                                 cerr << "end is out of range or smaller than start" << endl;
192                                 return;
193                         }
194                 }
195                 catch(bad_cast&) {
196                         cerr << "given parameter is not a number" << endl;
197                         return;
198                 }
199         }
200         
201         for(i = start; i <= end; i++) {
202                 cout << setw(2) << setfill('0') << i << ": 0x";
203                 cout << std::hex <<  setw(8) << setfill('0') << global_cpu->getRegister(i) << " ";
204                 cout << std::dec << setw(10) << setfill(' ') << global_cpu->getRegister(i) << " ";
205                 cout << std::dec << setw(10) << setfill(' ') << (int)global_cpu->getRegister(i) << endl;
206         }
207 }
208
209 void setReg(const vector<string>& in)
210 {
211         int reg = 0;
212         CDat val = 0;
213
214         if(in.size() >= 3) {
215                 try {
216                         reg = convertStringToNum(in[1]);
217                         if(reg < 0 || reg > (REG_COUNT-1)) {
218                                 cerr << "register is out of range" << endl;
219                                 return;
220                         }
221
222                         val = convertStringToNum(in[2]);
223
224                         cout << "Setting register " << reg << " to 0x" << std::hex << setw(8) << setfill('0') << val << std::dec << endl;
225                         global_cpu->setRegister(reg,val);
226                 }
227                 catch(bad_cast&) {
228                         cerr << "given parameter is not a number" << endl;
229                         return;
230                 }
231         }
232 }
233
234 void printRAM(const vector<string>& in)
235 {
236         int i, start = 0, end = 15;
237         /* Todo: 
238          * 1) make 2 columns
239          */
240
241         if(in.size() >= 2) {
242                 try {
243                         start = convertStringToNum(in[1]);
244                         if(start < 0 || start > (RAM_END-1)) {
245                                 cerr << "start is out of range" << endl;
246                                 return;
247                         }
248                         start = (start & (~(BYTE_COUNT-1))) / BYTE_COUNT;
249                         end = start;
250                 }
251                 catch(bad_cast&) {
252                         cerr << "given parameter is not a number" << endl;
253                         return;
254                 }
255         }
256
257         if(in.size() >= 3) {
258                 try {
259                         end = convertStringToNum(in[2]);
260                         if(start > end || end > (RAM_END-1)) {
261                                 cerr << "end is out of range or smaller than start" << endl;
262                                 return;
263                         }
264                         if(end % BYTE_COUNT != 0) {
265                                 end = ((end & (~(BYTE_COUNT-1))) / BYTE_COUNT)+1;
266                         }
267                         else {
268                                 end = ((end & (~(BYTE_COUNT-1))) / BYTE_COUNT);
269                         }
270                 }
271                 catch(bad_cast&) {
272                         cerr << "given parameter is not a number" << endl;
273                         return;
274                 }
275         }
276         for(i = start*BYTE_COUNT; i <= end*BYTE_COUNT; i += BYTE_COUNT) {
277                 cout << std::hex << "0x" << setw(8) << setfill('0') << i << ": 0x";
278                 cout << std::hex << setw(8)  << setfill('0') << global_cpu->getRAM(i) << " ";
279                 cout << std::dec << setw(10) << setfill(' ') << global_cpu->getRAM(i) << " ";
280                 cout << std::dec << setw(10) << setfill(' ') << (int)global_cpu->getRAM(i) << endl;
281         }
282 }
283
284 void setRam(const vector<string>& in)
285 {
286         int addr = 0;
287         CDat val = 0;
288
289         if(in.size() >= 3) {
290                 try {
291                         addr = convertStringToNum(in[1]);
292                         if(addr < 0 || addr > (RAM_END-1)) {
293                                 cerr << "RAM-Address is out of range" << endl;
294                                 return;
295                         }
296
297                         addr = (addr & (~(BYTE_COUNT-1))) / BYTE_COUNT;
298                         val = convertStringToNum(in[2]);
299
300                         addr *= BYTE_COUNT;
301
302                         cout << "Setting RAM-Address 0x" << std::hex << setw(8) << setfill('0') << addr;
303                         cout << " to 0x" << setw(8) << setfill('0') << val << std::dec << endl;
304                         global_cpu->setRAM(addr,val);
305                 }
306                 catch(bad_cast&) {
307                         cerr << "given parameter is not a number" << endl;
308                         return;
309                 }
310         }
311 }
312 void printPROG(const vector<string>& in)
313 {
314         int i, start = 0, end = 15;
315         /* Todo: 
316          * 1) make 2 columns
317          */
318
319         if(in.size() >= 2 && in[1][0] == 'c') {
320                 start = global_cpu->getCurPC() / BYTE_COUNT;
321                 end = start + 9;
322         }
323         else if(in.size() >= 2) {
324                 try {
325                         start = convertStringToNum(in[1]);
326                         if(start < 0 || start > (PROG_END-1)) {
327                                 cerr << "start is out of range" << endl;
328                                 return;
329                         }
330                         start = (start & (~(BYTE_COUNT-1))) / BYTE_COUNT;
331                         end = start;
332                 }
333                 catch(bad_cast&) {
334                         cerr << "given parameter is not a number" << endl;
335                         return;
336                 }
337         }
338
339         if(in.size() >= 3) {
340                 try {
341                         end = convertStringToNum(in[2]);
342                         if(start > end || end > (PROG_END-1)) {
343                                 cerr << "end is out of range or smaller than start" << endl;
344                                 return;
345                         }
346                         if(end % BYTE_COUNT != 0) {
347                                 end = ((end & (~(BYTE_COUNT-1))) / BYTE_COUNT)+1;
348                         }
349                         else {
350                                 end = ((end & (~(BYTE_COUNT-1))) / BYTE_COUNT);
351                         }
352
353                 }
354                 catch(bad_cast&) {
355                         cerr << "given parameter is not a number" << endl;
356                         return;
357                 }
358         }
359
360         
361         for(i = start*BYTE_COUNT; i <= end*BYTE_COUNT; i += BYTE_COUNT) {
362                 Iinstr* pi = global_cpu->getProg(i);
363                 if(pi == NULL) {
364                         cout << std::hex << "0x" << setw(8) << setfill('0') << i << ": NOP" << endl;
365                 }
366                 else {
367                         cout << std::hex << "0x" << setw(8) << setfill('0') << i << ": " << std::dec << pi->toString() << endl;
368                 }
369         }
370 }
371
372 void setBreak(const vector<string>& in)
373 {
374         unsigned int addr = 0;
375         if(in.size() == 2) {
376                 try {
377                         addr = convertStringToNum(in.back());
378                         breakpoints.push_back(addr);
379                         cout << "Breakpoint 0x" << std::hex << setw(8) << setfill('0') << addr << std::dec << " set" << endl;
380                 }
381                 catch(bad_cast&) {
382                         cerr << "Given parameter is not a valid address" << endl;
383                 }
384         }
385         else {
386                 cerr << "Invalid parameter count!" << endl;
387         }
388 }
389
390 void listBreaks(const vector<string>&)
391 {
392         for(auto iter = breakpoints.begin(); iter != breakpoints.end(); ++iter) {
393                 cout << "Breakpoint at 0x" << std::hex << setw(8) << setfill('0') << *iter << std::dec << endl;
394         }
395 }
396
397 void printStatus(const vector<string>&)
398 {
399         CDat stackp = global_cpu->getStack();
400         CDat stackd = global_cpu->getRAM(stackp);
401         cout << "Stack pointer: 0x" << std::hex << setw(8) << setfill('0') << stackp << " @stackpointer: 0x" << setw(8) << stackd << std::dec << " (" << stackd << ")" << endl;
402         cout << "PSW: 0x" << std::hex << setw(8) << setfill('0') << global_cpu->getFlags() << std::dec << endl;
403         cout << "cur PC: 0x" << std::hex << setw(8) << setfill('0') << global_cpu->getCurPC() << " next PC: 0x" << setw(8) << setfill('0') << global_cpu->getNextPC() << std::dec << endl;
404
405 }
406
407 using boost::lexical_cast;
408 using boost::bad_lexical_cast;
409
410 using namespace std;
411
412 using namespace boost::program_options;
413 namespace po = boost::program_options;
414
415 std::string progName;
416
417 int main(int argc, char* argv[])
418 {
419         progName = argv[0];
420         ifstream inFile;
421         try {
422                 po::options_description desc("Allowed options");
423                 desc.add_options()
424                 ("help,h","produce help message")
425                 ("file,f",value<string>(), "input file")
426                 ;
427
428                 po::positional_options_description p;
429                 p.add("file",1);
430
431                 po::variables_map vm;
432                 po::store(po::command_line_parser(argc, argv).options(desc).positional(p).run(), vm);
433                 po::notify(vm);
434
435                 if(vm.count("help")) {
436                         cout << desc << endl;
437                         return EXIT_FAILURE;
438                 }
439
440                 if(vm.count("file")) {
441 #ifdef DEBUG 
442                         cout << "going to open file " << vm["file"].as<string>() << endl;
443 #endif
444                         inFile.open(vm["file"].as<string>(), ios::in);
445                         if(!inFile) {
446                                 cerr << "Error opening file " << vm["file"].as<string>() << endl;
447                                 return EXIT_FAILURE;
448                         }
449                 }
450                 else {
451                         cout << "not input file given!" << endl << endl;
452                         cout << desc << endl;
453                         return EXIT_FAILURE;
454                 }
455         }
456         catch(std::exception& ex) {
457                 cout << ex.what() << endl;
458         }
459
460
461         string dir = "./instr/";
462
463         map<short, Iinstr*> instr;
464
465         CInstrFactory instrFab;
466         try {
467                 instrFab.loadLibsIntoMap(instr, dir);
468         }
469         catch(std::bad_alloc& e) {
470                 cerr << progName << ": bad_alloc caught " << e.what() << endl;
471                 exit(EXIT_FAILURE); 
472         }
473         catch(std::string& s) {
474                 cerr << progName << ": " << s << endl;
475                 exit(EXIT_FAILURE);
476         }
477
478         CCpu cpu(REG_COUNT, RAM_END, PROG_END);
479
480         global_cpu = &cpu;
481
482         Iinstr::setCPU(&cpu);
483
484         disasm disasm(instr);
485
486         Iinstr::setDisasm(&disasm);
487
488         std::string str = "";
489         int addr = 0;
490         boost::char_separator<char> sep(";", "", boost::keep_empty_tokens);
491         boost::tokenizer<boost::char_separator<char> > tokens(str, sep);
492         while(getline(inFile, str)) {
493                 int count = 0;
494                 tokens.assign(str);
495                 stringstream out;
496                 int type = 0;
497                 for(auto tok_iter = tokens.begin(); tok_iter != tokens.end(); ++tok_iter) {
498                         if(tok_iter == tokens.begin()) {
499                                 try {
500                                         type = lexical_cast<int>(*tok_iter);
501                                         count++;
502                                         continue;
503                                 }
504                                 catch(bad_lexical_cast &) {
505                                         break;
506                                 }
507                                 cout << endl;
508                         }
509                         switch(type) {
510                                 case 0:
511                                         if(count == 1) {
512                                                 try {
513                                                         addr = lexical_cast<uint32_from_hex>(*tok_iter);
514                                                 }
515                                                 catch(bad_lexical_cast& e) {
516                                                         cerr << e.what() << endl;
517                                                         exit(EXIT_FAILURE);
518                                                 }
519                                         }
520                                         else if(count == 2) {
521                                                 try {
522                                                         CDat data = lexical_cast<uint32_from_hex>(*tok_iter);
523                                                         cpu.setRAM(addr, data);
524                                                 }
525                                                 catch(bad_lexical_cast& e) {
526                                                         cerr << e.what() << endl;
527                                                         exit(EXIT_FAILURE);
528                                                 }
529                                         }
530                                         break;
531                                 case 1:
532                                         if(count == 1) {
533                                                 try {
534                                                         addr = lexical_cast<uint32_from_hex>(*tok_iter);
535                                                 }
536                                                 catch(bad_lexical_cast& e) {
537                                                         cerr << e.what() << endl;
538                                                         exit(EXIT_FAILURE);
539                                                 }
540                                         }
541                                         else if(count == 2) {
542                                                 Iinstr *pi = disasm.decode(*tok_iter);
543                                                 cpu.setProg(addr, pi);
544                                         }
545                                         break;
546                                 case 2:
547                                 case 3:
548                                         cerr << "ignoring labels and comments for now" << endl;
549                                         break;
550                                 default:
551                                         cerr << "i was to lazy to implement the other format types for now" << endl;
552                         }
553                         count++;
554                 }
555         }
556         inFile.close();
557
558         cout << endl;
559
560 /*
561         for(int i = 0; i <= 32; i += 4) {
562                 Iinstr *pinstr = cpu.getProg(i);
563                 if(pinstr != NULL) {
564                         cout << i << " : " << std::hex << i << std::dec << " " << pinstr->toString() << endl;
565                 }
566                 else {
567                         cout << "Null at " << i << " : " << std::hex << i << endl;
568                 }
569         }
570
571         for(int i = 0; i <= 32; i += 4) {
572                 CDat data = cpu.getRAM(i);
573                 cout << i << " : " << std::hex << i << std::dec << " " << data << endl;
574         }
575 */
576         cpu.setRegister(1, 4);
577         cpu.setRegister(2, 0);
578         cpu.setRAM(0,5);
579         cpu.setRAM(4,0x66334455);
580         cpu.setRAM(8,32);
581         cpu.setRAM(12,45);
582
583         // following: job of the bootloader
584         //set stackpointer
585         cpu.setStack(500);
586         //set return to nowhere for ret
587         cpu.setRAM(500,500);
588
589         SReadline Reader;
590
591         MyCompleterContainer Completers;
592
593         CHelpExec HelpExec(Completers);
594
595         Completers.push_back(CompleterElement("help", boost::bind1st( boost::mem_fun( &CHelpExec::operator()), &HelpExec), "Prints this message"));
596         Completers.push_back(CompleterElement("quit", &doExit, "Exits program"));
597         Completers.push_back(CompleterElement("exit", &doExit, "Exits program"));
598         Completers.push_back(CompleterElement("step [count]",&execStep, "Runs [count] ticks. if count is not given one tick is executed."));
599         Completers.push_back(CompleterElement("dreg [s] [e]",&printReg, "Prints registers. if s is given, only register s is printed. if s and e are given the registers from s to e are printed. if omitted all registers a printed."));
600         Completers.push_back(CompleterElement("ddata [s] [e]",&printRAM, "Prints RAM. if s is given, only RAM-Addr. s is printed. if s and e are given the RAM-Addrs from s to e are printed. if omitted the first 16 RAM-Addrs are printed."));
601         Completers.push_back(CompleterElement("dprog [s] [e]",&printPROG, "Prints program. if s is given, only Prog-Addr. s is printed. if s and e are given the Prog-Addrs from s to e are printed. if omitted the first 16 Prog-Addrs are printed."));
602         Completers.push_back(CompleterElement("break addr",&setBreak, "Sets a breakpoint for address addr."));
603         Completers.push_back(CompleterElement("listbreaks",&listBreaks, "Lists all breakpoints."));
604         Completers.push_back(CompleterElement("run",&execRun, "Runs till next breakpoint or end of program."));
605         Completers.push_back(CompleterElement("setpc [num]",&setPC, "Sets PC to num. if num is omitted 0 is used."));
606         Completers.push_back(CompleterElement("setreg [s] [num]",&setReg, "Sets Register s to num."));
607         Completers.push_back(CompleterElement("setdata [s] [num]",&setRam, "Sets RAM-Addr s to num."));
608         Completers.push_back(CompleterElement("status",&printStatus, "Prints status of CPU."));
609
610         Reader.RegisterCompletions(Completers);
611
612         string UserInput;
613         vector<string> Tokens, lastTokens;
614         bool EndOfInput = false;
615
616         //tilab g++44 doesn't like auto here
617         MyCompleterContainer::iterator Found(Completers.end());
618
619         Func lastFunc = NULL;
620
621
622         while(1) {
623                 UserInput = Reader.GetLine("> ", Tokens, EndOfInput);
624                 if(EndOfInput) {
625                         break;
626                 }
627
628                 if(!Tokens.empty()) {
629                         Found = find_if(Completers.begin(), Completers.end(), LookupFunctor(Tokens));
630
631                         if(Found != Completers.end()) {
632                                 if((*Found).get<1>() != 0) {
633                                         lastFunc = (*Found).get<1>();
634                                         lastFunc(Tokens);
635                                         lastTokens = Tokens;
636                                         //(*Found).get<1>()(Tokens);
637                                 }
638                         }
639                         else {
640                                 lastFunc = NULL;
641                                 cout << "Unknown command. 'help' displays help" << endl;
642                         }
643                 }
644                 else {
645                         if(lastFunc != NULL) {
646                                 lastFunc(lastTokens);
647                         }
648                         else {
649                                 cout << "Unknown command. 'help' displays help" << endl;
650                         }
651                 }
652         }
653
654
655 /*
656         for(int i = 0; ; i++) {
657                 try {
658                         cpu.tick();
659                         cout << " reg0: " << cpu.getRegister(0) <<  " reg1: " << cpu.getRegister(1);
660                         cout << " reg2: " << cpu.getRegister(2) <<  " reg3: " << cpu.getRegister(3);
661                         cout << " reg4: " << cpu.getRegister(4) <<  " reg5: " << cpu.getRegister(5);
662                         cout << endl << endl;
663
664                 }
665                 catch(string& e) {
666                         cerr << e << endl;
667                         break;
668                 }
669         }
670 */
671         return EXIT_SUCCESS;
672 }