DNBArchImpl.h revision 24943d2ee8bfaa7cf5893e4709143924157a5c1e 
1//===-- DNBArchImpl.h -------------------------------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10//  Created by Greg Clayton on 6/25/07.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef __DebugNubArchMachPPC_h__
15#define __DebugNubArchMachPPC_h__
16
17#if defined (__powerpc__) || defined (__ppc__) || defined (__ppc64__)
18
19#include "DNBArch.h"
20
21class MachThread;
22
23class DNBArchMachPPC : public DNBArchProtocol
24{
25public:
26    DNBArchMachPPC(MachThread *thread) :
27        m_thread(thread),
28        m_state()
29    {
30    }
31
32    virtual ~DNBArchMachPPC()
33    {
34    }
35
36    virtual const DNBRegisterSetInfo *
37                            GetRegisterSetInfo(nub_size_t *num_reg_sets) const;
38    virtual bool            GetRegisterValue(int set, int reg, DNBRegisterValue *value) const;
39    virtual kern_return_t   GetRegisterState  (int set, bool force);
40    virtual kern_return_t   SetRegisterState  (int set);
41    virtual bool            RegisterSetStateIsValid (int set) const;
42
43    virtual uint64_t        GetPC(uint64_t failValue);    // Get program counter
44    virtual kern_return_t   SetPC(uint64_t value);
45    virtual uint64_t        GetSP(uint64_t failValue);    // Get stack pointer
46    virtual bool            ThreadWillResume();
47    virtual bool            ThreadDidStop();
48
49    static const uint8_t * const SoftwareBreakpointOpcode (nub_size_t byte_size);
50    static uint32_t         GetCPUType();
51
52protected:
53
54
55    kern_return_t    EnableHardwareSingleStep (bool enable);
56
57    typedef enum RegisterSetTag
58    {
59        e_regSetALL = REGISTER_SET_ALL,
60        e_regSetGPR,
61        e_regSetFPR,
62        e_regSetEXC,
63        e_regSetVEC,
64        kNumRegisterSets
65    } RegisterSet;
66
67    typedef enum RegisterSetWordSizeTag
68    {
69        e_regSetWordSizeGPR = PPC_THREAD_STATE_COUNT,
70        e_regSetWordSizeFPR = PPC_FLOAT_STATE_COUNT,
71        e_regSetWordSizeEXC = PPC_EXCEPTION_STATE_COUNT,
72        e_regSetWordSizeVEC = PPC_VECTOR_STATE_COUNT
73    } RegisterSetWordSize;
74
75    enum
76    {
77        Read = 0,
78        Write = 1,
79        kNumErrors = 2
80    };
81
82    struct State
83    {
84        ppc_thread_state_t        gpr;
85        ppc_float_state_t        fpr;
86        ppc_exception_state_t    exc;
87        ppc_vector_state_t        vec;
88        kern_return_t            gpr_errs[2];    // Read/Write errors
89        kern_return_t            fpr_errs[2];    // Read/Write errors
90        kern_return_t            exc_errs[2];    // Read/Write errors
91        kern_return_t            vec_errs[2];    // Read/Write errors
92
93        State()
94        {
95            uint32_t i;
96            for (i=0; i<kNumErrors; i++)
97            {
98                gpr_errs[i] = -1;
99                fpr_errs[i] = -1;
100                exc_errs[i] = -1;
101                vec_errs[i] = -1;
102            }
103        }
104        void InvalidateAllRegisterStates()
105        {
106            SetError (e_regSetALL, Read, -1);
107        }
108        kern_return_t GetError (int set, uint32_t err_idx) const
109        {
110            if (err_idx < kNumErrors)
111            {
112                switch (set)
113                {
114                // When getting all errors, just OR all values together to see if
115                // we got any kind of error.
116                case e_regSetALL:    return gpr_errs[err_idx] | fpr_errs[err_idx] | exc_errs[err_idx] | vec_errs[err_idx];
117                case e_regSetGPR:    return gpr_errs[err_idx];
118                case e_regSetFPR:    return fpr_errs[err_idx];
119                case e_regSetEXC:    return exc_errs[err_idx];
120                case e_regSetVEC:    return vec_errs[err_idx];
121                default: break;
122                }
123            }
124            return -1;
125        }
126        bool SetError (int set, uint32_t err_idx, kern_return_t err)
127        {
128            if (err_idx < kNumErrors)
129            {
130                switch (set)
131                {
132                case e_regSetALL:
133                    gpr_errs[err_idx] = fpr_errs[err_idx] = exc_errs[err_idx] = vec_errs[err_idx] = err;
134                    return true;
135
136                case e_regSetGPR:
137                    gpr_errs[err_idx] = err;
138                    return true;
139
140                case e_regSetFPR:
141                    fpr_errs[err_idx] = err;
142                    return true;
143
144                case e_regSetEXC:
145                    exc_errs[err_idx] = err;
146                    return true;
147
148                case e_regSetVEC:
149                    vec_errs[err_idx] = err;
150                    return true;
151
152                default: break;
153                }
154            }
155            return false;
156        }
157        bool RegsAreValid (int set) const
158        {
159            return GetError(set, Read) == KERN_SUCCESS;
160        }
161    };
162
163    kern_return_t GetGPRState (bool force);
164    kern_return_t GetFPRState (bool force);
165    kern_return_t GetEXCState (bool force);
166    kern_return_t GetVECState (bool force);
167
168    kern_return_t SetGPRState ();
169    kern_return_t SetFPRState ();
170    kern_return_t SetEXCState ();
171    kern_return_t SetVECState ();
172
173protected:
174    MachThread *    m_thread;
175    State            m_state;
176};
177
178typedef DNBArchMachPPC    DNBArch;
179#endif    // #if defined (__powerpc__) || defined (__ppc__) || defined (__ppc64__)
180#endif    // #ifndef __DebugNubArchMachPPC_h__
181