← Back to branch summary

~ari-tczew/ubuntu/lucid/skyeye/sru-lp-464175

« back to all changes in this revision

Viewing changes to arch/mips/common/decoder.c

  • Committer: Bazaar Package Importer
  • Author(s): Yu Guanghui
  • Date: 2009-02-20 10:02:22 UTC
  • mfrom: (1.1.3 upstream) (2.1.2 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090220100222-sw2erxpve46mtx7j
Tags: 1.2.5-2
http://bugs.debian.org/516248
* Fix get_sym implicit-pointer-conversion. (Closes:Bug#516248) 
* Modified configure.in to disable link with libbfd.

Show diffs side-by-side

added added

removed removed

Lines of Context:
arch/mips/common/decoder.c
9
9
#include <unistd.h> /* for sync() */
10
10
#endif
11
11
 
 
12
extern FILE *skyeye_logfd;
12
13
/* This monster of a switch statement decodes all CPU instructions. I've
13
14
 * decided against an explicit jump table, as such implementation both
14
15
 * increases the code size and introduced additional overhead to the inner
69
70
                                        UInt32 x = mstate->gpr[rt(instr)];
70
71
                                        int s = bits(mstate->gpr[rs(instr)], 4, 0);
71
72
                                        x <<= s;
72
 
                                        mstate->gpr[rd(instr)] = sign_extend_UInt32(x, 32 - s);
 
73
                                        //mstate->gpr[rd(instr)] = sign_extend_UInt32(x, 32 - s);
 
74
                                        mstate->gpr[rd(instr)] = x;
73
75
 
74
76
                                        return nothing_special;
75
77
                                }
79
81
                                        UInt32 x = mstate->gpr[rt(instr)];
80
82
                                        int s = bits(mstate->gpr[rs(instr)], 4, 0);
81
83
                                        x >>= s;
82
 
                                        mstate->gpr[rd(instr)] = sign_extend_UInt32(x, 32 - s);
 
84
                                        //mstate->gpr[rd(instr)] = sign_extend_UInt32(x, 32 - s);
 
85
                                        mstate->gpr[rd(instr)] = x;
83
86
                                        return nothing_special;
84
87
                                }
85
88
                                case SRAV:
92
95
                                        return nothing_special;
93
96
 
94
97
                                }
 
98
                                case MOVZ:
 
99
                                {
 
100
                                        if(!mstate->gpr[rt(instr)])
 
101
                                                mstate->gpr[rd(instr)] = mstate->gpr[rs(instr)];
 
102
                                        return nothing_special;
 
103
 
 
104
                                }
 
105
                                case MOVN:
 
106
                                {
 
107
                                        if(mstate->gpr[rt(instr)])
 
108
                                                mstate->gpr[rd(instr)] = mstate->gpr[rs(instr)];
 
109
                                        return nothing_special;
 
110
 
 
111
                                }
 
112
 
95
113
                                case JR:
96
114
                                {
97
115
                                        // Jump Register
124
142
                                }
125
143
                                case BREAK:
126
144
                                {
127
 
                                        process_breakpoint(mstate);
 
145
                                        //process_breakpoint(mstate);
 
146
                                        fprintf(stderr,"workaround for break instruction, pc=0x%x\n ", mstate->pc);
128
147
                                        return nothing_special;
129
148
                                }
130
149
                                case SYNC:
131
150
                                {
132
151
                                        // Synchronize
133
152
                                        //Fix me Shi yang 2006-08-08
134
 
                                        process_reserved_instruction(mstate);
 
153
                                        //process_reserved_instruction(mstate);
135
154
                                        return nothing_special;
136
155
                                }
137
156
                                case MFHI:
182
201
                                case MULT:
183
202
                                {
184
203
                                        // Multiply
185
 
                                        Int32 x = mstate->gpr[rs(instr)];
186
 
                                        Int32 y = mstate->gpr[rt(instr)];
187
 
                                        multiply(x, y);
 
204
                                        Int64 x = mstate->gpr[rs(instr)];
 
205
                                        Int64 y = mstate->gpr[rt(instr)];
 
206
                                        //multiply(x, y);
 
207
                                        long long z = x * y;
 
208
                                        mstate->hi = (z >> 32) & 0xFFFFFFFF;
 
209
                                        mstate->lo = z & 0xFFFFFFFF;
 
210
 
188
211
                                        return nothing_special;
189
212
                                }
190
213
                                case MULTU:
191
214
                                {
192
215
                                        // Multiply Unsigned
193
 
                                        UInt32 x = mstate->gpr[rs(instr)];
194
 
                                        UInt32 y = mstate->gpr[rt(instr)];
195
 
                                        multiply(x, y);
 
216
                                        UInt64 x = mstate->gpr[rs(instr)];
 
217
                                        UInt64 y = mstate->gpr[rt(instr)];
 
218
                                        unsigned long long z = x * y;
 
219
                                        //multiply(x, y);
 
220
                                        mstate->hi = (z >> 32) & 0xFFFFFFFF;
 
221
                                        mstate->lo = z & 0xFFFFFFFF;
 
222
 
 
223
 
196
224
                                        return nothing_special;
197
225
                                }
198
226
                                case DIV:
379
407
                                case TNE:
380
408
                                {
381
409
                                        // Trap If Not Equal
382
 
                                        process_reserved_instruction(mstate);
 
410
                                        if( mstate->gpr[rs(instr)] != mstate->gpr[rt(instr)])
 
411
                                                fprintf(stderr,"trap happened in %s at 0x%x.\n", __FUNCTION__, mstate->pc);
 
412
                                        //process_reserved_instruction(mstate);
 
413
                                        //skyeye_exit(-1);
 
414
                                        
383
415
                                        return nothing_special;
384
416
                                }
385
417
                                case DSLL:
422
454
                                        // Reserved instruction
423
455
                                        process_reserved_instruction(mstate);
424
456
                                        return nothing_special;
425
 
                        }
426
 
                }
 
457
                        }// switch (function(instr)) {
 
458
                }//case SPECIAL:
427
459
        
428
460
                case REGIMM:
429
461
                {
544
576
                                        process_reserved_instruction(mstate);
545
577
                                        return nothing_special; //Fix me. Shi yang 2006-08-09
546
578
                        }
547
 
                }
 
579
                }//case REGIMM:
548
580
                case J:
549
581
                {
550
582
                        // Jump
642
674
                }
643
675
                case ADDIU:
644
676
                {
 
677
                        /* confused, signed or unsigned ?? */
645
678
                        // Add Immediate Unsigned
646
679
                        UInt32 x = mstate->gpr[rs(instr)];
647
 
                        UInt32 y = sign_extend_UInt32(immediate(instr), 16);
 
680
                        Int32 y = sign_extend_UInt32(immediate(instr), 16);
648
681
                        UInt32 z = x + y;
 
682
                        //fprintf(skyeye_logfd, "0x%d,0x%d,0x%d, in 0x%x\n", x ,y, z, mstate->pc);
649
683
                        mstate->gpr[rt(instr)] = z;
650
684
                
651
685
                        return nothing_special;
710
744
                }
711
745
                case COP1:
712
746
                {
 
747
                        return decode_cop1(mstate, instr);
713
748
                        // Coprocessor 1 Operation
714
 
                        process_reserved_instruction(mstate);
715
 
                        return nothing_special;
 
749
                        //process_reserved_instruction(mstate);
716
750
                }
717
751
                case COP2:
718
752
                {
720
754
                        process_reserved_instruction(mstate);
721
755
                        return nothing_special;
722
756
                }
 
757
                case PREF:
 
758
                {
 
759
                        //fprintf(stderr, "PREF instruction,pc=0x%x\n",mstate->pc);
 
760
                        return nothing_special;
 
761
                }
723
762
                case BEQL:
724
763
                {
725
764
                        // Branch On Equal Likely
767
806
                        process_reserved_instruction(mstate);
768
807
                        return nothing_special;
769
808
                }
 
809
                case SPECIAL2:
 
810
                {
 
811
                        
 
812
                        switch (function(instr)) {
 
813
                                case MADD:
 
814
                                {
 
815
                                        UInt64 temp1 = mstate->hi << 32 + mstate->lo;
 
816
                                        UInt64 temp2 = mstate->gpr[rs(instr)] * mstate->gpr[rt(instr)] + temp1;
 
817
                                        mstate->hi = (temp2 >> 32) & (~0x0);
 
818
                                        mstate->lo = temp2 & (~0x0);
 
819
                                        return nothing_special;
 
820
                                }       
 
821
                                case FMUL:
 
822
                                {
 
823
                                        mstate->gpr[rd(instr)] = mstate->gpr[rs(instr)] * mstate->gpr[rt(instr)];
 
824
                                        return nothing_special;
 
825
                                }
 
826
                                case CVT_S://CLZ:
 
827
                                {
 
828
                                        int i = 31;
 
829
                                        for(i; i >= 0;i--)
 
830
                                                if( mstate->gpr[rs(instr)] & (1 << i))
 
831
                                                        break;
 
832
                                                else
 
833
                                                        continue;
 
834
                                         mstate->gpr[rd(instr)] = 31 - i;
 
835
                                        return nothing_special;
 
836
                                }
 
837
                                default:
 
838
                                        // Load Doubleword Right
 
839
                                        process_reserved_instruction(mstate);
 
840
                                        return nothing_special;
 
841
                        }
 
842
                }
 
843
 
 
844
        
770
845
                case LB:
771
846
                {
772
847
                        // Load Byte
 
848
                        UInt32 x; 
 
849
                        UInt32 y = 0;
 
850
 
773
851
                        if (mstate->sync_bit)
774
852
                                sync();
775
853
                        VA va = sign_extend_UInt32(offset(instr), 16) + mstate->gpr[base(instr)];
776
 
                        PA pa = translate_vaddr(mstate, va, data_load); //Shi yang 2006-08-10, defined in tlb.c
777
 
                        UInt8 x;
778
 
                        UInt32 y = 0;
 
854
                        PA pa;
 
855
                        if(translate_vaddr(mstate, va, data_load, &pa) != TLB_SUCC)
 
856
                                return nothing_special;
 
857
                        /*
 
858
                        if(translate_vaddr(mstate, va, data_load, &pa) != TLB_SUCC){
 
859
                                        return nothing_special;
 
860
                        }*/
779
861
                        load(mstate, va, pa, &y, 1);
 
862
                        
780
863
                        x = sign_extend_UInt32(y & (0xff), 8); //Shi yang 2006-08-10, Sign extend
 
864
 
781
865
                        mstate->gpr[rt(instr)] = x;
782
866
 
783
867
                        return nothing_special;
791
875
 
792
876
                        if (bit(va, 0)) //Check alignment
793
877
                                process_address_error(data_load, va);
794
 
                        PA pa = translate_vaddr(mstate,va, data_load); //Shi yang 2006-08-10
795
 
                        UInt16 x;
 
878
                        PA pa;
 
879
                        if(translate_vaddr(mstate,va, data_load, &pa) != TLB_SUCC)
 
880
                                return nothing_special; //Shi yang 2006-08-10
 
881
                        UInt32 x; 
796
882
                        UInt32 y = 0;
797
883
                        load(mstate, va, pa, &y, 2);
798
884
                        x = sign_extend_UInt32(y & (0xffff), 16); //Shi yang 2006-08-10, Sign extend
806
892
                        if (mstate->sync_bit)
807
893
                                sync();
808
894
                        VA va = sign_extend_UInt32(offset(instr), 16) + mstate->gpr[base(instr)];
809
 
                        PA pa = translate_vaddr(mstate, va, data_load); //Shi yang 2006-08-10
 
895
                        PA pa;
 
896
                        if(translate_vaddr(mstate, va, data_load, &pa) != TLB_SUCC)
 
897
                                return nothing_special; //Shi yang 2006-08-10
810
898
                        UInt32 mem;
811
899
                        UInt32 y = 0;
812
900
                        load(mstate, round_down(va, 4), round_down(pa, 4), &y, 4);
831
919
                        VA va = sign_extend_UInt32(offset(instr), 16) + mstate->gpr[base(instr)];
832
920
                        if (bits(va, 1, 0)) //Check alignment
833
921
                                process_address_error(mstate,data_load, va);
834
 
                        PA pa = translate_vaddr(mstate, va, data_load); //Shi yang 2006-08-10
 
922
                        PA pa;
 
923
                        if(translate_vaddr(mstate, va, data_load, &pa) != TLB_SUCC)
 
924
                                return nothing_special; //Shi yang 2006-08-10
835
925
                        UInt32 x;
836
926
                        UInt32 y = 0;
837
927
                        load(mstate, va, pa, &y, 4);
845
935
                        if (mstate->sync_bit)
846
936
                                sync();
847
937
                        VA va = sign_extend_UInt32(offset(instr), 16) + mstate->gpr[base(instr)];
848
 
                        PA pa = translate_vaddr(mstate, va, data_load); //Shi yang 2006-08-10
 
938
                        PA pa;
 
939
                        if(translate_vaddr(mstate, va, data_load, &pa) != TLB_SUCC)
 
940
                                return nothing_special; //Shi yang 2006-08-10
849
941
                        UInt32 y = 0;
850
942
                        UInt32 x;
851
943
                        load(mstate, va, pa, &y, 1);
862
954
                        VA va = sign_extend_UInt32(offset(instr), 16) + mstate->gpr[base(instr)];
863
955
                        if (bit(va, 0)) //Check alignment
864
956
                                process_address_error(mstate,data_load, va);
865
 
                        PA pa = translate_vaddr(mstate, va, data_load); //Shi yang 2006-08-10
 
957
                        PA pa;
 
958
                        if(translate_vaddr(mstate, va, data_load, &pa) != TLB_SUCC)
 
959
                                return nothing_special; //Shi yang 2006-08-10
866
960
                        UInt16 x;
867
961
                        UInt32 y = 0;
868
962
                        load(mstate, va, pa, &y, 2);
877
971
                        if (mstate->sync_bit)
878
972
                                sync();
879
973
                        VA va = sign_extend_UInt32(offset(instr), 16) + mstate->gpr[base(instr)];
880
 
                        PA pa = translate_vaddr(mstate,va, data_load); //Shi yang 2006-08-10
 
974
                        PA pa;
 
975
                        if(translate_vaddr(mstate,va, data_load, &pa))
 
976
                                return nothing_special; //Shi yang 2006-08-10
881
977
                        UInt32 mem;
882
978
                        UInt32 y = 0;
883
979
                        load(mstate, round_down(va, 4), round_down(pa, 4), &y, 4);
903
999
                        if (mstate->sync_bit)
904
1000
                                sync();
905
1001
                        VA va = sign_extend_UInt32(offset(instr), 16) + mstate->gpr[base(instr)];
906
 
                        PA pa = translate_vaddr(mstate,va, data_store); //Shi yang 2006-08-10
 
1002
                        PA pa;
 
1003
                        if(translate_vaddr(mstate,va, data_store, &pa))
 
1004
                                return nothing_special; //Shi yang 2006-08-10
907
1005
                        store(mstate, mstate->gpr[rt(instr)], va, pa, 1); // Fix me: Shi yang 2006-08-10
908
1006
                        return nothing_special;
909
1007
                }
915
1013
                        VA va = sign_extend_UInt32(offset(instr), 16) + mstate->gpr[base(instr)];
916
1014
                        if (bit(va, 0)) //Check alignment
917
1015
                                process_address_error(mstate,data_store, va);
918
 
                        PA pa = translate_vaddr(mstate, va, data_store); //Shi yang 2006-08-10
 
1016
                        PA pa;
 
1017
                        if(translate_vaddr(mstate, va, data_store, &pa))
 
1018
                                return nothing_special; //Shi yang 2006-08-10
919
1019
                        store(mstate, mstate->gpr[rt(instr)], va, pa, 2); //Fix me: Shi yang 2006-08-10
920
1020
                        return nothing_special;
921
1021
                }
925
1025
                        if (mstate->sync_bit)
926
1026
                                sync();
927
1027
                        VA va = sign_extend_UInt32(offset(instr), 16) + mstate->gpr[base(instr)];
928
 
                        PA pa = translate_vaddr(mstate, va, data_store); //Shi yang 2006-08-10
 
1028
                        PA pa;
 
1029
                        if(translate_vaddr(mstate, va, data_store, &pa))
 
1030
                                return nothing_special; //Shi yang 2006-08-10
929
1031
                        UInt32 mem;
930
1032
                        UInt32 y = 0;
931
1033
                        load(mstate, round_down(va, 4), round_down(pa, 4), &y, 4);
946
1048
                                sync();
947
1049
                        VA va = sign_extend_UInt32(offset(instr), 16) + mstate->gpr[base(instr)];
948
1050
                        if (bits(va, 1, 0)) //Check alignment
 
1051
                        {
 
1052
                                fprintf(stderr," in %s,address unaligned va=0x%x,pc=0x%x\n", __FUNCTION__, va, mstate->pc);
 
1053
                                skyeye_exit(-1);
949
1054
                                process_address_error(mstate,data_store, va);
950
 
                        PA pa = translate_vaddr(mstate,va, data_store); //Shi yang 2006-08-10
 
1055
                        }
 
1056
                        PA pa;
 
1057
                        if(translate_vaddr(mstate,va, data_store, &pa) != TLB_SUCC)
 
1058
                                return nothing_special; //Shi yang 2006-08-10
951
1059
                        store(mstate, mstate->gpr[rt(instr)], va, pa, 4); //Fix me: Shi yang 2006-08-10
952
1060
                        return nothing_special;
953
1061
                }
969
1077
                        if (mstate->sync_bit)
970
1078
                                sync();
971
1079
                        VA va = sign_extend_UInt32(offset(instr), 16) + mstate->gpr[base(instr)];
972
 
                        PA pa = translate_vaddr(mstate, va, data_store); //Shi yang 2006-08-10
 
1080
                        PA pa;
 
1081
                        if(translate_vaddr(mstate, va, data_store, &pa) != TLB_SUCC)
 
1082
                                return nothing_special; //Shi yang 2006-08-10
973
1083
                        UInt32 mem;
974
1084
                        UInt32 y = 0;
975
1085
                        load(mstate,round_down(va, 4), round_down(pa, 4),&y,4);
991
1101
                case LL:
992
1102
                {
993
1103
                        // Load Linked
994
 
                        process_reserved_instruction(mstate);
 
1104
                        //int va = mstate->gpr[base(instr)] + offset(instr);
 
1105
                        int va = mstate->gpr[base(instr)] + sign_extend_UInt32(offset(instr), 16);
 
1106
                        PA pa;
 
1107
                        if(translate_vaddr(mstate, va, data_load, &pa) != TLB_SUCC)
 
1108
                                return nothing_special;
 
1109
                        int data;
 
1110
                        mips_mem_read(pa, &data, 4);    
 
1111
                        mstate->gpr[rt(instr)] = data;
 
1112
                        //process_reserved_instruction(mstate);
995
1113
                        return nothing_special;
996
1114
                }
997
1115
                case LWC1:
1032
1150
                case SC:
1033
1151
                {
1034
1152
                        // Store Conditional
1035
 
                        process_reserved_instruction(mstate);
 
1153
                        //int va = mstate->gpr[base(instr)] + offset(instr);
 
1154
                        int va = mstate->gpr[base(instr)] + sign_extend_UInt32(offset(instr), 16);
 
1155
                        PA pa;
 
1156
                        if(translate_vaddr(mstate, va, data_load, &pa) != TLB_SUCC)
 
1157
                                return nothing_special;
 
1158
                        int data;
 
1159
                        data = mstate->gpr[rt(instr)];
 
1160
                        
 
1161
                        /*
 
1162
                        if(mstate->pc == 0x8012a858){
 
1163
                                fprintf(stderr, "In SC,data=0x%x,va=0x%x\n", data, va);
 
1164
                                if(va == 0x81179a00){
 
1165
                                        fprintf(stderr, "Write to %d\n",va);
 
1166
                                        skyeye_exit(-1);
 
1167
                                }
 
1168
                        }
 
1169
                        */
 
1170
                        mips_mem_write(pa, &data, 4);
 
1171
                        mstate->gpr[rt(instr)] = 1;
 
1172
 
 
1173
                        //process_reserved_instruction(mstate);
1036
1174
                        return nothing_special;
1037
1175
                }
1038
1176
                case SWC1: