changes made for CFG for alpha architecture and
[dyninst.git] / dyninstAPI / src / AddressHandle.h
1 #ifndef _AddressHandle_h_
2 #define _AddressHandle_h_
3
4 #if defined(sparc_sun_solaris2_4) ||\
5     defined(mips_sgi_irix6_4) ||\
6     defined(rs6000_ibm_aix4_1) ||\
7     defined(alpha_dec_osf4_0)
8
9 #include "BPatch_Set.h"
10
11 class AddressHandle;
12
13 /** helper function to identify the properties of the
14   * instruction such as the type and the offset.
15   */
16 bool isAReturnInstruction(const instruction);
17 bool isACondBranchInstruction(const instruction);
18 bool isAJumpInstruction(const instruction);
19 bool isACallInstruction(const instruction);
20 Address getBranchTargetAddress(const instruction,Address pos);
21
22 #if defined(rs6000_ibm_aix4_1)
23 bool isAIndirectJumpInstruction(const instruction,AddressHandle);
24 #else 
25 bool isAIndirectJumpInstruction(const instruction);
26 #endif
27
28 /** class for manipulating the address space in an image for a given
29   * range. Such as the valid addresses and the instructions in the addresses
30   * and iteration on the address apce range for instructions
31   */
32 class AddressHandle {
33 protected:
34
35         /** process of the function and image */
36         process* addressProc;
37
38         /** member which hold the image of that will be used to retrive
39           * instruction values, where the address space resides.
40           */
41         image* addressImage;
42
43         /** the starting point of the address spce */
44         Address baseAddress;
45
46         /** the range/length of the address space in bytes */
47         unsigned range;
48
49         /** current address of the address spce which will be used 
50           * to iterate through the address space
51           */
52         Address currentAddress;
53 public:
54         /** constructor
55           * @param process_ptr process wher address spce resides
56           * @param base_addr start address of the addresss space
57           * @param range range of the address space in bytes
58           */ 
59         AddressHandle (process*,Address,unsigned);
60
61         /** constructor
62           * @param current current address of the iteration
63           * @param process_ptr process wher address spce resides
64           * @param base_addr start address of the addresss space
65           * @param range range of the address space in bytes
66           */ 
67         AddressHandle (Address,process*,Address,unsigned);
68
69         /** copy constructor
70           * @param ah address handler that will be copied 
71           */
72         AddressHandle (const AddressHandle&);
73
74         /** returns the image associated with the AddressHandle
75          */
76         image *getImage() { return addressImage; };
77
78         /** return true iff the address is in the space represented by
79          * the AddressHandle
80          */
81         bool containsAddress(Address addr)
82                 { return addr >= baseAddress && addr < baseAddress + range; };
83
84         /** method that returns true if the delay instruction is supported */
85         static bool delayInstructionSupported ();
86
87         /** method that returns the targets of a multi-branch instruction
88           * it assumes the currentAddress of the handle instance points to the
89           * multi branch instruction
90           */
91         void getMultipleJumpTargets(BPatch_Set<Address>& result);
92
93         /** method that returns true if ther is more instruction to iterate */
94         bool hasMore();
95
96         /** method that returns true if there are instruction previous to the
97          * current one */
98         bool hasPrev();
99
100         /** prev address of the content of the address handle */
101         Address prevAddress();
102
103         /** prev address of the argument 
104           * @param addr address whose prev is looked for
105           */
106         Address prevAddressOf(Address);
107
108         /** next address of the content of the address handle */
109         Address nextAddress();
110
111         /** next address of the  argument 
112           * @param addr address whose next is looked for
113           */
114         Address nextAddressOf(Address);
115
116         /** set the content of the handle to the argument 
117           * @param addr the value that handle will be set to
118           */
119         void setCurrentAddress(Address);
120
121         /** returns the instruction count in the address space */
122         unsigned getInstructionCount();
123
124         /** returns the instruction in the address of handle */
125         instruction getInstruction();
126
127         /** returns the instruction in the next address of handle */
128         instruction getNextInstruction();
129
130         /** returns the instruction in the prev address of handle */
131         instruction getPrevInstruction();
132
133         /** returns the content of the address  handle */
134         Address operator* ();
135
136         /** prefix increment operation */
137         Address operator++ ();
138
139         /** prefix decrement operation */
140         Address operator-- ();
141
142         /** postfix increment operation */
143         Address operator++ (int);
144
145         /** postfix decrement operation */
146         Address operator-- (int);
147 };
148
149 #endif
150 #endif /* _AddressHandle_h_ */