*** empty log message ***
[dyninst.git] / dyninstAPI / src / BPatch_type.C
1 /*
2  * Copyright (c) 1996 Barton P. Miller
3  * 
4  * We provide the Paradyn Parallel Performance Tools (below
5  * described as Paradyn") on an AS IS basis, and do not warrant its
6  * validity or performance.  We reserve the right to update, modify,
7  * or discontinue this software at any time.  We shall have no
8  * obligation to supply such updates or modifications or any other
9  * form of support to you.
10  * 
11  * This license is for research uses.  For such uses, there is no
12  * charge. We define "research use" to mean you may freely use it
13  * inside your organization for whatever purposes you see fit. But you
14  * may not re-distribute Paradyn or parts of Paradyn, in any form
15  * source or binary (including derivatives), electronic or otherwise,
16  * to any other organization or entity without our permission.
17  * 
18  * (for other uses, please contact us at paradyn@cs.wisc.edu)
19  * 
20  * All warranties, including without limitation, any warranty of
21  * merchantability or fitness for a particular purpose, are hereby
22  * excluded.
23  * 
24  * By your use of Paradyn, you understand and agree that we (or any
25  * other person or entity with proprietary rights in Paradyn) are
26  * under no obligation to provide either maintenance services,
27  * update services, notices of latent defects, or correction of
28  * defects for Paradyn.
29  * 
30  * Even if advised of the possibility of such damages, under no
31  * circumstances shall we (or any other person or entity with
32  * proprietary rights in the software licensed hereunder) be liable
33  * to you or any third party for direct, indirect, or consequential
34  * damages of any character regardless of type of action, including,
35  * without limitation, loss of profits, loss of use, loss of good
36  * will, or computer failure or malfunction.  You agree to indemnify
37  * us (and any other person or entity with proprietary rights in the
38  * software licensed hereunder) for any and all liability it may
39  * incur to third parties resulting from your use of Paradyn.
40  */
41
42 #include <stdio.h>
43
44 #include "util.h"
45 #include "BPatch_Vector.h"
46 #include "BPatch_type.h"
47
48 /*
49  * BPatch_type::BPatch_type
50  *
51  * EMPTY Constructor for BPatch_type.  
52  * 
53  */
54 BPatch_type::BPatch_type(){
55   name = NULL;
56   ID = 0;
57   size = 0;
58   low = NULL;
59   hi = NULL;
60   ptr = NULL;
61 }
62 /*
63  * BPatch_type::BPatch_type
64  *
65  * Constructor for BPatch_type.  Creates a type object representing a type
66  * with the features given in the parameters.
67  */
68 BPatch_type::BPatch_type(const char *_name, bool _nullType) :
69     nullType(_nullType)
70 {
71     /* XXX More later. */
72   if( _name)
73     name = strdup(_name);
74   else
75     name = NULL;
76
77 }
78 /*
79  * BPatch_type::BPatch_type
80  *
81  * Constructor for BPatch_type ENUM.  Creates a type object representing a type
82  * with the features given in the parameters.
83  */
84 BPatch_type::BPatch_type(const char *_name, int _ID, BPatch_dataClass _type)
85 {
86   ID = _ID;
87   type_ = _type;
88   // This is just for now XXX 
89   size = sizeof(int);
90   low = NULL;
91   hi= NULL;
92   ptr = NULL;
93   if( _name)
94     name = strdup(_name);
95   else
96     name = NULL;
97 }
98
99 /*
100  * BPatch_type::BPatch_type
101  *
102  * Constructor for BPatch_type Structs, Unions, range(size),
103  * and reference(void) and built-in type. These are the negative type
104  * numbers defined in the gdb doc.  The type ID neg. type num.
105  * Creates a type object representing a type
106  * with the features given in the parameters.
107  * A collection of the built-in types is created in for the image and
108  * is gloabally accessible to all modules. This way it is only created once..
109  */
110 BPatch_type::BPatch_type(const char *_name, int _ID, BPatch_dataClass _type,
111                          int _size)
112 {
113
114   ID = _ID;
115   type_ = _type;
116
117   if( _name)
118     name = strdup(_name);
119   else
120     name = NULL;
121   
122   if( _type == BPatch_scalar) {
123     // Check that void type == void type
124     if( _ID == _size ){
125       size = 0;
126       low = NULL;
127       hi = NULL;
128       type_ = _type;
129       ptr = NULL;
130       //typeCol = NULL;
131     }
132   }
133   else{
134     size = _size;
135     low = NULL;
136     hi = NULL;
137     type_ = _type;
138     ptr = NULL;
139     //typeCol = NULL;
140   }
141 }
142 /*
143  * BPatch_type::BPatch_type
144  *
145  * Constructor for BPatch_type Pointers (and Internal).
146  * Creates a type object representing a type
147  * with the features given in the parameters.
148  */
149 BPatch_type::BPatch_type(const char *_name, int _ID, BPatch_dataClass _type,
150                          BPatch_type * _ptr)
151 {
152     
153   ID = _ID;
154   if(_type == BPatch_scalar){  // could be a typedef for something
155     if( _name)
156       name = strdup(_name);
157     else
158       name = NULL;
159     if(_ptr ){
160       if(_ptr->ptr) // point to whatever it points to
161         ptr = _ptr->ptr;
162       else  // or just point to the oldType
163         ptr = _ptr;
164       type_ = _ptr->type_;
165       size = _ptr->size;
166       fieldList = _ptr->fieldList;
167     }
168     else{
169       ptr = _ptr;
170       size = sizeof(int);
171       type_ = _type;
172     }
173         
174     low = NULL;
175     hi = NULL;
176   }
177   else{
178     type_=_type;
179     ptr = _ptr;
180     if( _name)
181       name = strdup(_name);
182     else
183       name = NULL;
184
185     size = sizeof(int);
186     low = NULL;
187     hi = NULL;
188   }
189 }
190
191 /*
192  * BPatch_type::BPatch_type
193  *
194  * Constructor for BPatch_type Range with lower and upper bound.
195  * Creates a type object representing a type
196  * with the features given in the parameters.
197  */
198 BPatch_type::BPatch_type(const char *_name, int _ID, BPatch_dataClass _type,
199                          const char * _low, const char * _hi)
200 {
201   ID = _ID;
202   type_ = _type;
203
204   if( _name)
205     name = strdup(_name);
206   else
207     name = NULL;
208   
209   name = strdup(_name);
210   low = strdup(_low);
211   hi = strdup(_hi);
212   /* need to change for smaller types, maybe case statement
213      needs to be arch. independent and there may be a lot of cases*/
214   size = sizeof(int);
215   ptr = NULL;
216 }
217
218 /*
219  * BPatch_type::BPatch_type
220  *
221  * Constructor for BPatch_type Array.
222  * Creates a type object representing a type
223  * with the features given in the parameters.
224  */
225 BPatch_type::BPatch_type(const char *_name, int _ID, BPatch_dataClass _type,
226                          BPatch_type * _ptr, int _low, int _hi)
227 {
228   
229   char temp[255];
230
231   ID = _ID;
232   type_ = _type;
233   ptr = _ptr;
234
235   if( _name)
236     name = strdup(_name);
237   else
238     name = NULL;
239
240
241   sprintf(temp, "%d", _low);
242   low = strdup(temp);
243
244   sprintf(temp, "%d", _hi);
245   hi = strdup(temp);
246
247   /* size = sizeof(artype)*(_hi+1)
248      need to find out how big that size is first */
249   size = ((ptr->getSize())*(_hi+1));
250 }
251 /*
252  * BPatch_type::BPatch_type
253  *
254  * Constructor for BPatch_type typedef--pre-existing type.
255  * Creates a type object representing a type
256  * with the features given in the parameters.
257  */
258 BPatch_type::BPatch_type(const char * _name, int _ID, BPatch_type *  _ptr)
259 {
260   if(_ptr){
261     ID = _ID;
262     size = _ptr->size;
263
264     if( _name)
265       name = strdup(_name);
266     else
267       name = NULL;
268
269     if(_ptr->low)
270       low = strdup(_ptr->low);
271     else
272       low = NULL;
273     if(_ptr->hi)
274       hi = strdup(_ptr->hi);
275     else
276       hi = NULL;
277     type_ = _ptr->type_;
278     if(_ptr->ptr)
279       ptr = _ptr->ptr;
280     else
281       ptr = _ptr;
282   }
283   else{
284     ID = _ID;
285     size = 0;
286     if( _name)
287       name = strdup(_name);
288     else
289       name = NULL;
290     hi = NULL;
291     low = NULL;
292     type_ = BPatch_scalar;
293     ptr = _ptr;
294   }
295 }
296
297 /*
298  * BPatch_type::BPatch_type
299  *
300  * Constructor for BPatch_type Type Attributes.  These are types defined
301  * by the built-in types and use the '@' as the type identifier.
302  * Creates a type object representing a type
303  * with the features given in the parameters.
304  */
305 BPatch_type::BPatch_type(const char * _name, int _ID, BPatch_dataClass _type,
306                          int _size, BPatch_type * _ptr)
307 {
308   int b_size;
309
310   b_size = _ptr->getSize();
311   
312   ID = _ID;
313
314   if( b_size != _size)
315     printf(" Built-in Type size and stab record size are different, Overriding built-in type size!!\n");
316   
317   size = _size;
318
319   if( _name)
320     name = strdup(_name);
321   else
322     name = NULL;
323
324   low = NULL;
325   hi = NULL;
326   type_ = _type;
327   ptr = _ptr;
328 }
329
330 /*
331  * BPatch_type::isCompatible
332  *
333  * Returns true of the type is compatible with the other specified type, false
334  * if it is not.
335  *
336  * oType        The other type to check for compatibility.
337  */
338 bool BPatch_type::isCompatible(const BPatch_type &otype)
339 {
340     if (nullType || otype.nullType)
341         return true;
342
343     // XXX Just compare names for now, we'll have to fix this later.
344     if (name == otype.name) return true;
345     else return false;
346 }
347
348 /*
349  * void BPatch_type::addField
350  * Creates field object and adds it to the list of fields for this
351  * BPatch_type object.
352  *     ENUMS
353  */
354 void BPatch_type::addField(const char * _fieldname, BPatch_dataClass _typeDes,
355                            int value)
356 {
357   BPatch_field * newField;
358
359   newField = new BPatch_field(_fieldname, _typeDes, value);
360
361   // Add field to list of enum fields
362   fieldList.push_back(newField);
363 }
364
365 /*
366  * void BPatch_type::addField
367  * Creates field object and adds it to the list of fields for this
368  * BPatch_type object.
369  *     ENUMS C++ - have visibility
370  */
371 void BPatch_type::addField(const char * _fieldname, BPatch_dataClass _typeDes,
372                            int value, BPatch_visibility _vis)
373 {
374   BPatch_field * newField;
375
376   newField = new BPatch_field(_fieldname, _typeDes, value, _vis);
377
378   // Add field to list of enum fields
379   fieldList.push_back(newField);
380 }
381
382 /*
383  * void BPatch_type::addField
384  * Creates field object and adds it to the list of fields for this
385  * BPatch_type object.
386  *     STRUCTS OR UNIONS
387  */
388 void BPatch_type::addField(const char * _fieldname, BPatch_dataClass _typeDes,
389                            BPatch_type *_type, int _offset, int _size)
390 {
391   BPatch_field * newField;
392
393   // Create Field for struct or union
394   newField = new BPatch_field(_fieldname, _typeDes, _type, _offset, _size);
395
396   // Add field to list of struct/union fields
397   fieldList.push_back(newField);
398
399 }
400
401 /*
402  * void BPatch_type::addField
403  * Creates field object and adds it to the list of fields for this
404  * BPatch_type object.
405  *     STRUCTS OR UNIONS C++ have visibility
406  */
407 void BPatch_type::addField(const char * _fieldname, BPatch_dataClass _typeDes,
408                            BPatch_type *_type, int _offset, int _size,
409                            BPatch_visibility _vis)
410 {
411   BPatch_field * newField;
412
413   // Create Field for struct or union
414   newField = new BPatch_field(_fieldname, _typeDes, _type, _offset, _size,
415                               _vis);
416
417   // Add field to list of struct/union fields
418   fieldList.push_back(newField);
419
420 }
421
422 /*
423  * BPatch_field::BPatch_field
424  *
425  * Constructor for BPatch_field.  Creates a field object for 
426  * an enumerated type.
427  * type = offset = size = 0;
428  */
429 BPatch_field::BPatch_field(const char * fName, BPatch_dataClass _typeDes,
430                            int evalue)
431 {
432   typeDes = _typeDes;
433   value = evalue;
434   fieldname = strdup(fName);
435
436   type = NULL;
437   offset = size = 0;
438   vis = BPatch_visUnknown;
439   // printf("adding field %s\n", fName);
440
441 }
442
443 /*
444  * BPatch_field::BPatch_field
445  *
446  * Constructor for BPatch_field.  Creates a field object for 
447  * an enumerated type with a C++ visibility value
448  * type = offset = size = 0;
449  */
450 BPatch_field::BPatch_field(const char * fName, BPatch_dataClass _typeDes,
451                            int evalue, BPatch_visibility _vis)
452 {
453   typeDes = _typeDes;
454   value = evalue;
455   fieldname = strdup(fName);
456
457   type = NULL;
458   offset = size = 0;
459   vis = _vis;
460   // printf("adding field %s\n", fName);
461
462 }
463
464 /*
465  * BPatch_field::BPatch_field
466  *
467  * Constructor for BPatch_field.  Creates a field object for 
468  * an struct and union types.
469  * value= 0;
470  */
471 BPatch_field::BPatch_field(const char * fName, BPatch_dataClass _typeDes,
472                            BPatch_type *suType, int suOffset, int suSize)
473 {
474   
475   typeDes = _typeDes;
476   type = suType;
477   offset = suOffset;
478   fieldname = strdup(fName);
479   size = suSize;
480   
481   value = 0;
482   vis = BPatch_visUnknown;
483 }
484
485 /*
486  * BPatch_field::BPatch_field
487  *
488  * Constructor for BPatch_field.  Creates a field object for 
489  * a struct and union types for C++ fields that have visibility.
490  * value= 0;
491  */
492 BPatch_field::BPatch_field(const char * fName, BPatch_dataClass _typeDes,
493                            BPatch_type *suType, int suOffset, int suSize,
494                            BPatch_visibility _vis)
495 {
496   
497   typeDes = _typeDes;
498   type = suType;
499   offset = suOffset;
500   fieldname = strdup(fName);
501   size = suSize;
502   
503   value = 0;
504   vis = _vis;
505 }
506
507
508 /**************************************************************************
509  * BPatch_localVar
510  *************************************************************************/
511 /*
512  * BPatch_localVar Constructor
513  *
514  */
515 BPatch_localVar::BPatch_localVar(char * _name,  BPatch_type * _type,
516                                  int _lineNum,int _frameOffset)
517 {
518   if( _name)
519     name = strdup(_name);
520   else
521     name = NULL;
522   type = _type;
523   lineNum = _lineNum;
524   frameOffset = _frameOffset;
525
526 }
527
528
529 /*
530  * BPatch_localVar destructor
531  *
532  */
533 BPatch_localVar::~BPatch_localVar()
534 {
535
536   //More to do later
537
538 }