SymEval for POWER: WIP
[dyninst.git] / symEval / rose / SgAsmExpression.h
1 #if !defined(SG_ASM_EXPR_H)
2 #define SG_ASM_EXPR_H
3
4 #include "external/rose/rose-compat.h"
5 #include "SgNode.h"
6 #include "SgAsmType.h"
7 #include "powerpcInstructionEnum.h"
8
9 class SgAsmExpression : public SgNode {
10  public:
11     virtual SgAsmType* get_type();
12
13     /*! \brief returns a string representing the class name */
14     virtual std::string class_name() const;
15     
16     /*! \brief returns new style SageIII enum values */
17     virtual VariantT variantT() const; // MS: new variant used in tree traversal
18     
19     /*! \brief static variant value */
20     static const VariantT static_variant = V_SgAsmExpression;
21     
22     /* the generated cast function */
23     /*! \brief Casts pointer from base class to derived class */
24     friend       SgAsmExpression* isSgAsmExpression(       SgNode * s );
25     /*! \brief Casts pointer from base class to derived class (for const pointers) */
26     friend const SgAsmExpression* isSgAsmExpression( const SgNode * s );
27     
28     
29     std::string get_replacement() const;
30     void set_replacement(std::string replacement);
31     
32     std::string get_comment() const;
33     void set_comment(std::string comment);
34
35     virtual ~SgAsmExpression();
36     
37     SgAsmExpression(); 
38     
39  protected:
40     std::string p_replacement;
41     
42     std::string p_comment;
43 };
44
45 // Class Definition for SgAsmValueExpression
46 class SgAsmValueExpression : public SgAsmExpression {
47  public:
48     virtual SgAsmType* get_type();
49
50     virtual std::string class_name() const;
51     
52     /*! \brief returns new style SageIII enum values */
53     virtual VariantT variantT() const; // MS: new variant used in tree traversal
54     
55     /*! \brief static variant value */
56     static const VariantT static_variant = V_SgAsmValueExpression;
57     
58     /* the generated cast function */
59     /*! \brief Casts pointer from base class to derived class */
60     friend       SgAsmValueExpression* isSgAsmValueExpression(       SgNode * s );
61     /*! \brief Casts pointer from base class to derived class (for const pointers) */
62     friend const SgAsmValueExpression* isSgAsmValueExpression( const SgNode * s );
63     
64  public: 
65     SgAsmValueExpression* get_unfolded_expression_tree() const;
66     void set_unfolded_expression_tree(SgAsmValueExpression* unfolded_expression_tree);
67     
68  public: 
69     unsigned short get_bit_offset() const;
70     void set_bit_offset(unsigned short bit_offset);
71     
72  public: 
73     unsigned short get_bit_size() const;
74     void set_bit_size(unsigned short bit_size);
75     
76     
77  public: 
78     virtual ~SgAsmValueExpression();
79     
80     
81  public: 
82     SgAsmValueExpression(); 
83     
84  protected:
85     // Start of memberFunctionString
86     SgAsmValueExpression* p_unfolded_expression_tree;
87     
88     // End of memberFunctionString
89     // Start of memberFunctionString
90     unsigned short p_bit_offset;
91     
92     // End of memberFunctionString
93     // Start of memberFunctionString
94     unsigned short p_bit_size;  
95
96     
97     // End of memberFunctionString
98 };
99
100 class SgAsmByteValueExpression : public SgAsmValueExpression {
101  public:
102         virtual SgAsmType* get_type();
103     /*! \brief returns a string representing the class name */
104     virtual std::string class_name() const;
105     
106     /*! \brief returns new style SageIII enum values */
107     virtual VariantT variantT() const; // MS: new variant used in tree traversal
108     
109     /*! \brief static variant value */
110     static const VariantT static_variant = V_SgAsmByteValueExpression;
111     
112     /* the generated cast function */
113     /*! \brief Casts pointer from base class to derived class */
114     friend       SgAsmByteValueExpression* isSgAsmByteValueExpression(       SgNode * s );
115     /*! \brief Casts pointer from base class to derived class (for const pointers) */
116     friend const SgAsmByteValueExpression* isSgAsmByteValueExpression( const SgNode * s );
117     
118  public: 
119     uint8_t get_value() const;
120     void set_value(uint8_t value);
121     
122     
123  public: 
124     virtual ~SgAsmByteValueExpression();
125     
126     
127  public: 
128     SgAsmByteValueExpression(uint8_t value = 0x0); 
129     
130  protected:
131     // Start of memberFunctionString
132     uint8_t p_value;
133 };
134
135 class SgAsmWordValueExpression : public SgAsmValueExpression {
136  public:
137         virtual SgAsmType* get_type();
138    /*! \brief returns a string representing the class name */
139     virtual std::string class_name() const;
140     
141     /*! \brief returns new style SageIII enum values */
142     virtual VariantT variantT() const; // MS: new variant used in tree traversal
143     
144     /*! \brief static variant value */
145     static const VariantT static_variant = V_SgAsmWordValueExpression;
146     
147     /* the generated cast function */
148     /*! \brief Casts pointer from base class to derived class */
149     friend       SgAsmWordValueExpression* isSgAsmWordValueExpression(       SgNode * s );
150     /*! \brief Casts pointer from base class to derived class (for const pointers) */
151     friend const SgAsmWordValueExpression* isSgAsmWordValueExpression( const SgNode * s );
152     
153  public: 
154     uint16_t get_value() const;
155     void set_value(uint16_t value);
156     
157     
158  public: 
159     virtual ~SgAsmWordValueExpression();
160     
161     
162  public: 
163     SgAsmWordValueExpression(uint16_t value = 0x0); 
164     
165  protected:
166     // Start of memberFunctionString
167     uint16_t p_value;
168 };
169
170 // Class Definition for SgAsmDoubleWordValueExpression
171 class SgAsmDoubleWordValueExpression : public SgAsmValueExpression {
172  public:
173         virtual SgAsmType* get_type();
174    /*! \brief returns a string representing the class name */
175     virtual std::string class_name() const;
176     
177     /*! \brief returns new style SageIII enum values */
178     virtual VariantT variantT() const; // MS: new variant used in tree traversal
179     
180     /*! \brief static variant value */
181     static const VariantT static_variant = V_SgAsmDoubleWordValueExpression;
182     
183     /* the generated cast function */
184     /*! \brief Casts pointer from base class to derived class */
185     friend       SgAsmDoubleWordValueExpression* isSgAsmDoubleWordValueExpression(       SgNode * s );
186     /*! \brief Casts pointer from base class to derived class (for const pointers) */
187     friend const SgAsmDoubleWordValueExpression* isSgAsmDoubleWordValueExpression( const SgNode * s );
188     
189  public: 
190     uint32_t get_value() const;
191     void set_value(uint32_t value);
192     
193     
194  public: 
195     virtual ~SgAsmDoubleWordValueExpression();
196     
197     
198  public: 
199     SgAsmDoubleWordValueExpression(uint32_t value = 0x0); 
200     
201  protected:
202     // Start of memberFunctionString
203     uint32_t p_value;
204     
205 };
206
207 class SgAsmQuadWordValueExpression : public SgAsmValueExpression {
208  public:
209         virtual SgAsmType* get_type();
210    
211     /*! \brief returns a string representing the class name */
212     virtual std::string class_name() const;
213     
214     /*! \brief returns new style SageIII enum values */
215     virtual VariantT variantT() const; // MS: new variant used in tree traversal
216     
217     /*! \brief static variant value */
218     static const VariantT static_variant = V_SgAsmQuadWordValueExpression;
219     
220     /* the generated cast function */
221     /*! \brief Casts pointer from base class to derived class */
222     friend       SgAsmQuadWordValueExpression* isSgAsmQuadWordValueExpression(       SgNode * s );
223     /*! \brief Casts pointer from base class to derived class (for const pointers) */
224     friend const SgAsmQuadWordValueExpression* isSgAsmQuadWordValueExpression( const SgNode * s );
225     
226     
227     // End of memberFunctionString
228     
229  public: 
230     uint64_t get_value() const;
231     void set_value(uint64_t value);
232     
233     
234  public: 
235     virtual ~SgAsmQuadWordValueExpression();
236     
237     
238  public: 
239     SgAsmQuadWordValueExpression(uint64_t value = 0x0); 
240     
241  protected:
242     // Start of memberFunctionString
243     uint64_t p_value;
244     
245     // End of memberFunctionString
246 };
247
248 class SgAsmSingleFloatValueExpression : public SgAsmValueExpression {
249  public:
250         virtual SgAsmType* get_type();
251
252     // virtual SgNode* copy ( const SgCopyHelp & help) const;
253
254     /*! \brief returns a string representing the class name */
255     virtual std::string class_name() const;
256
257     /*! \brief returns new style SageIII enum values */
258     virtual VariantT variantT() const; // MS: new variant used in tree traversal
259
260     /*! \brief static variant value */
261     static const VariantT static_variant = V_SgAsmSingleFloatValueExpression;
262
263     /* the generated cast function */
264     /*! \brief Casts pointer from base class to derived class */
265     friend       SgAsmSingleFloatValueExpression* isSgAsmSingleFloatValueExpression(       SgNode * s );
266     /*! \brief Casts pointer from base class to derived class (for const pointers) */
267     friend const SgAsmSingleFloatValueExpression* isSgAsmSingleFloatValueExpression( const SgNode * s );
268
269  public: 
270     float get_value() const;
271     void set_value(float value);
272
273
274  public: 
275     virtual ~SgAsmSingleFloatValueExpression();
276
277
278  public: 
279     SgAsmSingleFloatValueExpression(float value = 0.0F); 
280
281  protected:
282     // Start of memberFunctionString
283     float p_value;
284 };
285
286
287 class SgAsmDoubleFloatValueExpression : public SgAsmValueExpression
288 {
289  public:
290         virtual SgAsmType* get_type();
291
292     /*! \brief returns a string representing the class name */
293     virtual std::string class_name() const;
294
295     /*! \brief returns new style SageIII enum values */
296     virtual VariantT variantT() const; // MS: new variant used in tree traversal
297
298     /*! \brief static variant value */
299     static const VariantT static_variant = V_SgAsmDoubleFloatValueExpression;
300
301     /* the generated cast function */
302     /*! \brief Casts pointer from base class to derived class */
303     friend       SgAsmDoubleFloatValueExpression* isSgAsmDoubleFloatValueExpression(       SgNode * s );
304     /*! \brief Casts pointer from base class to derived class (for const pointers) */
305     friend const SgAsmDoubleFloatValueExpression* isSgAsmDoubleFloatValueExpression( const SgNode * s );
306  public: 
307     double get_value() const;
308     void set_value(double value);
309
310
311  public: 
312     virtual ~SgAsmDoubleFloatValueExpression();
313
314
315  public: 
316     SgAsmDoubleFloatValueExpression(double value = 0.0); 
317
318  protected:
319     // Start of memberFunctionString
320     double p_value;
321 };
322
323 class SgAsmType;
324
325 class SgAsmVectorValueExpression : public SgAsmValueExpression
326 {
327  public:
328         virtual SgAsmType* get_type();
329
330     /*! \brief returns a string representing the class name */
331     virtual std::string class_name() const;
332
333     /*! \brief returns new style SageIII enum values */
334     virtual VariantT variantT() const; // MS: new variant used in tree traversal
335
336     /*! \brief static variant value */
337     static const VariantT static_variant = V_SgAsmVectorValueExpression;
338
339     /* the generated cast function */
340     /*! \brief Casts pointer from base class to derived class */
341     friend       SgAsmVectorValueExpression* isSgAsmVectorValueExpression(       SgNode * s );
342     /*! \brief Casts pointer from base class to derived class (for const pointers) */
343     friend const SgAsmVectorValueExpression* isSgAsmVectorValueExpression( const SgNode * s );
344
345  public: 
346     unsigned int get_size() const;
347     void set_size(unsigned int size);
348
349  public: 
350     SgAsmType* get_type() const;
351     void set_type(SgAsmType* type);
352
353
354  public: 
355     virtual ~SgAsmVectorValueExpression();
356
357
358  public: 
359     SgAsmVectorValueExpression(); 
360
361  protected:
362     // Start of memberFunctionString
363     unsigned int p_size;
364           
365     // End of memberFunctionString
366     // Start of memberFunctionString
367     SgAsmType* p_type;
368           
369     // End of memberFunctionString
370 };
371
372 class SgAsmBinaryExpression : public SgAsmExpression
373 {
374  public:
375
376         virtual SgAsmType* get_type();
377
378     /*! \brief returns a string representing the class name */
379     virtual std::string class_name() const;
380
381     /*! \brief returns new style SageIII enum values */
382     virtual VariantT variantT() const; // MS: new variant used in tree traversal
383
384     /*! \brief static variant value */
385     static const VariantT static_variant = V_SgAsmBinaryExpression;
386
387     /* the generated cast function */
388     /*! \brief Casts pointer from base class to derived class */
389     friend       SgAsmBinaryExpression* isSgAsmBinaryExpression(       SgNode * s );
390     /*! \brief Casts pointer from base class to derived class (for const pointers) */
391     friend const SgAsmBinaryExpression* isSgAsmBinaryExpression( const SgNode * s );
392
393  public: 
394     SgAsmExpression* get_lhs() const;
395     void set_lhs(SgAsmExpression* lhs);
396
397  public: 
398     SgAsmExpression* get_rhs() const;
399     void set_rhs(SgAsmExpression* rhs);
400
401
402  public: 
403     virtual ~SgAsmBinaryExpression();
404
405
406  public: 
407     SgAsmBinaryExpression(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
408
409  protected:
410     // Start of memberFunctionString
411     SgAsmExpression* p_lhs;
412           
413     // End of memberFunctionString
414     // Start of memberFunctionString
415     SgAsmExpression* p_rhs;
416           
417     // End of memberFunctionString
418
419
420 };
421
422 class SgAsmBinaryAdd : public SgAsmBinaryExpression
423 {
424  public:
425
426
427     virtual SgAsmType* get_type();
428
429     /*! \brief returns a string representing the class name */
430     virtual std::string class_name() const;
431
432     /*! \brief returns new style SageIII enum values */
433     virtual VariantT variantT() const; // MS: new variant used in tree traversal
434
435     /*! \brief static variant value */
436     static const VariantT static_variant = V_SgAsmBinaryAdd;
437
438     /* the generated cast function */
439     /*! \brief Casts pointer from base class to derived class */
440     friend       SgAsmBinaryAdd* isSgAsmBinaryAdd(       SgNode * s );
441     /*! \brief Casts pointer from base class to derived class (for const pointers) */
442     friend const SgAsmBinaryAdd* isSgAsmBinaryAdd( const SgNode * s );
443
444  public: 
445     virtual ~SgAsmBinaryAdd();
446
447
448  public: 
449     SgAsmBinaryAdd(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
450
451  protected:
452 };
453
454 class SgAsmBinarySubtract : public SgAsmBinaryExpression
455 {
456  public:
457     virtual SgAsmType* get_type();
458
459     /*! \brief returns a string representing the class name */
460     virtual std::string class_name() const;
461
462     /*! \brief returns new style SageIII enum values */
463     virtual VariantT variantT() const; // MS: new variant used in tree traversal
464
465     /*! \brief static variant value */
466     static const VariantT static_variant = V_SgAsmBinarySubtract;
467
468     /* the generated cast function */
469     /*! \brief Casts pointer from base class to derived class */
470     friend       SgAsmBinarySubtract* isSgAsmBinarySubtract(       SgNode * s );
471     /*! \brief Casts pointer from base class to derived class (for const pointers) */
472     friend const SgAsmBinarySubtract* isSgAsmBinarySubtract( const SgNode * s );
473  public: 
474     virtual ~SgAsmBinarySubtract();
475
476
477  public: 
478     SgAsmBinarySubtract(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
479
480  protected:
481
482
483
484
485 };
486
487 // Class Definition for SgAsmBinaryMultiply
488 class SgAsmBinaryMultiply : public SgAsmBinaryExpression
489 {
490  public:
491     virtual SgAsmType* get_type();
492
493     /*! \brief returns a string representing the class name */
494     virtual std::string class_name() const;
495
496     /*! \brief returns new style SageIII enum values */
497     virtual VariantT variantT() const; // MS: new variant used in tree traversal
498
499     /*! \brief static variant value */
500     static const VariantT static_variant = V_SgAsmBinaryMultiply;
501
502     /* the generated cast function */
503     /*! \brief Casts pointer from base class to derived class */
504     friend       SgAsmBinaryMultiply* isSgAsmBinaryMultiply(       SgNode * s );
505     /*! \brief Casts pointer from base class to derived class (for const pointers) */
506     friend const SgAsmBinaryMultiply* isSgAsmBinaryMultiply( const SgNode * s );
507
508  public: 
509     virtual ~SgAsmBinaryMultiply();
510
511
512  public: 
513     SgAsmBinaryMultiply(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
514 };
515
516 class SgAsmBinaryDivide : public SgAsmBinaryExpression
517 {
518  public:
519     virtual SgAsmType* get_type();
520
521     /*! \brief returns a string representing the class name */
522     virtual std::string class_name() const;
523
524     /*! \brief returns new style SageIII enum values */
525     virtual VariantT variantT() const; // MS: new variant used in tree traversal
526
527     /*! \brief static variant value */
528     static const VariantT static_variant = V_SgAsmBinaryDivide;
529
530     /* the generated cast function */
531     /*! \brief Casts pointer from base class to derived class */
532     friend       SgAsmBinaryDivide* isSgAsmBinaryDivide(       SgNode * s );
533     /*! \brief Casts pointer from base class to derived class (for const pointers) */
534     friend const SgAsmBinaryDivide* isSgAsmBinaryDivide( const SgNode * s );
535
536  public: 
537     virtual ~SgAsmBinaryDivide();
538
539
540  public: 
541     SgAsmBinaryDivide(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
542
543  protected:
544
545
546 };
547
548 // Class Definition for SgAsmBinaryMod
549 class SgAsmBinaryMod : public SgAsmBinaryExpression
550 {
551  public:    
552     virtual SgAsmType* get_type();
553     /*! \brief returns a string representing the class name */
554     virtual std::string class_name() const;
555
556     /*! \brief returns new style SageIII enum values */
557     virtual VariantT variantT() const; // MS: new variant used in tree traversal
558
559     /*! \brief static variant value */
560     static const VariantT static_variant = V_SgAsmBinaryMod;
561
562     /* the generated cast function */
563     /*! \brief Casts pointer from base class to derived class */
564     friend       SgAsmBinaryMod* isSgAsmBinaryMod(       SgNode * s );
565     /*! \brief Casts pointer from base class to derived class (for const pointers) */
566     friend const SgAsmBinaryMod* isSgAsmBinaryMod( const SgNode * s );
567
568  public: 
569     virtual ~SgAsmBinaryMod();
570
571
572  public: 
573     SgAsmBinaryMod(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
574 };
575
576 class SgAsmBinaryAddPreupdate : public SgAsmBinaryExpression
577 {
578  public:
579     virtual SgAsmType* get_type();
580
581     /*! \brief returns a string representing the class name */
582     virtual std::string class_name() const;
583
584     /*! \brief returns new style SageIII enum values */
585     virtual VariantT variantT() const; // MS: new variant used in tree traversal
586
587     /*! \brief static variant value */
588     static const VariantT static_variant = V_SgAsmBinaryAddPreupdate;
589
590     /* the generated cast function */
591     /*! \brief Casts pointer from base class to derived class */
592     friend       SgAsmBinaryAddPreupdate* isSgAsmBinaryAddPreupdate(       SgNode * s );
593     /*! \brief Casts pointer from base class to derived class (for const pointers) */
594     friend const SgAsmBinaryAddPreupdate* isSgAsmBinaryAddPreupdate( const SgNode * s );
595
596  public: 
597     virtual ~SgAsmBinaryAddPreupdate();
598
599
600  public: 
601     SgAsmBinaryAddPreupdate(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
602
603
604 };
605
606 class SgAsmBinarySubtractPreupdate : public SgAsmBinaryExpression
607 {
608  public:
609     virtual SgAsmType* get_type();
610
611     /*! \brief returns a string representing the class name */
612     virtual std::string class_name() const;
613
614     /*! \brief returns new style SageIII enum values */
615     virtual VariantT variantT() const; // MS: new variant used in tree traversal
616
617     /*! \brief static variant value */
618     static const VariantT static_variant = V_SgAsmBinarySubtractPreupdate;
619
620     /* the generated cast function */
621     /*! \brief Casts pointer from base class to derived class */
622     friend       SgAsmBinarySubtractPreupdate* isSgAsmBinarySubtractPreupdate(       SgNode * s );
623     /*! \brief Casts pointer from base class to derived class (for const pointers) */
624     friend const SgAsmBinarySubtractPreupdate* isSgAsmBinarySubtractPreupdate( const SgNode * s );
625
626
627  public: 
628     virtual ~SgAsmBinarySubtractPreupdate();
629
630
631  public: 
632     SgAsmBinarySubtractPreupdate(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
633
634 };
635
636 class SgAsmBinaryAddPostupdate : public SgAsmBinaryExpression
637 {
638  public:
639
640     virtual SgAsmType* get_type();
641     /*! \brief returns a string representing the class name */
642     virtual std::string class_name() const;
643
644     /*! \brief returns new style SageIII enum values */
645     virtual VariantT variantT() const; // MS: new variant used in tree traversal
646
647     /*! \brief static variant value */
648     static const VariantT static_variant = V_SgAsmBinaryAddPostupdate;
649
650     /* the generated cast function */
651     /*! \brief Casts pointer from base class to derived class */
652     friend       SgAsmBinaryAddPostupdate* isSgAsmBinaryAddPostupdate(       SgNode * s );
653     /*! \brief Casts pointer from base class to derived class (for const pointers) */
654     friend const SgAsmBinaryAddPostupdate* isSgAsmBinaryAddPostupdate( const SgNode * s );
655
656  public: 
657     virtual ~SgAsmBinaryAddPostupdate();
658
659
660  public: 
661     SgAsmBinaryAddPostupdate(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
662
663
664 };
665
666 class SgAsmBinarySubtractPostupdate : public SgAsmBinaryExpression
667 {
668  public:
669
670     virtual SgAsmType* get_type();
671     /*! \brief returns a string representing the class name */
672     virtual std::string class_name() const;
673
674     /*! \brief returns new style SageIII enum values */
675     virtual VariantT variantT() const; // MS: new variant used in tree traversal
676
677     /*! \brief static variant value */
678     static const VariantT static_variant = V_SgAsmBinarySubtractPostupdate;
679
680     /* the generated cast function */
681     /*! \brief Casts pointer from base class to derived class */
682     friend       SgAsmBinarySubtractPostupdate* isSgAsmBinarySubtractPostupdate(       SgNode * s );
683     /*! \brief Casts pointer from base class to derived class (for const pointers) */
684     friend const SgAsmBinarySubtractPostupdate* isSgAsmBinarySubtractPostupdate( const SgNode * s );
685
686  public: 
687     virtual ~SgAsmBinarySubtractPostupdate();
688
689
690  public: 
691     SgAsmBinarySubtractPostupdate(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
692
693 };
694
695 class SgAsmBinaryLsl : public SgAsmBinaryExpression
696 {
697  public:
698     virtual SgAsmType* get_type();
699     /*! \brief returns a string representing the class name */
700     virtual std::string class_name() const;
701
702     /*! \brief returns new style SageIII enum values */
703     virtual VariantT variantT() const; // MS: new variant used in tree traversal
704
705     /*! \brief static variant value */
706     static const VariantT static_variant = V_SgAsmBinaryLsl;
707
708     /* the generated cast function */
709     /*! \brief Casts pointer from base class to derived class */
710     friend       SgAsmBinaryLsl* isSgAsmBinaryLsl(       SgNode * s );
711     /*! \brief Casts pointer from base class to derived class (for const pointers) */
712     friend const SgAsmBinaryLsl* isSgAsmBinaryLsl( const SgNode * s );
713
714
715
716  public: 
717     virtual ~SgAsmBinaryLsl();
718
719
720  public: 
721     SgAsmBinaryLsl(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
722
723 };
724
725 class SgAsmBinaryLsr : public SgAsmBinaryExpression
726 {
727  public:
728     virtual SgAsmType* get_type();
729
730
731     /*! \brief returns a string representing the class name */
732     virtual std::string class_name() const;
733
734     /*! \brief returns new style SageIII enum values */
735     virtual VariantT variantT() const; // MS: new variant used in tree traversal
736
737     /*! \brief static variant value */
738     static const VariantT static_variant = V_SgAsmBinaryLsr;
739
740     /* the generated cast function */
741     /*! \brief Casts pointer from base class to derived class */
742     friend       SgAsmBinaryLsr* isSgAsmBinaryLsr(       SgNode * s );
743     /*! \brief Casts pointer from base class to derived class (for const pointers) */
744     friend const SgAsmBinaryLsr* isSgAsmBinaryLsr( const SgNode * s );
745
746  public: 
747     virtual ~SgAsmBinaryLsr();
748
749
750  public: 
751     SgAsmBinaryLsr(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
752
753 };
754
755 class SgAsmBinaryAsr : public SgAsmBinaryExpression
756 {
757  public:
758     virtual SgAsmType* get_type();
759
760
761     /*! \brief returns a string representing the class name */
762     virtual std::string class_name() const;
763
764     /*! \brief returns new style SageIII enum values */
765     virtual VariantT variantT() const; // MS: new variant used in tree traversal
766
767     /*! \brief static variant value */
768     static const VariantT static_variant = V_SgAsmBinaryAsr;
769
770     /* the generated cast function */
771     /*! \brief Casts pointer from base class to derived class */
772     friend       SgAsmBinaryAsr* isSgAsmBinaryAsr(       SgNode * s );
773     /*! \brief Casts pointer from base class to derived class (for const pointers) */
774     friend const SgAsmBinaryAsr* isSgAsmBinaryAsr( const SgNode * s );
775
776  public: 
777     virtual ~SgAsmBinaryAsr();
778
779
780  public: 
781     SgAsmBinaryAsr(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
782
783 };
784
785 class SgAsmBinaryRor : public SgAsmBinaryExpression
786 {
787  public:      
788     virtual SgAsmType* get_type();
789     /*! \brief returns a string representing the class name */
790     virtual std::string class_name() const;
791
792     /*! \brief returns new style SageIII enum values */
793     virtual VariantT variantT() const; // MS: new variant used in tree traversal
794
795     /*! \brief static variant value */
796     static const VariantT static_variant = V_SgAsmBinaryRor;
797
798     /* the generated cast function */
799     /*! \brief Casts pointer from base class to derived class */
800     friend       SgAsmBinaryRor* isSgAsmBinaryRor(       SgNode * s );
801     /*! \brief Casts pointer from base class to derived class (for const pointers) */
802     friend const SgAsmBinaryRor* isSgAsmBinaryRor( const SgNode * s );
803
804
805  public: 
806     virtual ~SgAsmBinaryRor();
807
808
809  public: 
810     SgAsmBinaryRor(SgAsmExpression* lhs = NULL, SgAsmExpression* rhs = NULL); 
811
812  
813 };
814
815 class SgAsmUnaryExpression : public SgAsmExpression
816 {
817  public:
818     virtual SgAsmType* get_type();
819     /*! \brief returns a string representing the class name */
820     virtual std::string class_name() const;
821
822     /*! \brief returns new style SageIII enum values */
823     virtual VariantT variantT() const; // MS: new variant used in tree traversal
824
825     /*! \brief static variant value */
826     static const VariantT static_variant = V_SgAsmUnaryExpression;
827
828     /* the generated cast function */
829     /*! \brief Casts pointer from base class to derived class */
830     friend       SgAsmUnaryExpression* isSgAsmUnaryExpression(       SgNode * s );
831     /*! \brief Casts pointer from base class to derived class (for const pointers) */
832     friend const SgAsmUnaryExpression* isSgAsmUnaryExpression( const SgNode * s );
833
834  public: 
835     SgAsmExpression* get_operand() const;
836     void set_operand(SgAsmExpression* operand);
837
838
839  public: 
840     virtual ~SgAsmUnaryExpression();
841
842
843  public: 
844     SgAsmUnaryExpression(SgAsmExpression* operand = NULL); 
845
846  protected:
847     // Start of memberFunctionString
848     SgAsmExpression* p_operand;
849           
850     // End of memberFunctionString
851
852
853 };
854
855 class SgAsmUnaryPlus : public SgAsmUnaryExpression
856 {
857  public:
858     virtual SgAsmType* get_type();
859
860     /*! \brief returns a string representing the class name */
861     virtual std::string class_name() const;
862
863     /*! \brief returns new style SageIII enum values */
864     virtual VariantT variantT() const; // MS: new variant used in tree traversal
865
866     /*! \brief static variant value */
867     static const VariantT static_variant = V_SgAsmUnaryPlus;
868
869     /* the generated cast function */
870     /*! \brief Casts pointer from base class to derived class */
871     friend       SgAsmUnaryPlus* isSgAsmUnaryPlus(       SgNode * s );
872     /*! \brief Casts pointer from base class to derived class (for const pointers) */
873     friend const SgAsmUnaryPlus* isSgAsmUnaryPlus( const SgNode * s );
874
875  public: 
876     virtual ~SgAsmUnaryPlus();
877
878
879  public: 
880     SgAsmUnaryPlus(SgAsmExpression* operand = NULL); 
881
882  protected:
883
884
885 };
886
887 class SgAsmUnaryMinus : public SgAsmUnaryExpression
888 {
889  public:
890     virtual SgAsmType* get_type();
891
892     /*! \brief returns a string representing the class name */
893     virtual std::string class_name() const;
894
895     /*! \brief returns new style SageIII enum values */
896     virtual VariantT variantT() const; // MS: new variant used in tree traversal
897
898     /*! \brief static variant value */
899     static const VariantT static_variant = V_SgAsmUnaryMinus;
900
901     /* the generated cast function */
902     /*! \brief Casts pointer from base class to derived class */
903     friend       SgAsmUnaryMinus* isSgAsmUnaryMinus(       SgNode * s );
904     /*! \brief Casts pointer from base class to derived class (for const pointers) */
905     friend const SgAsmUnaryMinus* isSgAsmUnaryMinus( const SgNode * s );
906
907
908  public: 
909     virtual ~SgAsmUnaryMinus();
910
911
912  public: 
913     SgAsmUnaryMinus(SgAsmExpression* operand = NULL); 
914
915  protected:
916
917
918 };
919
920 // Class Definition for SgAsmUnaryRrx
921 class SgAsmUnaryRrx : public SgAsmUnaryExpression
922 {
923  public:
924
925     virtual SgAsmType* get_type();
926
927     /*! \brief returns a string representing the class name */
928     virtual std::string class_name() const;
929
930     /*! \brief returns new style SageIII enum values */
931     virtual VariantT variantT() const; // MS: new variant used in tree traversal
932
933     /*! \brief static variant value */
934     static const VariantT static_variant = V_SgAsmUnaryRrx;
935
936     /* the generated cast function */
937     /*! \brief Casts pointer from base class to derived class */
938     friend       SgAsmUnaryRrx* isSgAsmUnaryRrx(       SgNode * s );
939     /*! \brief Casts pointer from base class to derived class (for const pointers) */
940     friend const SgAsmUnaryRrx* isSgAsmUnaryRrx( const SgNode * s );
941
942  public: 
943     virtual ~SgAsmUnaryRrx();
944
945
946  public: 
947     SgAsmUnaryRrx(SgAsmExpression* operand = NULL); 
948
949  protected:
950
951
952 };
953
954 // Class Definition for SgAsmMemoryReferenceExpression
955 class SgAsmMemoryReferenceExpression : public SgAsmExpression
956 {
957  public:
958     virtual SgAsmType* get_type();
959
960     /*! \brief returns a string representing the class name */
961     virtual std::string class_name() const;
962
963     /*! \brief returns new style SageIII enum values */
964     virtual VariantT variantT() const; // MS: new variant used in tree traversal
965
966     /*! \brief static variant value */
967     static const VariantT static_variant = V_SgAsmMemoryReferenceExpression;
968
969     /* the generated cast function */
970     /*! \brief Casts pointer from base class to derived class */
971     friend       SgAsmMemoryReferenceExpression* isSgAsmMemoryReferenceExpression(       SgNode * s );
972     /*! \brief Casts pointer from base class to derived class (for const pointers) */
973     friend const SgAsmMemoryReferenceExpression* isSgAsmMemoryReferenceExpression( const SgNode * s );
974
975  public: 
976     SgAsmExpression* get_address() const;
977     void set_address(SgAsmExpression* address);
978
979  public: 
980     SgAsmExpression* get_segment() const;
981     void set_segment(SgAsmExpression* segment);
982
983  public: 
984     SgAsmType* get_type() const;
985     void set_type(SgAsmType* type);
986
987
988  public: 
989     virtual ~SgAsmMemoryReferenceExpression();
990
991
992  public: 
993     SgAsmMemoryReferenceExpression(SgAsmExpression* address = NULL, SgAsmExpression* segment = NULL); 
994
995  protected:
996     // Start of memberFunctionString
997     SgAsmExpression* p_address;
998           
999     // End of memberFunctionString
1000     // Start of memberFunctionString
1001     SgAsmExpression* p_segment;
1002           
1003     // End of memberFunctionString
1004     // Start of memberFunctionString
1005     SgAsmType* p_type;
1006           
1007     // End of memberFunctionString
1008
1009
1010 };
1011
1012 // Class Definition for SgAsmRegisterReferenceExpression
1013 class SgAsmRegisterReferenceExpression : public SgAsmExpression
1014 {
1015  public:
1016     virtual SgAsmType* get_type();
1017
1018
1019     /*! \brief returns a string representing the class name */
1020     virtual std::string class_name() const;
1021
1022     /*! \brief returns new style SageIII enum values */
1023     virtual VariantT variantT() const; // MS: new variant used in tree traversal
1024
1025     /*! \brief static variant value */
1026     static const VariantT static_variant = V_SgAsmRegisterReferenceExpression;
1027
1028     /* the generated cast function */
1029     /*! \brief Casts pointer from base class to derived class */
1030     friend       SgAsmRegisterReferenceExpression* isSgAsmRegisterReferenceExpression(       SgNode * s );
1031     /*! \brief Casts pointer from base class to derived class (for const pointers) */
1032     friend const SgAsmRegisterReferenceExpression* isSgAsmRegisterReferenceExpression( const SgNode * s );
1033
1034  public: 
1035     virtual void set_type(SgAsmType* type);
1036
1037
1038  public: 
1039     virtual ~SgAsmRegisterReferenceExpression();
1040
1041
1042  public: 
1043     SgAsmRegisterReferenceExpression(); 
1044
1045  protected:
1046     // Start of memberFunctionString
1047     SgAsmType* p_type;
1048           
1049     // End of memberFunctionString
1050
1051
1052 };
1053
1054 class SgAsmx86RegisterReferenceExpression : public SgAsmRegisterReferenceExpression
1055 {
1056  public:
1057
1058
1059     //! Get a unique identifier for this particular register
1060     std::pair<X86RegisterClass, int> get_identifier() const;
1061
1062     /*! \brief returns a string representing the class name */
1063     virtual std::string class_name() const;
1064
1065     /*! \brief returns new style SageIII enum values */
1066     virtual VariantT variantT() const; // MS: new variant used in tree traversal
1067
1068     /*! \brief static variant value */
1069     static const VariantT static_variant = V_SgAsmx86RegisterReferenceExpression;
1070
1071     /* the generated cast function */
1072     /*! \brief Casts pointer from base class to derived class */
1073     friend       SgAsmx86RegisterReferenceExpression* isSgAsmx86RegisterReferenceExpression(       SgNode * s );
1074     /*! \brief Casts pointer from base class to derived class (for const pointers) */
1075     friend const SgAsmx86RegisterReferenceExpression* isSgAsmx86RegisterReferenceExpression( const SgNode * s );
1076
1077  public: 
1078     X86RegisterClass get_register_class() const;
1079     void set_register_class(X86RegisterClass register_class);
1080
1081  public: 
1082     int get_register_number() const;
1083     void set_register_number(int register_number);
1084
1085  public: 
1086     X86PositionInRegister get_position_in_register() const;
1087     void set_position_in_register(X86PositionInRegister position_in_register);
1088
1089
1090  public: 
1091     virtual ~SgAsmx86RegisterReferenceExpression();
1092
1093
1094  public: 
1095     SgAsmx86RegisterReferenceExpression(X86RegisterClass register_class = x86_regclass_unknown, int register_number = 0, X86PositionInRegister position_in_register = x86_regpos_unknown); 
1096
1097  protected:
1098     // Start of memberFunctionString
1099     X86RegisterClass p_register_class;
1100           
1101     // End of memberFunctionString
1102     // Start of memberFunctionString
1103     int p_register_number;
1104           
1105     // End of memberFunctionString
1106     // Start of memberFunctionString
1107     X86PositionInRegister p_position_in_register;
1108           
1109     // End of memberFunctionString
1110 };
1111
1112 // Class Definition for SgAsmPowerpcRegisterReferenceExpression
1113 class SgAsmPowerpcRegisterReferenceExpression : public SgAsmRegisterReferenceExpression
1114 {
1115     public:
1116         enum powerpc_register_enum { // The exact numbers here are important
1117     undefined_powerpc_register = 0, /*!< unknown (error or unitialized value) */
1118     reg0 = 1,
1119     reg1 = 2,
1120     reg2 = 3,
1121     reg3 = 4,
1122     reg4 = 5,
1123     reg5 = 6,
1124     reg6 = 7,
1125     reg7 = 8,
1126     last_powerpc_register
1127         };
1128
1129     public:
1130
1131         /*! \brief returns a string representing the class name */
1132         virtual std::string class_name() const { return "SgAsmPowerpcRegisterReferenceExpression"; }
1133
1134         /*! \brief returns new style SageIII enum values */
1135         virtual VariantT variantT() const { return static_variant; } 
1136
1137         /*! \brief static variant value */
1138         static const VariantT static_variant = V_SgAsmPowerpcRegisterReferenceExpression;
1139
1140         /* the generated cast function */
1141         /*! \brief Casts pointer from base class to derived class */
1142         friend       SgAsmPowerpcRegisterReferenceExpression* isSgAsmPowerpcRegisterReferenceExpression(       SgNode * s );
1143         /*! \brief Casts pointer from base class to derived class (for const pointers) */
1144         friend const SgAsmPowerpcRegisterReferenceExpression* isSgAsmPowerpcRegisterReferenceExpression( const SgNode * s );
1145
1146     public:
1147         PowerpcRegisterClass get_register_class() const;
1148         void set_register_class(PowerpcRegisterClass register_class);
1149         int get_register_number() const;
1150         void set_register_number(int register_number);
1151         PowerpcConditionRegisterAccessGranularity get_conditionRegisterGranularity() const;
1152         void set_conditionRegisterGranularity(PowerpcConditionRegisterAccessGranularity conditionRegisterGranularity);
1153         virtual ~SgAsmPowerpcRegisterReferenceExpression();
1154         SgAsmPowerpcRegisterReferenceExpression(PowerpcRegisterClass register_class = powerpc_regclass_unknown, int
1155                 register_number = 0, PowerpcConditionRegisterAccessGranularity conditionRegisterGranularity =
1156                         powerpc_condreggranularity_whole);
1157
1158     protected:
1159         PowerpcRegisterClass p_register_class;
1160         int p_register_number;
1161         PowerpcConditionRegisterAccessGranularity p_conditionRegisterGranularity;
1162 };
1163
1164 uint64_t getAsmSignedConstant(SgAsmValueExpression *e);
1165
1166
1167 #endif