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 /// \file | 10 /// \file |
(...skipping 238 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
249 // A phi source variable conservatively needs to be marked as multi-block, | 249 // A phi source variable conservatively needs to be marked as multi-block, |
250 // even if its definition is in the same block. This is because there can be | 250 // even if its definition is in the same block. This is because there can be |
251 // additional control flow before branching back to this node, and the | 251 // additional control flow before branching back to this node, and the |
252 // variable is live throughout those nodes. | 252 // variable is live throughout those nodes. |
253 if (Instr && llvm::isa<InstPhi>(Instr)) | 253 if (Instr && llvm::isa<InstPhi>(Instr)) |
254 MakeMulti = true; | 254 MakeMulti = true; |
255 | 255 |
256 if (!MakeMulti) { | 256 if (!MakeMulti) { |
257 switch (MultiBlock) { | 257 switch (MultiBlock) { |
258 case MBS_Unknown: | 258 case MBS_Unknown: |
| 259 case MBS_NoUses: |
259 MultiBlock = MBS_SingleBlock; | 260 MultiBlock = MBS_SingleBlock; |
260 SingleUseNode = Node; | 261 SingleUseNode = Node; |
261 break; | 262 break; |
262 case MBS_SingleBlock: | 263 case MBS_SingleBlock: |
263 if (SingleUseNode != Node) | 264 if (SingleUseNode != Node) |
264 MakeMulti = true; | 265 MakeMulti = true; |
265 break; | 266 break; |
266 case MBS_MultiBlock: | 267 case MBS_MultiBlock: |
267 break; | 268 break; |
268 } | 269 } |
(...skipping 94 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
363 assert(FirstOrSingleDefinition); | 364 assert(FirstOrSingleDefinition); |
364 return FirstOrSingleDefinition; | 365 return FirstOrSingleDefinition; |
365 } | 366 } |
366 return nullptr; | 367 return nullptr; |
367 } | 368 } |
368 | 369 |
369 void VariablesMetadata::init(MetadataKind TrackingKind) { | 370 void VariablesMetadata::init(MetadataKind TrackingKind) { |
370 TimerMarker T(TimerStack::TT_vmetadata, Func); | 371 TimerMarker T(TimerStack::TT_vmetadata, Func); |
371 Kind = TrackingKind; | 372 Kind = TrackingKind; |
372 Metadata.clear(); | 373 Metadata.clear(); |
373 Metadata.resize(Func->getNumVariables()); | 374 Metadata.resize(Func->getNumVariables(), VariableTracking::MBS_NoUses); |
374 | 375 |
375 // Mark implicit args as being used in the entry node. | 376 // Mark implicit args as being used in the entry node. |
376 for (Variable *Var : Func->getImplicitArgs()) { | 377 for (Variable *Var : Func->getImplicitArgs()) { |
377 constexpr Inst *NoInst = nullptr; | 378 constexpr Inst *NoInst = nullptr; |
378 CfgNode *EntryNode = Func->getEntryNode(); | 379 CfgNode *EntryNode = Func->getEntryNode(); |
379 constexpr bool IsImplicit = true; | 380 constexpr bool IsImplicit = true; |
380 Metadata[Var->getIndex()].markUse(Kind, NoInst, EntryNode, IsImplicit); | 381 Metadata[Var->getIndex()].markUse(Kind, NoInst, EntryNode, IsImplicit); |
381 } | 382 } |
382 | 383 |
383 for (CfgNode *Node : Func->getNodes()) | 384 for (CfgNode *Node : Func->getNodes()) |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
432 if (!isTracked(Var)) | 433 if (!isTracked(Var)) |
433 return true; // conservative answer | 434 return true; // conservative answer |
434 SizeT VarNum = Var->getIndex(); | 435 SizeT VarNum = Var->getIndex(); |
435 // Conservatively return true if the state is unknown. | 436 // Conservatively return true if the state is unknown. |
436 return Metadata[VarNum].getMultiDef() != VariableTracking::MDS_SingleDef; | 437 return Metadata[VarNum].getMultiDef() != VariableTracking::MDS_SingleDef; |
437 } | 438 } |
438 | 439 |
439 bool VariablesMetadata::isMultiBlock(const Variable *Var) const { | 440 bool VariablesMetadata::isMultiBlock(const Variable *Var) const { |
440 if (Var->getIsArg()) | 441 if (Var->getIsArg()) |
441 return true; | 442 return true; |
| 443 if (Var->isRematerializable()) |
| 444 return false; |
442 if (!isTracked(Var)) | 445 if (!isTracked(Var)) |
443 return true; // conservative answer | 446 return true; // conservative answer |
444 SizeT VarNum = Var->getIndex(); | 447 SizeT VarNum = Var->getIndex(); |
| 448 switch (Metadata[VarNum].getMultiBlock()) { |
| 449 case VariableTracking::MBS_NoUses: |
| 450 case VariableTracking::MBS_SingleBlock: |
| 451 return false; |
445 // Conservatively return true if the state is unknown. | 452 // Conservatively return true if the state is unknown. |
446 return Metadata[VarNum].getMultiBlock() != VariableTracking::MBS_SingleBlock; | 453 case VariableTracking::MBS_Unknown: |
| 454 case VariableTracking::MBS_MultiBlock: |
| 455 return true; |
| 456 } |
| 457 assert(0); |
| 458 return true; |
| 459 } |
| 460 |
| 461 bool VariablesMetadata::isSingleBlock(const Variable *Var) const { |
| 462 if (Var->getIsArg()) |
| 463 return false; |
| 464 if (Var->isRematerializable()) |
| 465 return false; |
| 466 if (!isTracked(Var)) |
| 467 return false; // conservative answer |
| 468 SizeT VarNum = Var->getIndex(); |
| 469 switch (Metadata[VarNum].getMultiBlock()) { |
| 470 case VariableTracking::MBS_SingleBlock: |
| 471 return true; |
| 472 case VariableTracking::MBS_Unknown: |
| 473 case VariableTracking::MBS_NoUses: |
| 474 case VariableTracking::MBS_MultiBlock: |
| 475 return false; |
| 476 } |
| 477 assert(0); |
| 478 return false; |
447 } | 479 } |
448 | 480 |
449 const Inst * | 481 const Inst * |
450 VariablesMetadata::getFirstDefinitionSingleBlock(const Variable *Var) const { | 482 VariablesMetadata::getFirstDefinitionSingleBlock(const Variable *Var) const { |
451 assert(Kind != VMK_Uses); | 483 assert(Kind != VMK_Uses); |
452 if (!isTracked(Var)) | 484 if (!isTracked(Var)) |
453 return nullptr; // conservative answer | 485 return nullptr; // conservative answer |
454 SizeT VarNum = Var->getIndex(); | 486 SizeT VarNum = Var->getIndex(); |
455 return Metadata[VarNum].getFirstDefinitionSingleBlock(); | 487 return Metadata[VarNum].getFirstDefinitionSingleBlock(); |
456 } | 488 } |
(...skipping 162 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
619 if (getType() != IceType_i32 && getType() != IceType_i16 && | 651 if (getType() != IceType_i32 && getType() != IceType_i16 && |
620 getType() != IceType_i8) | 652 getType() != IceType_i8) |
621 return false; | 653 return false; |
622 // The Following checks if the signed representation of Value is between | 654 // The Following checks if the signed representation of Value is between |
623 // -Threshold/2 and +Threshold/2 | 655 // -Threshold/2 and +Threshold/2 |
624 bool largerThanThreshold = Threshold / 2 + Value >= Threshold; | 656 bool largerThanThreshold = Threshold / 2 + Value >= Threshold; |
625 return largerThanThreshold; | 657 return largerThanThreshold; |
626 } | 658 } |
627 | 659 |
628 } // end of namespace Ice | 660 } // end of namespace Ice |
OLD | NEW |