URL https://opencores.org/ocsvn/or1k_soc_on_altera_embedded_dev_kit/or1k_soc_on_altera_embedded_dev_kit/trunk

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [arch/] [powerpc/] [lib/] [sstep.c] - Blame information for rev 3

Details | Compare with Previous | View Log


/*
 * Single-step support.
 *
 * Copyright (C) 2004 Paul Mackerras <paulus@au.ibm.com>, IBM
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version
 * 2 of the License, or (at your option) any later version.
 */
#include <linux/kernel.h>
#include <linux/kprobes.h>
#include <linux/ptrace.h>
#include <asm/sstep.h>
#include <asm/processor.h>
 
extern char system_call_common[];
 
#ifdef CONFIG_PPC64
/* Bits in SRR1 that are copied from MSR */
#define MSR_MASK        0xffffffff87c0ffffUL
#else
#define MSR_MASK        0x87c0ffff
#endif
 
/*
 * Determine whether a conditional branch instruction would branch.
 */
static int __kprobes branch_taken(unsigned int instr, struct pt_regs *regs)
{
        unsigned int bo = (instr >> 21) & 0x1f;
        unsigned int bi;
 
        if ((bo & 4) == 0) {
                /* decrement counter */
                --regs->ctr;
                if (((bo >> 1) & 1) ^ (regs->ctr == 0))
                        return 0;
        }
        if ((bo & 0x10) == 0) {
                /* check bit from CR */
                bi = (instr >> 16) & 0x1f;
                if (((regs->ccr >> (31 - bi)) & 1) != ((bo >> 3) & 1))
                        return 0;
        }
        return 1;
}
 
/*
 * Emulate instructions that cause a transfer of control.
 * Returns 1 if the step was emulated, 0 if not,
 * or -1 if the instruction is one that should not be stepped,
 * such as an rfid, or a mtmsrd that would clear MSR_RI.
 */
int __kprobes emulate_step(struct pt_regs *regs, unsigned int instr)
{
        unsigned int opcode, rs, rb, rd, spr;
        unsigned long int imm;
 
        opcode = instr >> 26;
        switch (opcode) {
        case 16:        /* bc */
                imm = (signed short)(instr & 0xfffc);
                if ((instr & 2) == 0)
                        imm += regs->nip;
                regs->nip += 4;
                if ((regs->msr & MSR_SF) == 0)
                        regs->nip &= 0xffffffffUL;
                if (instr & 1)
                        regs->link = regs->nip;
                if (branch_taken(instr, regs))
                        regs->nip = imm;
                return 1;
#ifdef CONFIG_PPC64
        case 17:        /* sc */
                /*
                 * N.B. this uses knowledge about how the syscall
                 * entry code works.  If that is changed, this will
                 * need to be changed also.
                 */
                regs->gpr[9] = regs->gpr[13];
                regs->gpr[11] = regs->nip + 4;
                regs->gpr[12] = regs->msr & MSR_MASK;
                regs->gpr[13] = (unsigned long) get_paca();
                regs->nip = (unsigned long) &system_call_common;
                regs->msr = MSR_KERNEL;
                return 1;
#endif
        case 18:        /* b */
                imm = instr & 0x03fffffc;
                if (imm & 0x02000000)
                        imm -= 0x04000000;
                if ((instr & 2) == 0)
                        imm += regs->nip;
                if (instr & 1) {
                        regs->link = regs->nip + 4;
                        if ((regs->msr & MSR_SF) == 0)
                                regs->link &= 0xffffffffUL;
                }
                if ((regs->msr & MSR_SF) == 0)
                        imm &= 0xffffffffUL;
                regs->nip = imm;
                return 1;
        case 19:
                switch (instr & 0x7fe) {
                case 0x20:      /* bclr */
                case 0x420:     /* bcctr */
                        imm = (instr & 0x400)? regs->ctr: regs->link;
                        regs->nip += 4;
                        if ((regs->msr & MSR_SF) == 0) {
                                regs->nip &= 0xffffffffUL;
                                imm &= 0xffffffffUL;
                        }
                        if (instr & 1)
                                regs->link = regs->nip;
                        if (branch_taken(instr, regs))
                                regs->nip = imm;
                        return 1;
                case 0x24:      /* rfid, scary */
                        return -1;
                }
        case 31:
                rd = (instr >> 21) & 0x1f;
                switch (instr & 0x7fe) {
                case 0xa6:      /* mfmsr */
                        regs->gpr[rd] = regs->msr & MSR_MASK;
                        regs->nip += 4;
                        if ((regs->msr & MSR_SF) == 0)
                                regs->nip &= 0xffffffffUL;
                        return 1;
                case 0x124:     /* mtmsr */
                        imm = regs->gpr[rd];
                        if ((imm & MSR_RI) == 0)
                                /* can't step mtmsr that would clear MSR_RI */
                                return -1;
                        regs->msr = imm;
                        regs->nip += 4;
                        return 1;
#ifdef CONFIG_PPC64
                case 0x164:     /* mtmsrd */
                        /* only MSR_EE and MSR_RI get changed if bit 15 set */
                        /* mtmsrd doesn't change MSR_HV and MSR_ME */
                        imm = (instr & 0x10000)? 0x8002: 0xefffffffffffefffUL;
                        imm = (regs->msr & MSR_MASK & ~imm)
                                | (regs->gpr[rd] & imm);
                        if ((imm & MSR_RI) == 0)
                                /* can't step mtmsrd that would clear MSR_RI */
                                return -1;
                        regs->msr = imm;
                        regs->nip += 4;
                        if ((imm & MSR_SF) == 0)
                                regs->nip &= 0xffffffffUL;
                        return 1;
#endif
                case 0x26:      /* mfcr */
                        regs->gpr[rd] = regs->ccr;
                        regs->gpr[rd] &= 0xffffffffUL;
                        goto mtspr_out;
                case 0x2a6:     /* mfspr */
                        spr = (instr >> 11) & 0x3ff;
                        switch (spr) {
                        case 0x20:      /* mfxer */
                                regs->gpr[rd] = regs->xer;
                                regs->gpr[rd] &= 0xffffffffUL;
                                goto mtspr_out;
                        case 0x100:     /* mflr */
                                regs->gpr[rd] = regs->link;
                                goto mtspr_out;
                        case 0x120:     /* mfctr */
                                regs->gpr[rd] = regs->ctr;
                                goto mtspr_out;
                        }
                        break;
                case 0x378:     /* orx */
                        rs = (instr >> 21) & 0x1f;
                        rb = (instr >> 11) & 0x1f;
                        if (rs == rb) {         /* mr */
                                rd = (instr >> 16) & 0x1f;
                                regs->gpr[rd] = regs->gpr[rs];
                                goto mtspr_out;
                        }
                        break;
                case 0x3a6:     /* mtspr */
                        spr = (instr >> 11) & 0x3ff;
                        switch (spr) {
                        case 0x20:      /* mtxer */
                                regs->xer = (regs->gpr[rd] & 0xffffffffUL);
                                goto mtspr_out;
                        case 0x100:     /* mtlr */
                                regs->link = regs->gpr[rd];
                                goto mtspr_out;
                        case 0x120:     /* mtctr */
                                regs->ctr = regs->gpr[rd];
mtspr_out:
                                regs->nip += 4;
                                return 1;
                        }
                }
        }
        return 0;
}

Browse

Tools

Subversion Repositories or1k_soc_on_altera_embedded_dev_kit

[/] [or1k_soc_on_altera_embedded_dev_kit/] [trunk/] [linux-2.6/] [linux-2.6.24/] [arch/] [powerpc/] [lib/] [sstep.c] - Blame information for rev 3

Line No.	Rev	Author	Line
1	3	xianfeng	`/*`
2			`* Single-step support.`
3			`*`
4			`* Copyright (C) 2004 Paul Mackerras <paulus@au.ibm.com>, IBM`
5			`*`
6			`* This program is free software; you can redistribute it and/or`
7			`* modify it under the terms of the GNU General Public License`
8			`* as published by the Free Software Foundation; either version`
9			`* 2 of the License, or (at your option) any later version.`
10			`*/`
11			`#include <linux/kernel.h>`
12			`#include <linux/kprobes.h>`
13			`#include <linux/ptrace.h>`
14			`#include <asm/sstep.h>`
15			`#include <asm/processor.h>`
16
17			`extern char system_call_common[];`
18
19			`#ifdef CONFIG_PPC64`
20			`/* Bits in SRR1 that are copied from MSR */`
21			`#define MSR_MASK 0xffffffff87c0ffffUL`
22			`#else`
23			`#define MSR_MASK 0x87c0ffff`
24			`#endif`
25
26			`/*`
27			`* Determine whether a conditional branch instruction would branch.`
28			`*/`
29			`static int __kprobes branch_taken(unsigned int instr, struct pt_regs *regs)`
30			`{`
31			`unsigned int bo = (instr >> 21) & 0x1f;`
32			`unsigned int bi;`
33
34			`if ((bo & 4) == 0) {`
35			`/* decrement counter */`
36			`--regs->ctr;`
37			`if (((bo >> 1) & 1) ^ (regs->ctr == 0))`
38			`return 0;`
39			`}`
40			`if ((bo & 0x10) == 0) {`
41			`/* check bit from CR */`
42			`bi = (instr >> 16) & 0x1f;`
43			`if (((regs->ccr >> (31 - bi)) & 1) != ((bo >> 3) & 1))`
44			`return 0;`
45			`}`
46			`return 1;`
47			`}`
48
49			`/*`
50			`* Emulate instructions that cause a transfer of control.`
51			`* Returns 1 if the step was emulated, 0 if not,`
52			`* or -1 if the instruction is one that should not be stepped,`
53			`* such as an rfid, or a mtmsrd that would clear MSR_RI.`
54			`*/`
55			`int __kprobes emulate_step(struct pt_regs *regs, unsigned int instr)`
56			`{`
57			`unsigned int opcode, rs, rb, rd, spr;`
58			`unsigned long int imm;`
59
60			`opcode = instr >> 26;`
61			`switch (opcode) {`
62			`case 16: /* bc */`
63			`imm = (signed short)(instr & 0xfffc);`
64			`if ((instr & 2) == 0)`
65			`imm += regs->nip;`
66			`regs->nip += 4;`
67			`if ((regs->msr & MSR_SF) == 0)`
68			`regs->nip &= 0xffffffffUL;`
69			`if (instr & 1)`
70			`regs->link = regs->nip;`
71			`if (branch_taken(instr, regs))`
72			`regs->nip = imm;`
73			`return 1;`
74			`#ifdef CONFIG_PPC64`
75			`case 17: /* sc */`
76			`/*`
77			`* N.B. this uses knowledge about how the syscall`
78			`* entry code works. If that is changed, this will`
79			`* need to be changed also.`
80			`*/`
81			`regs->gpr[9] = regs->gpr[13];`
82			`regs->gpr[11] = regs->nip + 4;`
83			`regs->gpr[12] = regs->msr & MSR_MASK;`
84			`regs->gpr[13] = (unsigned long) get_paca();`
85			`regs->nip = (unsigned long) &system_call_common;`
86			`regs->msr = MSR_KERNEL;`
87			`return 1;`
88			`#endif`
89			`case 18: /* b */`
90			`imm = instr & 0x03fffffc;`
91			`if (imm & 0x02000000)`
92			`imm -= 0x04000000;`
93			`if ((instr & 2) == 0)`
94			`imm += regs->nip;`
95			`if (instr & 1) {`
96			`regs->link = regs->nip + 4;`
97			`if ((regs->msr & MSR_SF) == 0)`
98			`regs->link &= 0xffffffffUL;`
99			`}`
100			`if ((regs->msr & MSR_SF) == 0)`
101			`imm &= 0xffffffffUL;`
102			`regs->nip = imm;`
103			`return 1;`
104			`case 19:`
105			`switch (instr & 0x7fe) {`
106			`case 0x20: /* bclr */`
107			`case 0x420: /* bcctr */`
108			`imm = (instr & 0x400)? regs->ctr: regs->link;`
109			`regs->nip += 4;`
110			`if ((regs->msr & MSR_SF) == 0) {`
111			`regs->nip &= 0xffffffffUL;`
112			`imm &= 0xffffffffUL;`
113			`}`
114			`if (instr & 1)`
115			`regs->link = regs->nip;`
116			`if (branch_taken(instr, regs))`
117			`regs->nip = imm;`
118			`return 1;`
119			`case 0x24: /* rfid, scary */`
120			`return -1;`
121			`}`
122			`case 31:`
123			`rd = (instr >> 21) & 0x1f;`
124			`switch (instr & 0x7fe) {`
125			`case 0xa6: /* mfmsr */`
126			`regs->gpr[rd] = regs->msr & MSR_MASK;`
127			`regs->nip += 4;`
128			`if ((regs->msr & MSR_SF) == 0)`
129			`regs->nip &= 0xffffffffUL;`
130			`return 1;`
131			`case 0x124: /* mtmsr */`
132			`imm = regs->gpr[rd];`
133			`if ((imm & MSR_RI) == 0)`
134			`/* can't step mtmsr that would clear MSR_RI */`
135			`return -1;`
136			`regs->msr = imm;`
137			`regs->nip += 4;`
138			`return 1;`
139			`#ifdef CONFIG_PPC64`
140			`case 0x164: /* mtmsrd */`
141			`/* only MSR_EE and MSR_RI get changed if bit 15 set */`
142			`/* mtmsrd doesn't change MSR_HV and MSR_ME */`
143			`imm = (instr & 0x10000)? 0x8002: 0xefffffffffffefffUL;`
144			`imm = (regs->msr & MSR_MASK & ~imm)`
145			`\| (regs->gpr[rd] & imm);`
146			`if ((imm & MSR_RI) == 0)`
147			`/* can't step mtmsrd that would clear MSR_RI */`
148			`return -1;`
149			`regs->msr = imm;`
150			`regs->nip += 4;`
151			`if ((imm & MSR_SF) == 0)`
152			`regs->nip &= 0xffffffffUL;`
153			`return 1;`
154			`#endif`
155			`case 0x26: /* mfcr */`
156			`regs->gpr[rd] = regs->ccr;`
157			`regs->gpr[rd] &= 0xffffffffUL;`
158			`goto mtspr_out;`
159			`case 0x2a6: /* mfspr */`
160			`spr = (instr >> 11) & 0x3ff;`
161			`switch (spr) {`
162			`case 0x20: /* mfxer */`
163			`regs->gpr[rd] = regs->xer;`
164			`regs->gpr[rd] &= 0xffffffffUL;`
165			`goto mtspr_out;`
166			`case 0x100: /* mflr */`
167			`regs->gpr[rd] = regs->link;`
168			`goto mtspr_out;`
169			`case 0x120: /* mfctr */`
170			`regs->gpr[rd] = regs->ctr;`
171			`goto mtspr_out;`
172			`}`
173			`break;`
174			`case 0x378: /* orx */`
175			`rs = (instr >> 21) & 0x1f;`
176			`rb = (instr >> 11) & 0x1f;`
177			`if (rs == rb) { /* mr */`
178			`rd = (instr >> 16) & 0x1f;`
179			`regs->gpr[rd] = regs->gpr[rs];`
180			`goto mtspr_out;`
181			`}`
182			`break;`
183			`case 0x3a6: /* mtspr */`
184			`spr = (instr >> 11) & 0x3ff;`
185			`switch (spr) {`
186			`case 0x20: /* mtxer */`
187			`regs->xer = (regs->gpr[rd] & 0xffffffffUL);`
188			`goto mtspr_out;`
189			`case 0x100: /* mtlr */`
190			`regs->link = regs->gpr[rd];`
191			`goto mtspr_out;`
192			`case 0x120: /* mtctr */`
193			`regs->ctr = regs->gpr[rd];`
194			`mtspr_out:`
195			`regs->nip += 4;`
196			`return 1;`
197			`}`
198			`}`
199			`}`
200			`return 0;`
201			`}`