OLD | NEW |
1 //===- subzero/src/IceOperand.cpp - High-level operand implementation -----===// | 1 //===- subzero/src/IceOperand.cpp - High-level operand implementation -----===// |
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 implements the Operand class and its target-independent | 10 // This file implements the Operand class and its target-independent |
(...skipping 161 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
172 if (SingleUseNode != Node) | 172 if (SingleUseNode != Node) |
173 MakeMulti = true; | 173 MakeMulti = true; |
174 break; | 174 break; |
175 case MBS_MultiBlock: | 175 case MBS_MultiBlock: |
176 break; | 176 break; |
177 } | 177 } |
178 } | 178 } |
179 | 179 |
180 if (MakeMulti) { | 180 if (MakeMulti) { |
181 MultiBlock = MBS_MultiBlock; | 181 MultiBlock = MBS_MultiBlock; |
182 SingleUseNode = NULL; | 182 SingleUseNode = nullptr; |
183 } | 183 } |
184 } | 184 } |
185 | 185 |
186 void VariableTracking::markDef(MetadataKind TrackingKind, const Inst *Instr, | 186 void VariableTracking::markDef(MetadataKind TrackingKind, const Inst *Instr, |
187 const CfgNode *Node) { | 187 const CfgNode *Node) { |
188 // TODO(stichnot): If the definition occurs in the last instruction | 188 // TODO(stichnot): If the definition occurs in the last instruction |
189 // of the block, consider not marking this as a separate use. But | 189 // of the block, consider not marking this as a separate use. But |
190 // be careful not to omit all uses of the variable if markDef() and | 190 // be careful not to omit all uses of the variable if markDef() and |
191 // markUse() both use this optimization. | 191 // markUse() both use this optimization. |
192 assert(Node); | 192 assert(Node); |
193 // Verify that instructions are added in increasing order. | 193 // Verify that instructions are added in increasing order. |
194 #ifndef NDEBUG | 194 #ifndef NDEBUG |
195 if (TrackingKind == VMK_All) { | 195 if (TrackingKind == VMK_All) { |
196 const Inst *LastInstruction = | 196 const Inst *LastInstruction = |
197 Definitions.empty() ? FirstOrSingleDefinition : Definitions.back(); | 197 Definitions.empty() ? FirstOrSingleDefinition : Definitions.back(); |
198 assert(LastInstruction == NULL || | 198 assert(LastInstruction == nullptr || |
199 Instr->getNumber() >= LastInstruction->getNumber()); | 199 Instr->getNumber() >= LastInstruction->getNumber()); |
200 } | 200 } |
201 #endif | 201 #endif |
202 const bool IsFromDef = true; | 202 const bool IsFromDef = true; |
203 const bool IsImplicit = false; | 203 const bool IsImplicit = false; |
204 markUse(TrackingKind, Instr, Node, IsFromDef, IsImplicit); | 204 markUse(TrackingKind, Instr, Node, IsFromDef, IsImplicit); |
205 if (TrackingKind == VMK_Uses) | 205 if (TrackingKind == VMK_Uses) |
206 return; | 206 return; |
207 if (FirstOrSingleDefinition == NULL) | 207 if (FirstOrSingleDefinition == nullptr) |
208 FirstOrSingleDefinition = Instr; | 208 FirstOrSingleDefinition = Instr; |
209 else if (TrackingKind == VMK_All) | 209 else if (TrackingKind == VMK_All) |
210 Definitions.push_back(Instr); | 210 Definitions.push_back(Instr); |
211 switch (MultiDef) { | 211 switch (MultiDef) { |
212 case MDS_Unknown: | 212 case MDS_Unknown: |
213 assert(SingleDefNode == NULL); | 213 assert(SingleDefNode == nullptr); |
214 MultiDef = MDS_SingleDef; | 214 MultiDef = MDS_SingleDef; |
215 SingleDefNode = Node; | 215 SingleDefNode = Node; |
216 break; | 216 break; |
217 case MDS_SingleDef: | 217 case MDS_SingleDef: |
218 assert(SingleDefNode); | 218 assert(SingleDefNode); |
219 if (Node == SingleDefNode) { | 219 if (Node == SingleDefNode) { |
220 MultiDef = MDS_MultiDefSingleBlock; | 220 MultiDef = MDS_MultiDefSingleBlock; |
221 } else { | 221 } else { |
222 MultiDef = MDS_MultiDefMultiBlock; | 222 MultiDef = MDS_MultiDefMultiBlock; |
223 SingleDefNode = NULL; | 223 SingleDefNode = nullptr; |
224 } | 224 } |
225 break; | 225 break; |
226 case MDS_MultiDefSingleBlock: | 226 case MDS_MultiDefSingleBlock: |
227 assert(SingleDefNode); | 227 assert(SingleDefNode); |
228 if (Node != SingleDefNode) { | 228 if (Node != SingleDefNode) { |
229 MultiDef = MDS_MultiDefMultiBlock; | 229 MultiDef = MDS_MultiDefMultiBlock; |
230 SingleDefNode = NULL; | 230 SingleDefNode = nullptr; |
231 } | 231 } |
232 break; | 232 break; |
233 case MDS_MultiDefMultiBlock: | 233 case MDS_MultiDefMultiBlock: |
234 assert(SingleDefNode == NULL); | 234 assert(SingleDefNode == nullptr); |
235 break; | 235 break; |
236 } | 236 } |
237 } | 237 } |
238 | 238 |
239 const Inst *VariableTracking::getFirstDefinition() const { | 239 const Inst *VariableTracking::getFirstDefinition() const { |
240 switch (MultiDef) { | 240 switch (MultiDef) { |
241 case MDS_Unknown: | 241 case MDS_Unknown: |
242 case MDS_MultiDefMultiBlock: | 242 case MDS_MultiDefMultiBlock: |
243 return NULL; | 243 return nullptr; |
244 case MDS_SingleDef: | 244 case MDS_SingleDef: |
245 case MDS_MultiDefSingleBlock: | 245 case MDS_MultiDefSingleBlock: |
246 assert(FirstOrSingleDefinition); | 246 assert(FirstOrSingleDefinition); |
247 return FirstOrSingleDefinition; | 247 return FirstOrSingleDefinition; |
248 } | 248 } |
249 return NULL; | 249 return nullptr; |
250 } | 250 } |
251 | 251 |
252 const Inst *VariableTracking::getSingleDefinition() const { | 252 const Inst *VariableTracking::getSingleDefinition() const { |
253 switch (MultiDef) { | 253 switch (MultiDef) { |
254 case MDS_Unknown: | 254 case MDS_Unknown: |
255 case MDS_MultiDefMultiBlock: | 255 case MDS_MultiDefMultiBlock: |
256 case MDS_MultiDefSingleBlock: | 256 case MDS_MultiDefSingleBlock: |
257 return NULL; | 257 return nullptr; |
258 case MDS_SingleDef: | 258 case MDS_SingleDef: |
259 assert(FirstOrSingleDefinition); | 259 assert(FirstOrSingleDefinition); |
260 return FirstOrSingleDefinition; | 260 return FirstOrSingleDefinition; |
261 } | 261 } |
262 return NULL; | 262 return nullptr; |
263 } | 263 } |
264 | 264 |
265 void VariablesMetadata::init(MetadataKind TrackingKind) { | 265 void VariablesMetadata::init(MetadataKind TrackingKind) { |
266 TimerMarker T(TimerStack::TT_vmetadata, Func); | 266 TimerMarker T(TimerStack::TT_vmetadata, Func); |
267 Kind = TrackingKind; | 267 Kind = TrackingKind; |
268 Metadata.clear(); | 268 Metadata.clear(); |
269 Metadata.resize(Func->getNumVariables()); | 269 Metadata.resize(Func->getNumVariables()); |
270 | 270 |
271 // Mark implicit args as being used in the entry node. | 271 // Mark implicit args as being used in the entry node. |
272 for (Variable *Var : Func->getImplicitArgs()) { | 272 for (Variable *Var : Func->getImplicitArgs()) { |
273 const Inst *NoInst = NULL; | 273 const Inst *NoInst = nullptr; |
274 const CfgNode *EntryNode = Func->getEntryNode(); | 274 const CfgNode *EntryNode = Func->getEntryNode(); |
275 const bool IsFromDef = false; | 275 const bool IsFromDef = false; |
276 const bool IsImplicit = true; | 276 const bool IsImplicit = true; |
277 Metadata[Var->getIndex()] | 277 Metadata[Var->getIndex()] |
278 .markUse(Kind, NoInst, EntryNode, IsFromDef, IsImplicit); | 278 .markUse(Kind, NoInst, EntryNode, IsFromDef, IsImplicit); |
279 } | 279 } |
280 | 280 |
281 for (CfgNode *Node : Func->getNodes()) | 281 for (CfgNode *Node : Func->getNodes()) |
282 addNode(Node); | 282 addNode(Node); |
283 } | 283 } |
(...skipping 65 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
349 if (!isTracked(Var)) | 349 if (!isTracked(Var)) |
350 return true; // conservative answer | 350 return true; // conservative answer |
351 SizeT VarNum = Var->getIndex(); | 351 SizeT VarNum = Var->getIndex(); |
352 // Conservatively return true if the state is unknown. | 352 // Conservatively return true if the state is unknown. |
353 return Metadata[VarNum].getMultiBlock() != VariableTracking::MBS_SingleBlock; | 353 return Metadata[VarNum].getMultiBlock() != VariableTracking::MBS_SingleBlock; |
354 } | 354 } |
355 | 355 |
356 const Inst *VariablesMetadata::getFirstDefinition(const Variable *Var) const { | 356 const Inst *VariablesMetadata::getFirstDefinition(const Variable *Var) const { |
357 assert(Kind != VMK_Uses); | 357 assert(Kind != VMK_Uses); |
358 if (!isTracked(Var)) | 358 if (!isTracked(Var)) |
359 return NULL; // conservative answer | 359 return nullptr; // conservative answer |
360 SizeT VarNum = Var->getIndex(); | 360 SizeT VarNum = Var->getIndex(); |
361 return Metadata[VarNum].getFirstDefinition(); | 361 return Metadata[VarNum].getFirstDefinition(); |
362 } | 362 } |
363 | 363 |
364 const Inst *VariablesMetadata::getSingleDefinition(const Variable *Var) const { | 364 const Inst *VariablesMetadata::getSingleDefinition(const Variable *Var) const { |
365 assert(Kind != VMK_Uses); | 365 assert(Kind != VMK_Uses); |
366 if (!isTracked(Var)) | 366 if (!isTracked(Var)) |
367 return NULL; // conservative answer | 367 return nullptr; // conservative answer |
368 SizeT VarNum = Var->getIndex(); | 368 SizeT VarNum = Var->getIndex(); |
369 return Metadata[VarNum].getSingleDefinition(); | 369 return Metadata[VarNum].getSingleDefinition(); |
370 } | 370 } |
371 | 371 |
372 const InstDefList & | 372 const InstDefList & |
373 VariablesMetadata::getLatterDefinitions(const Variable *Var) const { | 373 VariablesMetadata::getLatterDefinitions(const Variable *Var) const { |
374 assert(Kind == VMK_All); | 374 assert(Kind == VMK_All); |
375 if (!isTracked(Var)) | 375 if (!isTracked(Var)) |
376 return NoDefinitions; | 376 return NoDefinitions; |
377 SizeT VarNum = Var->getIndex(); | 377 SizeT VarNum = Var->getIndex(); |
378 return Metadata[VarNum].getLatterDefinitions(); | 378 return Metadata[VarNum].getLatterDefinitions(); |
379 } | 379 } |
380 | 380 |
381 const CfgNode *VariablesMetadata::getLocalUseNode(const Variable *Var) const { | 381 const CfgNode *VariablesMetadata::getLocalUseNode(const Variable *Var) const { |
382 if (!isTracked(Var)) | 382 if (!isTracked(Var)) |
383 return NULL; // conservative answer | 383 return nullptr; // conservative answer |
384 SizeT VarNum = Var->getIndex(); | 384 SizeT VarNum = Var->getIndex(); |
385 return Metadata[VarNum].getNode(); | 385 return Metadata[VarNum].getNode(); |
386 } | 386 } |
387 | 387 |
388 const InstDefList VariablesMetadata::NoDefinitions; | 388 const InstDefList VariablesMetadata::NoDefinitions; |
389 | 389 |
390 // ======================== dump routines ======================== // | 390 // ======================== dump routines ======================== // |
391 | 391 |
392 void Variable::emit(const Cfg *Func) const { | 392 void Variable::emit(const Cfg *Func) const { |
393 if (ALLOW_DUMP) | 393 if (ALLOW_DUMP) |
394 Func->getTarget()->emitVariable(this); | 394 Func->getTarget()->emitVariable(this); |
395 } | 395 } |
396 | 396 |
397 void Variable::dump(const Cfg *Func, Ostream &Str) const { | 397 void Variable::dump(const Cfg *Func, Ostream &Str) const { |
398 if (!ALLOW_DUMP) | 398 if (!ALLOW_DUMP) |
399 return; | 399 return; |
400 if (Func == NULL) { | 400 if (Func == nullptr) { |
401 Str << "%" << getName(Func); | 401 Str << "%" << getName(Func); |
402 return; | 402 return; |
403 } | 403 } |
404 if (Func->getContext()->isVerbose(IceV_RegOrigins) || | 404 if (Func->getContext()->isVerbose(IceV_RegOrigins) || |
405 (!hasReg() && !Func->getTarget()->hasComputedFrame())) | 405 (!hasReg() && !Func->getTarget()->hasComputedFrame())) |
406 Str << "%" << getName(Func); | 406 Str << "%" << getName(Func); |
407 if (hasReg()) { | 407 if (hasReg()) { |
408 if (Func->getContext()->isVerbose(IceV_RegOrigins)) | 408 if (Func->getContext()->isVerbose(IceV_RegOrigins)) |
409 Str << ":"; | 409 Str << ":"; |
410 Str << Func->getTarget()->getRegName(RegNum, getType()); | 410 Str << Func->getTarget()->getRegName(RegNum, getType()); |
(...skipping 72 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
483 if (!ALLOW_DUMP) | 483 if (!ALLOW_DUMP) |
484 return Str; | 484 return Str; |
485 if (W.getWeight() == RegWeight::Inf) | 485 if (W.getWeight() == RegWeight::Inf) |
486 Str << "Inf"; | 486 Str << "Inf"; |
487 else | 487 else |
488 Str << W.getWeight(); | 488 Str << W.getWeight(); |
489 return Str; | 489 return Str; |
490 } | 490 } |
491 | 491 |
492 } // end of namespace Ice | 492 } // end of namespace Ice |
OLD | NEW |