Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(107)

Side by Side Diff: src/IceOperand.h

Issue 570713006: Subzero: Refactor Operand::dump(). (Closed) Base URL: https://chromium.googlesource.com/native_client/pnacl-subzero.git@master
Patch Set: Use a more general dump function Created 6 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « src/IceInstX8632.cpp ('k') | src/IceOperand.cpp » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
1 //===- subzero/src/IceOperand.h - High-level operands -----------*- C++ -*-===// 1 //===- subzero/src/IceOperand.h - High-level operands -----------*- C++ -*-===//
2 // 2 //
3 // The Subzero Code Generator 3 // The Subzero Code Generator
4 // 4 //
5 // This file is distributed under the University of Illinois Open Source 5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details. 6 // License. See LICENSE.TXT for details.
7 // 7 //
8 //===----------------------------------------------------------------------===// 8 //===----------------------------------------------------------------------===//
9 // 9 //
10 // This file declares the Operand class and its target-independent 10 // This file declares the Operand class and its target-independent
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after
44 // Every Operand keeps an array of the Variables referenced in 44 // Every Operand keeps an array of the Variables referenced in
45 // the operand. This is so that the liveness operations can get 45 // the operand. This is so that the liveness operations can get
46 // quick access to the variables of interest, without having to dig 46 // quick access to the variables of interest, without having to dig
47 // so far into the operand. 47 // so far into the operand.
48 SizeT getNumVars() const { return NumVars; } 48 SizeT getNumVars() const { return NumVars; }
49 Variable *getVar(SizeT I) const { 49 Variable *getVar(SizeT I) const {
50 assert(I < getNumVars()); 50 assert(I < getNumVars());
51 return Vars[I]; 51 return Vars[I];
52 } 52 }
53 virtual void emit(const Cfg *Func) const = 0; 53 virtual void emit(const Cfg *Func) const = 0;
54 virtual void dump(const Cfg *Func) const = 0; 54 // The dump(Func,Str) implementation must be sure to handle the
55 // situation where Func==NULL.
56 virtual void dump(const Cfg *Func, Ostream &Str) const = 0;
57 void dump(const Cfg *Func) const {
58 assert(Func);
59 dump(Func, Func->getContext()->getStrDump());
60 }
61 void dump(Ostream &Str) const { dump(NULL, Str); }
55 62
56 // Query whether this object was allocated in isolation, or added to 63 // Query whether this object was allocated in isolation, or added to
57 // some higher-level pool. This determines whether a containing 64 // some higher-level pool. This determines whether a containing
58 // object's destructor should delete this object. Generally, 65 // object's destructor should delete this object. Generally,
59 // constants are pooled globally, variables are pooled per-CFG, and 66 // constants are pooled globally, variables are pooled per-CFG, and
60 // target-specific operands are not pooled. 67 // target-specific operands are not pooled.
61 virtual bool isPooled() const { return false; } 68 virtual bool isPooled() const { return false; }
62 69
63 virtual ~Operand() {} 70 virtual ~Operand() {}
64 71
(...skipping 10 matching lines...) Expand all
75 private: 82 private:
76 Operand(const Operand &) LLVM_DELETED_FUNCTION; 83 Operand(const Operand &) LLVM_DELETED_FUNCTION;
77 Operand &operator=(const Operand &) LLVM_DELETED_FUNCTION; 84 Operand &operator=(const Operand &) LLVM_DELETED_FUNCTION;
78 }; 85 };
79 86
80 // Constant is the abstract base class for constants. All 87 // Constant is the abstract base class for constants. All
81 // constants are allocated from a global arena and are pooled. 88 // constants are allocated from a global arena and are pooled.
82 class Constant : public Operand { 89 class Constant : public Operand {
83 public: 90 public:
84 uint32_t getPoolEntryID() const { return PoolEntryID; } 91 uint32_t getPoolEntryID() const { return PoolEntryID; }
92 using Operand::dump;
85 virtual void emit(const Cfg *Func) const { emit(Func->getContext()); } 93 virtual void emit(const Cfg *Func) const { emit(Func->getContext()); }
86 virtual void dump(const Cfg *Func) const { dump(Func->getContext()); }
87 virtual void emit(GlobalContext *Ctx) const = 0; 94 virtual void emit(GlobalContext *Ctx) const = 0;
88 virtual void dump(GlobalContext *Ctx) const = 0; 95 virtual void dump(const Cfg *Func, Ostream &Str) const = 0;
89 96
90 static bool classof(const Operand *Operand) { 97 static bool classof(const Operand *Operand) {
91 OperandKind Kind = Operand->getKind(); 98 OperandKind Kind = Operand->getKind();
92 return Kind >= kConst_Base && Kind <= kConst_Num; 99 return Kind >= kConst_Base && Kind <= kConst_Num;
93 } 100 }
94 101
95 protected: 102 protected:
96 Constant(OperandKind Kind, Type Ty, uint32_t PoolEntryID) 103 Constant(OperandKind Kind, Type Ty, uint32_t PoolEntryID)
97 : Operand(Kind, Ty), PoolEntryID(PoolEntryID) { 104 : Operand(Kind, Ty), PoolEntryID(PoolEntryID) {
98 Vars = NULL; 105 Vars = NULL;
(...skipping 18 matching lines...) Expand all
117 uint32_t PoolEntryID) { 124 uint32_t PoolEntryID) {
118 return new (Ctx->allocate<ConstantPrimitive>()) 125 return new (Ctx->allocate<ConstantPrimitive>())
119 ConstantPrimitive(Ty, Value, PoolEntryID); 126 ConstantPrimitive(Ty, Value, PoolEntryID);
120 } 127 }
121 T getValue() const { return Value; } 128 T getValue() const { return Value; }
122 using Constant::emit; 129 using Constant::emit;
123 // The target needs to implement this for each ConstantPrimitive 130 // The target needs to implement this for each ConstantPrimitive
124 // specialization. 131 // specialization.
125 virtual void emit(GlobalContext *Ctx) const; 132 virtual void emit(GlobalContext *Ctx) const;
126 using Constant::dump; 133 using Constant::dump;
127 virtual void dump(GlobalContext *Ctx) const { 134 virtual void dump(const Cfg *, Ostream &Str) const { Str << getValue(); }
128 Ostream &Str = Ctx->getStrDump();
129 Str << getValue();
130 }
131 135
132 static bool classof(const Operand *Operand) { 136 static bool classof(const Operand *Operand) {
133 return Operand->getKind() == K; 137 return Operand->getKind() == K;
134 } 138 }
135 139
136 private: 140 private:
137 ConstantPrimitive(Type Ty, T Value, uint32_t PoolEntryID) 141 ConstantPrimitive(Type Ty, T Value, uint32_t PoolEntryID)
138 : Constant(K, Ty, PoolEntryID), Value(Value) {} 142 : Constant(K, Ty, PoolEntryID), Value(Value) {}
139 ConstantPrimitive(const ConstantPrimitive &) LLVM_DELETED_FUNCTION; 143 ConstantPrimitive(const ConstantPrimitive &) LLVM_DELETED_FUNCTION;
140 ConstantPrimitive &operator=(const ConstantPrimitive &) LLVM_DELETED_FUNCTION; 144 ConstantPrimitive &operator=(const ConstantPrimitive &) LLVM_DELETED_FUNCTION;
141 virtual ~ConstantPrimitive() {} 145 virtual ~ConstantPrimitive() {}
142 const T Value; 146 const T Value;
143 }; 147 };
144 148
145 typedef ConstantPrimitive<uint64_t, Operand::kConstInteger> ConstantInteger; 149 typedef ConstantPrimitive<uint64_t, Operand::kConstInteger> ConstantInteger;
146 typedef ConstantPrimitive<float, Operand::kConstFloat> ConstantFloat; 150 typedef ConstantPrimitive<float, Operand::kConstFloat> ConstantFloat;
147 typedef ConstantPrimitive<double, Operand::kConstDouble> ConstantDouble; 151 typedef ConstantPrimitive<double, Operand::kConstDouble> ConstantDouble;
148 152
149 template <> inline void ConstantInteger::dump(GlobalContext *Ctx) const { 153 template <> inline void ConstantInteger::dump(const Cfg *, Ostream &Str) const {
150 Ostream &Str = Ctx->getStrDump();
151 if (getType() == IceType_i1) 154 if (getType() == IceType_i1)
152 Str << (getValue() ? "true" : "false"); 155 Str << (getValue() ? "true" : "false");
153 else 156 else
154 Str << static_cast<int64_t>(getValue()); 157 Str << static_cast<int64_t>(getValue());
155 } 158 }
156 159
157 // RelocatableTuple bundles the parameters that are used to 160 // RelocatableTuple bundles the parameters that are used to
158 // construct an ConstantRelocatable. It is done this way so that 161 // construct an ConstantRelocatable. It is done this way so that
159 // ConstantRelocatable can fit into the global constant pool 162 // ConstantRelocatable can fit into the global constant pool
160 // template mechanism. 163 // template mechanism.
(...skipping 25 matching lines...) Expand all
186 return new (Ctx->allocate<ConstantRelocatable>()) ConstantRelocatable( 189 return new (Ctx->allocate<ConstantRelocatable>()) ConstantRelocatable(
187 Ty, Tuple.Offset, Tuple.Name, Tuple.SuppressMangling, PoolEntryID); 190 Ty, Tuple.Offset, Tuple.Name, Tuple.SuppressMangling, PoolEntryID);
188 } 191 }
189 int64_t getOffset() const { return Offset; } 192 int64_t getOffset() const { return Offset; }
190 IceString getName() const { return Name; } 193 IceString getName() const { return Name; }
191 void setSuppressMangling(bool Value) { SuppressMangling = Value; } 194 void setSuppressMangling(bool Value) { SuppressMangling = Value; }
192 bool getSuppressMangling() const { return SuppressMangling; } 195 bool getSuppressMangling() const { return SuppressMangling; }
193 using Constant::emit; 196 using Constant::emit;
194 using Constant::dump; 197 using Constant::dump;
195 virtual void emit(GlobalContext *Ctx) const; 198 virtual void emit(GlobalContext *Ctx) const;
196 virtual void dump(GlobalContext *Ctx) const; 199 virtual void dump(const Cfg *Func, Ostream &Str) const;
197 200
198 static bool classof(const Operand *Operand) { 201 static bool classof(const Operand *Operand) {
199 OperandKind Kind = Operand->getKind(); 202 OperandKind Kind = Operand->getKind();
200 return Kind == kConstRelocatable; 203 return Kind == kConstRelocatable;
201 } 204 }
202 205
203 private: 206 private:
204 ConstantRelocatable(Type Ty, int64_t Offset, const IceString &Name, 207 ConstantRelocatable(Type Ty, int64_t Offset, const IceString &Name,
205 bool SuppressMangling, uint32_t PoolEntryID) 208 bool SuppressMangling, uint32_t PoolEntryID)
206 : Constant(kConstRelocatable, Ty, PoolEntryID), Offset(Offset), 209 : Constant(kConstRelocatable, Ty, PoolEntryID), Offset(Offset),
(...skipping 11 matching lines...) Expand all
218 // legal to lower ConstantUndef to any value, backends should try to 221 // legal to lower ConstantUndef to any value, backends should try to
219 // make code generation deterministic by lowering ConstantUndefs to 0. 222 // make code generation deterministic by lowering ConstantUndefs to 0.
220 class ConstantUndef : public Constant { 223 class ConstantUndef : public Constant {
221 public: 224 public:
222 static ConstantUndef *create(GlobalContext *Ctx, Type Ty, 225 static ConstantUndef *create(GlobalContext *Ctx, Type Ty,
223 uint32_t PoolEntryID) { 226 uint32_t PoolEntryID) {
224 return new (Ctx->allocate<ConstantUndef>()) ConstantUndef(Ty, PoolEntryID); 227 return new (Ctx->allocate<ConstantUndef>()) ConstantUndef(Ty, PoolEntryID);
225 } 228 }
226 229
227 using Constant::emit; 230 using Constant::emit;
231 using Constant::dump;
228 // The target needs to implement this. 232 // The target needs to implement this.
229 virtual void emit(GlobalContext *Ctx) const; 233 virtual void emit(GlobalContext *Ctx) const;
230 234 virtual void dump(const Cfg *, Ostream &Str) const { Str << "undef"; }
231 using Constant::dump;
232 virtual void dump(GlobalContext *Ctx) const {
233 Ostream &Str = Ctx->getStrEmit();
234 Str << "undef";
235 }
236 235
237 static bool classof(const Operand *Operand) { 236 static bool classof(const Operand *Operand) {
238 return Operand->getKind() == kConstUndef; 237 return Operand->getKind() == kConstUndef;
239 } 238 }
240 239
241 private: 240 private:
242 ConstantUndef(Type Ty, uint32_t PoolEntryID) 241 ConstantUndef(Type Ty, uint32_t PoolEntryID)
243 : Constant(kConstUndef, Ty, PoolEntryID) {} 242 : Constant(kConstUndef, Ty, PoolEntryID) {}
244 ConstantUndef(const ConstantUndef &) LLVM_DELETED_FUNCTION; 243 ConstantUndef(const ConstantUndef &) LLVM_DELETED_FUNCTION;
245 ConstantUndef &operator=(const ConstantUndef &) LLVM_DELETED_FUNCTION; 244 ConstantUndef &operator=(const ConstantUndef &) LLVM_DELETED_FUNCTION;
(...skipping 162 matching lines...) Expand 10 before | Expand all | Expand 10 after
408 HiVar = Hi; 407 HiVar = Hi;
409 } 408 }
410 // Creates a temporary copy of the variable with a different type. 409 // Creates a temporary copy of the variable with a different type.
411 // Used primarily for syntactic correctness of textual assembly 410 // Used primarily for syntactic correctness of textual assembly
412 // emission. Note that only basic information is copied, in 411 // emission. Note that only basic information is copied, in
413 // particular not DefInst, IsArgument, Weight, RegisterPreference, 412 // particular not DefInst, IsArgument, Weight, RegisterPreference,
414 // AllowRegisterOverlap, LoVar, HiVar, VarsReal. 413 // AllowRegisterOverlap, LoVar, HiVar, VarsReal.
415 Variable asType(Type Ty); 414 Variable asType(Type Ty);
416 415
417 virtual void emit(const Cfg *Func) const; 416 virtual void emit(const Cfg *Func) const;
418 virtual void dump(const Cfg *Func) const; 417 using Operand::dump;
418 virtual void dump(const Cfg *Func, Ostream &Str) const;
419 419
420 static bool classof(const Operand *Operand) { 420 static bool classof(const Operand *Operand) {
421 return Operand->getKind() == kVariable; 421 return Operand->getKind() == kVariable;
422 } 422 }
423 423
424 // The destructor is public because of the asType() method. 424 // The destructor is public because of the asType() method.
425 virtual ~Variable() {} 425 virtual ~Variable() {}
426 426
427 private: 427 private:
428 Variable(Type Ty, const CfgNode *Node, SizeT Index, const IceString &Name) 428 Variable(Type Ty, const CfgNode *Node, SizeT Index, const IceString &Name)
(...skipping 55 matching lines...) Expand 10 before | Expand all | Expand 10 after
484 Variable *LoVar; 484 Variable *LoVar;
485 Variable *HiVar; 485 Variable *HiVar;
486 // VarsReal (and Operand::Vars) are set up such that Vars[0] == 486 // VarsReal (and Operand::Vars) are set up such that Vars[0] ==
487 // this. 487 // this.
488 Variable *VarsReal[1]; 488 Variable *VarsReal[1];
489 }; 489 };
490 490
491 } // end of namespace Ice 491 } // end of namespace Ice
492 492
493 #endif // SUBZERO_SRC_ICEOPERAND_H 493 #endif // SUBZERO_SRC_ICEOPERAND_H
OLDNEW
« no previous file with comments | « src/IceInstX8632.cpp ('k') | src/IceOperand.cpp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698