1 /* MN10300 Misalignment fixup handler
3 * Copyright (C) 2007 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public Licence
8 * as published by the Free Software Foundation; either version
9 * 2 of the Licence, or (at your option) any later version.
11 #include <linux/module.h>
12 #include <linux/sched.h>
13 #include <linux/kernel.h>
14 #include <linux/string.h>
15 #include <linux/errno.h>
16 #include <linux/ptrace.h>
17 #include <linux/timer.h>
19 #include <linux/smp.h>
20 #include <linux/smp_lock.h>
21 #include <linux/init.h>
22 #include <linux/delay.h>
23 #include <linux/spinlock.h>
24 #include <linux/interrupt.h>
25 #include <linux/pci.h>
26 #include <asm/processor.h>
27 #include <asm/system.h>
28 #include <asm/uaccess.h>
30 #include <asm/atomic.h>
32 #include <asm/pgalloc.h>
33 #include <asm/cpu-regs.h>
34 #include <asm/busctl-regs.h>
36 #include <asm/gdb-stub.h>
37 #include <asm/asm-offsets.h>
40 #define kdebug(FMT, ...) printk(KERN_DEBUG "MISALIGN: "FMT"\n", ##__VA_ARGS__)
42 #define kdebug(FMT, ...) do {} while (0)
45 static int misalignment_addr(unsigned long *registers
, unsigned params
,
46 unsigned opcode
, unsigned long disp
,
47 void **_address
, unsigned long **_postinc
,
50 static int misalignment_reg(unsigned long *registers
, unsigned params
,
51 unsigned opcode
, unsigned long disp
,
52 unsigned long **_register
);
54 static void misalignment_MOV_Lcc(struct pt_regs
*regs
, uint32_t opcode
);
56 static const unsigned Dreg_index
[] = {
57 REG_D0
>> 2, REG_D1
>> 2, REG_D2
>> 2, REG_D3
>> 2
60 static const unsigned Areg_index
[] = {
61 REG_A0
>> 2, REG_A1
>> 2, REG_A2
>> 2, REG_A3
>> 2
64 static const unsigned Rreg_index
[] = {
65 REG_E0
>> 2, REG_E1
>> 2, REG_E2
>> 2, REG_E3
>> 2,
66 REG_E4
>> 2, REG_E5
>> 2, REG_E6
>> 2, REG_E7
>> 2,
67 REG_A0
>> 2, REG_A1
>> 2, REG_A2
>> 2, REG_A3
>> 2,
68 REG_D0
>> 2, REG_D1
>> 2, REG_D2
>> 2, REG_D3
>> 2
88 u_int8_t opsz
, dispsz
;
96 [FMT_D2
] = { 16, 16 },
97 [FMT_D4
] = { 16, 32 },
100 [FMT_D8
] = { 24, 24 },
101 [FMT_D9
] = { 24, 32 },
102 [FMT_D10
] = { 32, 0 },
106 DM0
, /* data reg in opcode in bits 0-1 */
107 DM1
, /* data reg in opcode in bits 2-3 */
108 DM2
, /* data reg in opcode in bits 4-5 */
109 AM0
, /* addr reg in opcode in bits 0-1 */
110 AM1
, /* addr reg in opcode in bits 2-3 */
111 AM2
, /* addr reg in opcode in bits 4-5 */
112 RM0
, /* reg in opcode in bits 0-3 */
113 RM1
, /* reg in opcode in bits 2-5 */
114 RM2
, /* reg in opcode in bits 4-7 */
115 RM4
, /* reg in opcode in bits 8-11 */
116 RM6
, /* reg in opcode in bits 12-15 */
118 RD0
, /* reg in displacement in bits 0-3 */
119 RD2
, /* reg in displacement in bits 4-7 */
121 SP
, /* stack pointer */
123 SD8
, /* 8-bit signed displacement */
124 SD16
, /* 16-bit signed displacement */
125 SD24
, /* 24-bit signed displacement */
126 SIMM4_2
, /* 4-bit signed displacement in opcode bits 4-7 */
127 SIMM8
, /* 8-bit signed immediate */
128 IMM8
, /* 8-bit unsigned immediate */
129 IMM16
, /* 16-bit unsigned immediate */
130 IMM24
, /* 24-bit unsigned immediate */
131 IMM32
, /* 32-bit unsigned immediate */
132 IMM32_HIGH8
, /* 32-bit unsigned immediate, LSB in opcode */
134 IMM32_MEM
, /* 32-bit unsigned displacement */
135 IMM32_HIGH8_MEM
, /* 32-bit unsigned displacement, LSB in opcode */
153 struct mn10300_opcode
{
159 enum format_id format
;
165 #define MEM(ADDR) (0x80000000 | (ADDR))
166 #define MEM2(ADDR1, ADDR2) (0x80000000 | (ADDR1) << 8 | (ADDR2))
167 #define MEMINC(ADDR) (0x81000000 | (ADDR))
168 #define MEMINC2(ADDR, INC) (0x81000000 | (ADDR) << 8 | (INC))
171 /* LIBOPCODES EXCERPT
172 Assemble Matsushita MN10300 instructions.
173 Copyright 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
175 This program is free software; you can redistribute it and/or modify
176 it under the terms of the GNU General Public Licence as published by
177 the Free Software Foundation; either version 2 of the Licence, or
178 (at your option) any later version.
180 This program is distributed in the hope that it will be useful,
181 but WITHOUT ANY WARRANTY; without even the implied warranty of
182 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
183 GNU General Public Licence for more details.
185 You should have received a copy of the GNU General Public Licence
186 along with this program; if not, write to the Free Software
187 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
189 static const struct mn10300_opcode mn10300_opcodes
[] = {
190 { "mov", 0x4200, 0xf300, 0, FMT_S1
, 0, {DM1
, MEM2(IMM8
, SP
)}},
191 { "mov", 0x4300, 0xf300, 0, FMT_S1
, 0, {AM1
, MEM2(IMM8
, SP
)}},
192 { "mov", 0x5800, 0xfc00, 0, FMT_S1
, 0, {MEM2(IMM8
, SP
), DN0
}},
193 { "mov", 0x5c00, 0xfc00, 0, FMT_S1
, 0, {MEM2(IMM8
, SP
), AN0
}},
194 { "mov", 0x60, 0xf0, 0, FMT_S0
, 0, {DM1
, MEM(AN0
)}},
195 { "mov", 0x70, 0xf0, 0, FMT_S0
, 0, {MEM(AM0
), DN1
}},
196 { "mov", 0xf000, 0xfff0, 0, FMT_D0
, 0, {MEM(AM0
), AN1
}},
197 { "mov", 0xf010, 0xfff0, 0, FMT_D0
, 0, {AM1
, MEM(AN0
)}},
198 { "mov", 0xf300, 0xffc0, 0, FMT_D0
, 0, {MEM2(DI
, AM0
), DN2
}},
199 { "mov", 0xf340, 0xffc0, 0, FMT_D0
, 0, {DM2
, MEM2(DI
, AN0
)}},
200 { "mov", 0xf380, 0xffc0, 0, FMT_D0
, 0, {MEM2(DI
, AM0
), AN2
}},
201 { "mov", 0xf3c0, 0xffc0, 0, FMT_D0
, 0, {AM2
, MEM2(DI
, AN0
)}},
202 { "mov", 0xf80000, 0xfff000, 0, FMT_D1
, 0, {MEM2(SD8
, AM0
), DN1
}},
203 { "mov", 0xf81000, 0xfff000, 0, FMT_D1
, 0, {DM1
, MEM2(SD8
, AN0
)}},
204 { "mov", 0xf82000, 0xfff000, 0, FMT_D1
, 0, {MEM2(SD8
,AM0
), AN1
}},
205 { "mov", 0xf83000, 0xfff000, 0, FMT_D1
, 0, {AM1
, MEM2(SD8
, AN0
)}},
206 { "mov", 0xf8f000, 0xfffc00, 0, FMT_D1
, AM33
, {MEM2(SD8
, AM0
), SP
}},
207 { "mov", 0xf8f400, 0xfffc00, 0, FMT_D1
, AM33
, {SP
, MEM2(SD8
, AN0
)}},
208 { "mov", 0xf90a00, 0xffff00, 0, FMT_D6
, AM33
, {MEM(RM0
), RN2
}},
209 { "mov", 0xf91a00, 0xffff00, 0, FMT_D6
, AM33
, {RM2
, MEM(RN0
)}},
210 { "mov", 0xf96a00, 0xffff00, 0x12, FMT_D6
, AM33
, {MEMINC(RM0
), RN2
}},
211 { "mov", 0xf97a00, 0xffff00, 0, FMT_D6
, AM33
, {RM2
, MEMINC(RN0
)}},
212 { "mov", 0xfa000000, 0xfff00000, 0, FMT_D2
, 0, {MEM2(SD16
, AM0
), DN1
}},
213 { "mov", 0xfa100000, 0xfff00000, 0, FMT_D2
, 0, {DM1
, MEM2(SD16
, AN0
)}},
214 { "mov", 0xfa200000, 0xfff00000, 0, FMT_D2
, 0, {MEM2(SD16
, AM0
), AN1
}},
215 { "mov", 0xfa300000, 0xfff00000, 0, FMT_D2
, 0, {AM1
, MEM2(SD16
, AN0
)}},
216 { "mov", 0xfa900000, 0xfff30000, 0, FMT_D2
, 0, {AM1
, MEM2(IMM16
, SP
)}},
217 { "mov", 0xfa910000, 0xfff30000, 0, FMT_D2
, 0, {DM1
, MEM2(IMM16
, SP
)}},
218 { "mov", 0xfab00000, 0xfffc0000, 0, FMT_D2
, 0, {MEM2(IMM16
, SP
), AN0
}},
219 { "mov", 0xfab40000, 0xfffc0000, 0, FMT_D2
, 0, {MEM2(IMM16
, SP
), DN0
}},
220 { "mov", 0xfb0a0000, 0xffff0000, 0, FMT_D7
, AM33
, {MEM2(SD8
, RM0
), RN2
}},
221 { "mov", 0xfb1a0000, 0xffff0000, 0, FMT_D7
, AM33
, {RM2
, MEM2(SD8
, RN0
)}},
222 { "mov", 0xfb6a0000, 0xffff0000, 0x22, FMT_D7
, AM33
, {MEMINC2 (RM0
, SIMM8
), RN2
}},
223 { "mov", 0xfb7a0000, 0xffff0000, 0, FMT_D7
, AM33
, {RM2
, MEMINC2 (RN0
, SIMM8
)}},
224 { "mov", 0xfb8a0000, 0xffff0f00, 0, FMT_D7
, AM33
, {MEM2(IMM8
, SP
), RN2
}},
225 { "mov", 0xfb8e0000, 0xffff000f, 0, FMT_D7
, AM33
, {MEM2(RI
, RM0
), RD2
}},
226 { "mov", 0xfb9a0000, 0xffff0f00, 0, FMT_D7
, AM33
, {RM2
, MEM2(IMM8
, SP
)}},
227 { "mov", 0xfb9e0000, 0xffff000f, 0, FMT_D7
, AM33
, {RD2
, MEM2(RI
, RN0
)}},
228 { "mov", 0xfc000000, 0xfff00000, 0, FMT_D4
, 0, {MEM2(IMM32
,AM0
), DN1
}},
229 { "mov", 0xfc100000, 0xfff00000, 0, FMT_D4
, 0, {DM1
, MEM2(IMM32
,AN0
)}},
230 { "mov", 0xfc200000, 0xfff00000, 0, FMT_D4
, 0, {MEM2(IMM32
,AM0
), AN1
}},
231 { "mov", 0xfc300000, 0xfff00000, 0, FMT_D4
, 0, {AM1
, MEM2(IMM32
,AN0
)}},
232 { "mov", 0xfc800000, 0xfff30000, 0, FMT_D4
, 0, {AM1
, MEM(IMM32_MEM
)}},
233 { "mov", 0xfc810000, 0xfff30000, 0, FMT_D4
, 0, {DM1
, MEM(IMM32_MEM
)}},
234 { "mov", 0xfc900000, 0xfff30000, 0, FMT_D4
, 0, {AM1
, MEM2(IMM32
, SP
)}},
235 { "mov", 0xfc910000, 0xfff30000, 0, FMT_D4
, 0, {DM1
, MEM2(IMM32
, SP
)}},
236 { "mov", 0xfca00000, 0xfffc0000, 0, FMT_D4
, 0, {MEM(IMM32_MEM
), AN0
}},
237 { "mov", 0xfca40000, 0xfffc0000, 0, FMT_D4
, 0, {MEM(IMM32_MEM
), DN0
}},
238 { "mov", 0xfcb00000, 0xfffc0000, 0, FMT_D4
, 0, {MEM2(IMM32
, SP
), AN0
}},
239 { "mov", 0xfcb40000, 0xfffc0000, 0, FMT_D4
, 0, {MEM2(IMM32
, SP
), DN0
}},
240 { "mov", 0xfd0a0000, 0xffff0000, 0, FMT_D8
, AM33
, {MEM2(SD24
, RM0
), RN2
}},
241 { "mov", 0xfd1a0000, 0xffff0000, 0, FMT_D8
, AM33
, {RM2
, MEM2(SD24
, RN0
)}},
242 { "mov", 0xfd6a0000, 0xffff0000, 0x22, FMT_D8
, AM33
, {MEMINC2 (RM0
, IMM24
), RN2
}},
243 { "mov", 0xfd7a0000, 0xffff0000, 0, FMT_D8
, AM33
, {RM2
, MEMINC2 (RN0
, IMM24
)}},
244 { "mov", 0xfd8a0000, 0xffff0f00, 0, FMT_D8
, AM33
, {MEM2(IMM24
, SP
), RN2
}},
245 { "mov", 0xfd9a0000, 0xffff0f00, 0, FMT_D8
, AM33
, {RM2
, MEM2(IMM24
, SP
)}},
246 { "mov", 0xfe0a0000, 0xffff0000, 0, FMT_D9
, AM33
, {MEM2(IMM32_HIGH8
,RM0
), RN2
}},
247 { "mov", 0xfe0a0000, 0xffff0000, 0, FMT_D9
, AM33
, {MEM2(IMM32_HIGH8
,RM0
), RN2
}},
248 { "mov", 0xfe0e0000, 0xffff0f00, 0, FMT_D9
, AM33
, {MEM(IMM32_HIGH8_MEM
), RN2
}},
249 { "mov", 0xfe1a0000, 0xffff0000, 0, FMT_D9
, AM33
, {RM2
, MEM2(IMM32_HIGH8
, RN0
)}},
250 { "mov", 0xfe1a0000, 0xffff0000, 0, FMT_D9
, AM33
, {RM2
, MEM2(IMM32_HIGH8
, RN0
)}},
251 { "mov", 0xfe1e0000, 0xffff0f00, 0, FMT_D9
, AM33
, {RM2
, MEM(IMM32_HIGH8_MEM
)}},
252 { "mov", 0xfe6a0000, 0xffff0000, 0x22, FMT_D9
, AM33
, {MEMINC2 (RM0
, IMM32_HIGH8
), RN2
}},
253 { "mov", 0xfe7a0000, 0xffff0000, 0, FMT_D9
, AM33
, {RN2
, MEMINC2 (RM0
, IMM32_HIGH8
)}},
254 { "mov", 0xfe8a0000, 0xffff0f00, 0, FMT_D9
, AM33
, {MEM2(IMM32_HIGH8
, SP
), RN2
}},
255 { "mov", 0xfe9a0000, 0xffff0f00, 0, FMT_D9
, AM33
, {RM2
, MEM2(IMM32_HIGH8
, SP
)}},
257 { "movhu", 0xf060, 0xfff0, 0, FMT_D0
, 0, {MEM(AM0
), DN1
}},
258 { "movhu", 0xf070, 0xfff0, 0, FMT_D0
, 0, {DM1
, MEM(AN0
)}},
259 { "movhu", 0xf480, 0xffc0, 0, FMT_D0
, 0, {MEM2(DI
, AM0
), DN2
}},
260 { "movhu", 0xf4c0, 0xffc0, 0, FMT_D0
, 0, {DM2
, MEM2(DI
, AN0
)}},
261 { "movhu", 0xf86000, 0xfff000, 0, FMT_D1
, 0, {MEM2(SD8
, AM0
), DN1
}},
262 { "movhu", 0xf87000, 0xfff000, 0, FMT_D1
, 0, {DM1
, MEM2(SD8
, AN0
)}},
263 { "movhu", 0xf89300, 0xfff300, 0, FMT_D1
, 0, {DM1
, MEM2(IMM8
, SP
)}},
264 { "movhu", 0xf8bc00, 0xfffc00, 0, FMT_D1
, 0, {MEM2(IMM8
, SP
), DN0
}},
265 { "movhu", 0xf94a00, 0xffff00, 0, FMT_D6
, AM33
, {MEM(RM0
), RN2
}},
266 { "movhu", 0xf95a00, 0xffff00, 0, FMT_D6
, AM33
, {RM2
, MEM(RN0
)}},
267 { "movhu", 0xf9ea00, 0xffff00, 0x12, FMT_D6
, AM33
, {MEMINC(RM0
), RN2
}},
268 { "movhu", 0xf9fa00, 0xffff00, 0, FMT_D6
, AM33
, {RM2
, MEMINC(RN0
)}},
269 { "movhu", 0xfa600000, 0xfff00000, 0, FMT_D2
, 0, {MEM2(SD16
, AM0
), DN1
}},
270 { "movhu", 0xfa700000, 0xfff00000, 0, FMT_D2
, 0, {DM1
, MEM2(SD16
, AN0
)}},
271 { "movhu", 0xfa930000, 0xfff30000, 0, FMT_D2
, 0, {DM1
, MEM2(IMM16
, SP
)}},
272 { "movhu", 0xfabc0000, 0xfffc0000, 0, FMT_D2
, 0, {MEM2(IMM16
, SP
), DN0
}},
273 { "movhu", 0xfb4a0000, 0xffff0000, 0, FMT_D7
, AM33
, {MEM2(SD8
, RM0
), RN2
}},
274 { "movhu", 0xfb5a0000, 0xffff0000, 0, FMT_D7
, AM33
, {RM2
, MEM2(SD8
, RN0
)}},
275 { "movhu", 0xfbca0000, 0xffff0f00, 0, FMT_D7
, AM33
, {MEM2(IMM8
, SP
), RN2
}},
276 { "movhu", 0xfbce0000, 0xffff000f, 0, FMT_D7
, AM33
, {MEM2(RI
, RM0
), RD2
}},
277 { "movhu", 0xfbda0000, 0xffff0f00, 0, FMT_D7
, AM33
, {RM2
, MEM2(IMM8
, SP
)}},
278 { "movhu", 0xfbde0000, 0xffff000f, 0, FMT_D7
, AM33
, {RD2
, MEM2(RI
, RN0
)}},
279 { "movhu", 0xfbea0000, 0xffff0000, 0x22, FMT_D7
, AM33
, {MEMINC2 (RM0
, SIMM8
), RN2
}},
280 { "movhu", 0xfbfa0000, 0xffff0000, 0, FMT_D7
, AM33
, {RM2
, MEMINC2 (RN0
, SIMM8
)}},
281 { "movhu", 0xfc600000, 0xfff00000, 0, FMT_D4
, 0, {MEM2(IMM32
,AM0
), DN1
}},
282 { "movhu", 0xfc700000, 0xfff00000, 0, FMT_D4
, 0, {DM1
, MEM2(IMM32
,AN0
)}},
283 { "movhu", 0xfc830000, 0xfff30000, 0, FMT_D4
, 0, {DM1
, MEM(IMM32_MEM
)}},
284 { "movhu", 0xfc930000, 0xfff30000, 0, FMT_D4
, 0, {DM1
, MEM2(IMM32
, SP
)}},
285 { "movhu", 0xfcac0000, 0xfffc0000, 0, FMT_D4
, 0, {MEM(IMM32_MEM
), DN0
}},
286 { "movhu", 0xfcbc0000, 0xfffc0000, 0, FMT_D4
, 0, {MEM2(IMM32
, SP
), DN0
}},
287 { "movhu", 0xfd4a0000, 0xffff0000, 0, FMT_D8
, AM33
, {MEM2(SD24
, RM0
), RN2
}},
288 { "movhu", 0xfd5a0000, 0xffff0000, 0, FMT_D8
, AM33
, {RM2
, MEM2(SD24
, RN0
)}},
289 { "movhu", 0xfdca0000, 0xffff0f00, 0, FMT_D8
, AM33
, {MEM2(IMM24
, SP
), RN2
}},
290 { "movhu", 0xfdda0000, 0xffff0f00, 0, FMT_D8
, AM33
, {RM2
, MEM2(IMM24
, SP
)}},
291 { "movhu", 0xfdea0000, 0xffff0000, 0x22, FMT_D8
, AM33
, {MEMINC2 (RM0
, IMM24
), RN2
}},
292 { "movhu", 0xfdfa0000, 0xffff0000, 0, FMT_D8
, AM33
, {RM2
, MEMINC2 (RN0
, IMM24
)}},
293 { "movhu", 0xfe4a0000, 0xffff0000, 0, FMT_D9
, AM33
, {MEM2(IMM32_HIGH8
,RM0
), RN2
}},
294 { "movhu", 0xfe4e0000, 0xffff0f00, 0, FMT_D9
, AM33
, {MEM(IMM32_HIGH8_MEM
), RN2
}},
295 { "movhu", 0xfe5a0000, 0xffff0000, 0, FMT_D9
, AM33
, {RM2
, MEM2(IMM32_HIGH8
, RN0
)}},
296 { "movhu", 0xfe5e0000, 0xffff0f00, 0, FMT_D9
, AM33
, {RM2
, MEM(IMM32_HIGH8_MEM
)}},
297 { "movhu", 0xfeca0000, 0xffff0f00, 0, FMT_D9
, AM33
, {MEM2(IMM32_HIGH8
, SP
), RN2
}},
298 { "movhu", 0xfeda0000, 0xffff0f00, 0, FMT_D9
, AM33
, {RM2
, MEM2(IMM32_HIGH8
, SP
)}},
299 { "movhu", 0xfeea0000, 0xffff0000, 0x22, FMT_D9
, AM33
, {MEMINC2 (RM0
, IMM32_HIGH8
), RN2
}},
300 { "movhu", 0xfefa0000, 0xffff0000, 0, FMT_D9
, AM33
, {RN2
, MEMINC2 (RM0
, IMM32_HIGH8
)}},
302 { "mov_llt", 0xf7e00000, 0xffff000f, 0x22, FMT_D10
, AM33
, {MEMINC2 (RN4
,SIMM4_2
), RM6
}},
303 { "mov_lgt", 0xf7e00001, 0xffff000f, 0x22, FMT_D10
, AM33
, {MEMINC2 (RN4
,SIMM4_2
), RM6
}},
304 { "mov_lge", 0xf7e00002, 0xffff000f, 0x22, FMT_D10
, AM33
, {MEMINC2 (RN4
,SIMM4_2
), RM6
}},
305 { "mov_lle", 0xf7e00003, 0xffff000f, 0x22, FMT_D10
, AM33
, {MEMINC2 (RN4
,SIMM4_2
), RM6
}},
306 { "mov_lcs", 0xf7e00004, 0xffff000f, 0x22, FMT_D10
, AM33
, {MEMINC2 (RN4
,SIMM4_2
), RM6
}},
307 { "mov_lhi", 0xf7e00005, 0xffff000f, 0x22, FMT_D10
, AM33
, {MEMINC2 (RN4
,SIMM4_2
), RM6
}},
308 { "mov_lcc", 0xf7e00006, 0xffff000f, 0x22, FMT_D10
, AM33
, {MEMINC2 (RN4
,SIMM4_2
), RM6
}},
309 { "mov_lls", 0xf7e00007, 0xffff000f, 0x22, FMT_D10
, AM33
, {MEMINC2 (RN4
,SIMM4_2
), RM6
}},
310 { "mov_leq", 0xf7e00008, 0xffff000f, 0x22, FMT_D10
, AM33
, {MEMINC2 (RN4
,SIMM4_2
), RM6
}},
311 { "mov_lne", 0xf7e00009, 0xffff000f, 0x22, FMT_D10
, AM33
, {MEMINC2 (RN4
,SIMM4_2
), RM6
}},
312 { "mov_lra", 0xf7e0000a, 0xffff000f, 0x22, FMT_D10
, AM33
, {MEMINC2 (RN4
,SIMM4_2
), RM6
}},
314 { "", 0, 0, 0, 0, 0, {0}},
318 * fix up misalignment problems where possible
320 asmlinkage
void misalignment(struct pt_regs
*regs
, enum exception_code code
)
322 const struct exception_table_entry
*fixup
;
323 const struct mn10300_opcode
*pop
;
324 unsigned long *registers
= (unsigned long *) regs
;
325 unsigned long data
, *store
, *postinc
, disp
, inc
;
328 uint32_t opcode
, noc
, xo
, xm
;
329 uint8_t *pc
, byte
, datasz
;
331 unsigned tmp
, npop
, dispsz
, loop
;
333 kdebug("==>misalignment({pc=%lx})", regs
->pc
);
335 if (regs
->epsw
& EPSW_IE
)
336 asm volatile("or %0,epsw" : : "i"(EPSW_IE
));
341 fixup
= search_exception_tables(regs
->pc
);
343 /* first thing to do is to match the opcode */
344 pc
= (u_int8_t
*) regs
->pc
;
346 if (__get_user(byte
, pc
) != 0)
351 for (pop
= mn10300_opcodes
; pop
->name
[0]; pop
++) {
352 npop
= ilog2(pop
->opcode
| pop
->opmask
);
353 if (npop
<= 0 || npop
> 31)
355 npop
= (npop
+ 8) & ~7;
359 if ((opcode
& pop
->opmask
) == pop
->opcode
)
361 } else if (npop
> noc
) {
362 xo
= pop
->opcode
>> (npop
- noc
);
363 xm
= pop
->opmask
>> (npop
- noc
);
365 if ((opcode
& xm
) != xo
)
368 /* we've got a partial match (an exact match on the
369 * first N bytes), so we need to get some more data */
371 if (__get_user(byte
, pc
) != 0)
373 opcode
= opcode
<< 8 | byte
;
377 /* there's already been a partial match as long as the
378 * complete match we're now considering, so this one
384 /* didn't manage to find a fixup */
385 if (!user_mode(regs
))
386 printk(KERN_CRIT
"MISALIGN: %lx: unsupported instruction %x\n",
391 if (die_if_no_fixup("misalignment error", regs
, code
))
394 info
.si_signo
= SIGBUS
;
396 info
.si_code
= BUS_ADRALN
;
397 info
.si_addr
= (void *) regs
->pc
;
398 force_sig_info(SIGBUS
, &info
, current
);
401 /* error reading opcodes */
403 if (!user_mode(regs
))
405 "MISALIGN: %p: fault whilst reading instruction data\n",
410 if (!user_mode(regs
))
412 "MISALIGN: %lx: unsupported addressing mode %x\n",
417 if (!user_mode(regs
))
419 "MISALIGN: %lx: unsupported register mode %x\n",
423 unsupported_instruction
:
424 if (!user_mode(regs
))
426 "MISALIGN: %lx: unsupported instruction %x (%s)\n",
427 regs
->pc
, opcode
, pop
->name
);
433 regs
->pc
= fixup
->fixup
;
436 if (die_if_no_fixup("misalignment fixup", regs
, code
))
439 info
.si_signo
= SIGSEGV
;
442 info
.si_addr
= (void *) regs
->pc
;
443 force_sig_info(SIGSEGV
, &info
, current
);
446 /* we matched the opcode */
448 kdebug("%lx: %x==%x { %x, %x }",
449 regs
->pc
, opcode
, pop
->opcode
, pop
->params
[0], pop
->params
[1]);
451 tmp
= format_tbl
[pop
->format
].opsz
;
453 BUG(); /* match was less complete than it ought to have been */
461 /* grab the extra displacement (note it's LSB first) */
463 dispsz
= format_tbl
[pop
->format
].dispsz
;
464 for (loop
= 0; loop
< dispsz
; loop
+= 8) {
466 if (__get_user(byte
, pc
) != 0)
468 disp
|= byte
<< loop
;
469 kdebug("{%p} disp[%02x]=%02x", pc
, loop
, byte
);
472 kdebug("disp=%lx", disp
);
475 if (fixup
|| regs
->epsw
& EPSW_nSL
)
478 tmp
= (pop
->params
[0] ^ pop
->params
[1]) & 0x80000000;
480 if (!user_mode(regs
))
483 " insn not move to/from memory %x\n",
488 /* determine the data transfer size of the move */
489 if (pop
->name
[3] == 0 || /* "mov" */
490 pop
->name
[4] == 'l') /* mov_lcc */
492 else if (pop
->name
[3] == 'h') /* movhu */
495 goto unsupported_instruction
;
497 if (pop
->params
[0] & 0x80000000) {
498 /* move memory to register */
499 if (!misalignment_addr(registers
, pop
->params
[0], opcode
, disp
,
500 &address
, &postinc
, &inc
))
503 if (!misalignment_reg(registers
, pop
->params
[1], opcode
, disp
,
507 kdebug("mov%u (%p),DARn", datasz
, address
);
508 if (copy_from_user(&data
, (void *) address
, datasz
) != 0)
509 goto transfer_failed
;
510 if (pop
->params
[0] & 0x1000000) {
511 kdebug("inc=%lx", inc
);
516 kdebug("loaded %lx", data
);
518 /* move register to memory */
519 if (!misalignment_reg(registers
, pop
->params
[0], opcode
, disp
,
523 if (!misalignment_addr(registers
, pop
->params
[1], opcode
, disp
,
524 &address
, &postinc
, &inc
))
529 kdebug("mov%u %lx,(%p)", datasz
, data
, address
);
530 if (copy_to_user((void *) address
, &data
, datasz
) != 0)
531 goto transfer_failed
;
532 if (pop
->params
[1] & 0x1000000)
536 tmp
= format_tbl
[pop
->format
].opsz
+ format_tbl
[pop
->format
].dispsz
;
537 regs
->pc
+= tmp
>> 3;
539 /* handle MOV_Lcc, which are currently the only FMT_D10 insns that
541 if (pop
->format
== FMT_D10
)
542 misalignment_MOV_Lcc(regs
, opcode
);
549 * determine the address that was being accessed
551 static int misalignment_addr(unsigned long *registers
, unsigned params
,
552 unsigned opcode
, unsigned long disp
,
553 void **_address
, unsigned long **_postinc
,
556 unsigned long *postinc
= NULL
, address
= 0, tmp
;
558 if (!(params
& 0x1000000)) {
564 params
&= 0x00ffffff;
567 switch (params
& 0xff) {
569 postinc
= ®isters
[Dreg_index
[opcode
& 0x03]];
573 postinc
= ®isters
[Dreg_index
[opcode
>> 2 & 0x03]];
577 postinc
= ®isters
[Dreg_index
[opcode
>> 4 & 0x03]];
581 postinc
= ®isters
[Areg_index
[opcode
& 0x03]];
585 postinc
= ®isters
[Areg_index
[opcode
>> 2 & 0x03]];
589 postinc
= ®isters
[Areg_index
[opcode
>> 4 & 0x03]];
593 postinc
= ®isters
[Rreg_index
[opcode
& 0x0f]];
597 postinc
= ®isters
[Rreg_index
[opcode
>> 2 & 0x0f]];
601 postinc
= ®isters
[Rreg_index
[opcode
>> 4 & 0x0f]];
605 postinc
= ®isters
[Rreg_index
[opcode
>> 8 & 0x0f]];
609 postinc
= ®isters
[Rreg_index
[opcode
>> 12 & 0x0f]];
613 postinc
= ®isters
[Rreg_index
[disp
& 0x0f]];
617 postinc
= ®isters
[Rreg_index
[disp
>> 4 & 0x0f]];
621 address
+= registers
[REG_SP
>> 2];
624 /* displacements are either to be added to the address
625 * before use, or, in the case of post-inc addressing,
626 * to be added into the base register after use */
629 disp
= (long) (int8_t) (disp
& 0xff);
630 goto displace_or_inc
;
632 disp
= (long) (int16_t) (disp
& 0xffff);
633 goto displace_or_inc
;
636 asm("asr 8,%0" : "=r"(tmp
) : "0"(tmp
));
638 goto displace_or_inc
;
640 tmp
= opcode
>> 4 & 0x0f;
642 asm("asr 28,%0" : "=r"(tmp
) : "0"(tmp
));
644 goto displace_or_inc
;
647 goto displace_or_inc
;
651 case IMM32_HIGH8_MEM
:
653 kdebug("%s %lx", _inc
? "incr" : "disp", disp
);
663 } while ((params
>>= 8));
665 *_address
= (void *) address
;
671 * determine the register that is acting as source/dest
673 static int misalignment_reg(unsigned long *registers
, unsigned params
,
674 unsigned opcode
, unsigned long disp
,
675 unsigned long **_register
)
677 params
&= 0x7fffffff;
679 if (params
& 0xffffff00)
682 switch (params
& 0xff) {
684 *_register
= ®isters
[Dreg_index
[opcode
& 0x03]];
687 *_register
= ®isters
[Dreg_index
[opcode
>> 2 & 0x03]];
690 *_register
= ®isters
[Dreg_index
[opcode
>> 4 & 0x03]];
693 *_register
= ®isters
[Areg_index
[opcode
& 0x03]];
696 *_register
= ®isters
[Areg_index
[opcode
>> 2 & 0x03]];
699 *_register
= ®isters
[Areg_index
[opcode
>> 4 & 0x03]];
702 *_register
= ®isters
[Rreg_index
[opcode
& 0x0f]];
705 *_register
= ®isters
[Rreg_index
[opcode
>> 2 & 0x0f]];
708 *_register
= ®isters
[Rreg_index
[opcode
>> 4 & 0x0f]];
711 *_register
= ®isters
[Rreg_index
[opcode
>> 8 & 0x0f]];
714 *_register
= ®isters
[Rreg_index
[opcode
>> 12 & 0x0f]];
717 *_register
= ®isters
[Rreg_index
[disp
& 0x0f]];
720 *_register
= ®isters
[Rreg_index
[disp
>> 4 & 0x0f]];
723 *_register
= ®isters
[REG_SP
>> 2];
735 * handle the conditional loop part of the move-and-loop instructions
737 static void misalignment_MOV_Lcc(struct pt_regs
*regs
, uint32_t opcode
)
739 unsigned long epsw
= regs
->epsw
;
742 kdebug("MOV_Lcc %x [flags=%lx]", opcode
, epsw
& 0xf);
744 /* calculate N^V and shift onto the same bit position as Z */
745 NxorV
= ((epsw
>> 3) ^ epsw
>> 1) & 1;
747 switch (opcode
& 0xf) {
748 case 0x0: /* MOV_LLT: N^V */
752 case 0x1: /* MOV_LGT: ~(Z or (N^V))*/
753 if (!((epsw
& EPSW_FLAG_Z
) | NxorV
))
756 case 0x2: /* MOV_LGE: ~(N^V) */
760 case 0x3: /* MOV_LLE: Z or (N^V) */
761 if ((epsw
& EPSW_FLAG_Z
) | NxorV
)
765 case 0x4: /* MOV_LCS: C */
766 if (epsw
& EPSW_FLAG_C
)
769 case 0x5: /* MOV_LHI: ~(C or Z) */
770 if (!(epsw
& (EPSW_FLAG_C
| EPSW_FLAG_Z
)))
773 case 0x6: /* MOV_LCC: ~C */
774 if (!(epsw
& EPSW_FLAG_C
))
777 case 0x7: /* MOV_LLS: C or Z */
778 if (epsw
& (EPSW_FLAG_C
| EPSW_FLAG_Z
))
782 case 0x8: /* MOV_LEQ: Z */
783 if (epsw
& EPSW_FLAG_Z
)
786 case 0x9: /* MOV_LNE: ~Z */
787 if (!(epsw
& EPSW_FLAG_Z
))
790 case 0xa: /* MOV_LRA: always */
798 /* wind the PC back to just after the SETLB insn */
799 kdebug("loop LAR=%lx", regs
->lar
);
800 regs
->pc
= regs
->lar
- 4;
804 * misalignment handler tests
806 #ifdef CONFIG_TEST_MISALIGNMENT_HANDLER
807 static u8 __initdata testbuf
[512] __attribute__((aligned(16))) = {
814 #define ASSERTCMP(X, OP, Y) \
816 if (unlikely(!((X) OP (Y)))) { \
817 printk(KERN_ERR "\n"); \
818 printk(KERN_ERR "MISALIGN: Assertion failed at line %u\n", \
820 printk(KERN_ERR "0x%lx " #OP " 0x%lx is false\n", \
821 (unsigned long)(X), (unsigned long)(Y)); \
826 static int __init
test_misalignment(void)
828 register void *r
asm("e0");
829 register u32 y
asm("e1");
830 void *p
= testbuf
, *q
;
833 printk(KERN_NOTICE
"==>test_misalignment() [testbuf=%p]\n", p
);
836 printk(KERN_NOTICE
"___ MOV (Am),Dn ___\n");
838 asm volatile("mov (%0),%1" : "+a"(q
), "=d"(x
));
839 ASSERTCMP(q
, ==, p
+ 256);
840 ASSERTCMP(x
, ==, 0x44332211);
842 printk(KERN_NOTICE
"___ MOV (256,Am),Dn ___\n");
844 asm volatile("mov (256,%0),%1" : "+a"(q
), "=d"(x
));
846 ASSERTCMP(x
, ==, 0x44332211);
848 printk(KERN_NOTICE
"___ MOV (Di,Am),Dn ___\n");
851 asm volatile("mov (%2,%0),%1" : "+a"(q
), "=d"(x
), "+d"(tmp
));
853 ASSERTCMP(x
, ==, 0x44332211);
854 ASSERTCMP(tmp
, ==, 256);
856 printk(KERN_NOTICE
"___ MOV (256,Rm),Rn ___\n");
858 asm volatile("mov (256,%0),%1" : "+r"(r
), "=r"(y
));
860 ASSERTCMP(y
, ==, 0x44332211);
862 printk(KERN_NOTICE
"___ MOV (Rm+),Rn ___\n");
864 asm volatile("mov (%0+),%1" : "+r"(r
), "=r"(y
));
865 ASSERTCMP(r
, ==, p
+ 256 + 4);
866 ASSERTCMP(y
, ==, 0x44332211);
868 printk(KERN_NOTICE
"___ MOV (Rm+,8),Rn ___\n");
870 asm volatile("mov (%0+,8),%1" : "+r"(r
), "=r"(y
));
871 ASSERTCMP(r
, ==, p
+ 256 + 8);
872 ASSERTCMP(y
, ==, 0x44332211);
874 printk(KERN_NOTICE
"___ MOV (7,SP),Rn ___\n");
884 "movbu %0,(10,sp) \n"
888 ASSERTCMP(x
, ==, 0x44332211);
890 printk(KERN_NOTICE
"___ MOV (259,SP),Rn ___\n");
894 "movbu %0,(259,sp) \n"
896 "movbu %0,(260,sp) \n"
898 "movbu %0,(261,sp) \n"
900 "movbu %0,(262,sp) \n"
903 : "+d"(tmp
), "=d"(x
));
904 ASSERTCMP(x
, ==, 0x55332211);
906 printk(KERN_NOTICE
"___ MOV (260,SP),Rn ___\n");
910 "movbu %0,(260,sp) \n"
912 "movbu %0,(261,sp) \n"
914 "movbu %0,(262,sp) \n"
916 "movbu %0,(263,sp) \n"
919 : "+d"(tmp
), "=d"(x
));
920 ASSERTCMP(x
, ==, 0x55332211);
923 printk(KERN_NOTICE
"___ MOV_LNE ___\n");
933 : "+r"(q
), "+d"(tmp
), "+d"(tmp2
), "=d"(x
)
936 ASSERTCMP(q
, ==, p
+ 256 + 12);
937 ASSERTCMP(x
, ==, 0x44332211);
939 printk(KERN_NOTICE
"___ MOV in SETLB ___\n");
949 : "+a"(q
), "+d"(tmp
), "+d"(tmp2
), "=d"(x
)
953 ASSERTCMP(q
, ==, p
+ 256 + 8);
954 ASSERTCMP(x
, ==, 0x44332211);
956 printk(KERN_NOTICE
"<==test_misalignment()\n");
960 arch_initcall(test_misalignment
);
962 #endif /* CONFIG_TEST_MISALIGNMENT_HANDLER */