<div dir="ltr">Krzysztof,<br><div><br></div><div>I think it breaks build bots:</div><div><br></div><div><a href="http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-bootstrap/builds/12555">http://lab.llvm.org:8011/builders/sanitizer-x86_64-linux-bootstrap/builds/12555</a><br></div><div><br></div><div><div>/mnt/b/sanitizer-buildbot2/sanitizer-x86_64-linux-bootstrap/build/llvm/lib/Target/Hexagon/HexagonConstPropagation.cpp:2052:26: runtime error: left shift of negative value -2</div><div>  Â  #0 0x1010d5d in (anonymous namespace)::HexagonConstEvaluator::evaluate(llvm::MachineInstr const&, (anonymous namespace)::MachineConstPropagator::CellMap const&, (anonymous namespace)::MachineConstPropagator::CellMap&) /mnt/b/sanitizer-buildbot2/sanitizer-x86_64-linux-bootstrap/build/llvm/lib/Target/Hexagon/HexagonConstPropagation.cpp:2052:26</div><div>  Â  #1 0x101ec38 in (anonymous namespace)::MachineConstPropagator::visitNonBranch(llvm::MachineInstr const&) /mnt/b/sanitizer-buildbot2/sanitizer-x86_64-linux-bootstrap/build/llvm/lib/Target/Hexagon/HexagonConstPropagation.cpp:652:19</div><div>  Â  #2 0x101d238 in (anonymous namespace)::MachineConstPropagator::propagate(llvm::MachineFunction&) /mnt/b/sanitizer-buildbot2/sanitizer-x86_64-linux-bootstrap/build/llvm/lib/Target/Hexagon/HexagonConstPropagation.cpp:906:9</div><div>  Â  #3 0x100f8be in (anonymous namespace)::MachineConstPropagator::run(llvm::MachineFunction&) /mnt/b/sanitizer-buildbot2/sanitizer-x86_64-linux-bootstrap/build/llvm/lib/Target/Hexagon/HexagonConstPropagation.cpp:1051:3</div><div>  Â  #4 0x100f4ca in (anonymous namespace)::HexagonConstPropagation::runOnMachineFunction(llvm::MachineFunction&) /mnt/b/sanitizer-buildbot2/sanitizer-x86_64-linux-bootstrap/build/llvm/lib/Target/Hexagon/HexagonConstPropagation.cpp:1924:42</div><div>  Â  #5 0x1de4382 in llvm::MachineFunctionPass::runOnFunction(llvm::Function&) /mnt/b/sanitizer-buildbot2/sanitizer-x86_64-linux-bootstrap/build/llvm/lib/CodeGen/MachineFunctionPass.cpp:60:13</div><div>  Â  #6 0x22b341e in llvm::FPPassManager::runOnFunction(llvm::Function&) /mnt/b/sanitizer-buildbot2/sanitizer-x86_64-linux-bootstrap/build/llvm/lib/IR/LegacyPassManager.cpp:1526:27</div><div>  Â  #7 0x22b380b in llvm::FPPassManager::runOnModule(llvm::Module&) /mnt/b/sanitizer-buildbot2/sanitizer-x86_64-linux-bootstrap/build/llvm/lib/IR/LegacyPassManager.cpp:1547:16</div><div>  Â  #8 0x22b4323 in (anonymous namespace)::MPPassManager::runOnModule(llvm::Module&) /mnt/b/sanitizer-buildbot2/sanitizer-x86_64-linux-bootstrap/build/llvm/lib/IR/LegacyPassManager.cpp:1603:27</div><div>  Â  #9 0x22b3c53 in llvm::legacy::PassManagerImpl::run(llvm::Module&) /mnt/b/sanitizer-buildbot2/sanitizer-x86_64-linux-bootstrap/build/llvm/lib/IR/LegacyPassManager.cpp:1706:44</div><div>  Â  #10 0x8b2418 in compileModule(char**, llvm::LLVMContext&) /mnt/b/sanitizer-buildbot2/sanitizer-x86_64-linux-bootstrap/build/llvm/tools/llc/llc.cpp:497:8</div><div>  Â  #11 0x8b128a in main /mnt/b/sanitizer-buildbot2/sanitizer-x86_64-linux-bootstrap/build/llvm/tools/llc/llc.cpp:265:22</div><div>  Â  #12 0x7efd4f842f44 in __libc_start_main (/lib/x86_64-linux-gnu/libc.so.6+0x21f44)</div><div>  Â  #13 0x88af8d in _start (/mnt/b/sanitizer-buildbot2/sanitizer-x86_64-linux-bootstrap/build/llvm_build_ubsan/bin/llc+0x88af8d)</div><div><br></div></div></div><br><div class="gmail_quote"><div dir="ltr">On Thu, Jul 28, 2016 at 1:09 PM Krzysztof Parzyszek via llvm-commits <<a href="mailto:llvm-commits@lists.llvm.org">llvm-commits@lists.llvm.org</a>> wrote:<br></div><blockquote class="gmail_quote" style="margin:0 0 0 .8ex;border-left:1px #ccc solid;padding-left:1ex">Author: kparzysz<br>
Date: Thu Jul 28 15:01:59 2016<br>
New Revision: 277028<br>
<br>
URL: <a href="http://llvm.org/viewvc/llvm-project?rev=277028&view=rev" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project?rev=277028&view=rev</a><br>
Log:<br>
[Hexagon] Implement MI-level constant propagation<br>
<br>
Added:<br>
  Â  llvm/trunk/lib/Target/Hexagon/HexagonConstPropagation.cpp<br>
  Â  llvm/trunk/test/CodeGen/Hexagon/constp-clb.ll<br>
  Â  llvm/trunk/test/CodeGen/Hexagon/constp-combine-neg.ll<br>
  Â  llvm/trunk/test/CodeGen/Hexagon/constp-ctb.ll<br>
  Â  llvm/trunk/test/CodeGen/Hexagon/constp-extract.ll<br>
  Â  llvm/trunk/test/CodeGen/Hexagon/constp-physreg.ll<br>
  Â  llvm/trunk/test/CodeGen/Hexagon/constp-rewrite-branches.ll<br>
  Â  llvm/trunk/test/CodeGen/Hexagon/constp-rseq.ll<br>
  Â  llvm/trunk/test/CodeGen/Hexagon/constp-vsplat.ll<br>
Modified:<br>
  Â  llvm/trunk/lib/Target/Hexagon/CMakeLists.txt<br>
  Â  llvm/trunk/lib/Target/Hexagon/HexagonTargetMachine.cpp<br>
  Â  llvm/trunk/test/CodeGen/Hexagon/vect/vect-vsplatb.ll<br>
  Â  llvm/trunk/test/CodeGen/Hexagon/vect/vect-vsplath.ll<br>
<br>
Modified: llvm/trunk/lib/Target/Hexagon/CMakeLists.txt<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/Hexagon/CMakeLists.txt?rev=277028&r1=277027&r2=277028&view=diff" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/Hexagon/CMakeLists.txt?rev=277028&r1=277027&r2=277028&view=diff</a><br>
==============================================================================<br>
--- llvm/trunk/lib/Target/Hexagon/CMakeLists.txt (original)<br>
+++ llvm/trunk/lib/Target/Hexagon/CMakeLists.txt Thu Jul 28 15:01:59 2016<br>
@@ -21,6 +21,7 @@ add_llvm_target(HexagonCodeGen<br>
  Â HexagonBranchRelaxation.cpp<br>
  Â HexagonCFGOptimizer.cpp<br>
  Â HexagonCommonGEP.cpp<br>
+  HexagonConstPropagation.cpp<br>
  Â HexagonCopyToCombine.cpp<br>
  Â HexagonEarlyIfConv.cpp<br>
  Â HexagonExpandCondsets.cpp<br>
<br>
Added: llvm/trunk/lib/Target/Hexagon/HexagonConstPropagation.cpp<br>
URL: <a href="http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/Hexagon/HexagonConstPropagation.cpp?rev=277028&view=auto" rel="noreferrer" target="_blank">http://llvm.org/viewvc/llvm-project/llvm/trunk/lib/Target/Hexagon/HexagonConstPropagation.cpp?rev=277028&view=auto</a><br>
==============================================================================<br>
--- llvm/trunk/lib/Target/Hexagon/HexagonConstPropagation.cpp (added)<br>
+++ llvm/trunk/lib/Target/Hexagon/HexagonConstPropagation.cpp Thu Jul 28 15:01:59 2016<br>
@@ -0,0 +1,3208 @@<br>
+//===--- HexagonConstPropagation.cpp --------------------------------------===//<br>
+//<br>
+//  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â The LLVM Compiler Infrastructure<br>
+//<br>
+// This file is distributed under the University of Illinois Open Source<br>
+// License. See LICENSE.TXT for details.<br>
+//<br>
+//===----------------------------------------------------------------------===//<br>
+<br>
+#define DEBUG_TYPE "hcp"<br>
+<br>
+#include "HexagonInstrInfo.h"<br>
+#include "HexagonRegisterInfo.h"<br>
+#include "HexagonSubtarget.h"<br>
+<br>
+#include "llvm/ADT/PostOrderIterator.h"<br>
+#include "llvm/ADT/SetVector.h"<br>
+#include "llvm/CodeGen/MachineFunction.h"<br>
+#include "llvm/CodeGen/MachineFunctionPass.h"<br>
+#include "llvm/CodeGen/MachineInstrBuilder.h"<br>
+#include "llvm/CodeGen/MachineRegisterInfo.h"<br>
+#include "llvm/IR/Constants.h"<br>
+#include "llvm/Support/CommandLine.h"<br>
+#include "llvm/Support/Debug.h"<br>
+#include "llvm/Support/raw_ostream.h"<br>
+#include "llvm/Target/TargetInstrInfo.h"<br>
+<br>
+#include <map><br>
+#include <queue><br>
+#include <set><br>
+<br>
+using namespace llvm;<br>
+<br>
+namespace {<br>
+  class LatticeCell;<br>
+<br>
+  // Properties of a value that are tracked by the propagation.<br>
+  // A property that is marked as present (i.e. bit is set) dentes that the<br>
+  // value is known (proven) to have this property. Not all combinations<br>
+  // of bits make sense, for example Zero and NonZero are mutually exclusive,<br>
+  // but on the other hand, Zero implies Finite. In this case, whenever<br>
+  // the Zero property is present, Finite should also be present.<br>
+  class ConstantProperties {<br>
+  public:<br>
+  Â  enum {<br>
+  Â  Â  Unknown  Â = 0x0000,<br>
+  Â  Â  Zero  Â  Â  = 0x0001,<br>
+  Â  Â  NonZero  Â = 0x0002,<br>
+  Â  Â  Finite  Â  = 0x0004,<br>
+  Â  Â  Infinity  = 0x0008,<br>
+  Â  Â  NaN  Â  Â  Â = 0x0010,<br>
+  Â  Â  SignedZero = 0x0020,<br>
+  Â  Â  NumericProperties = (Zero|NonZero|Finite|Infinity|NaN|SignedZero),<br>
+  Â  Â  PosOrZero  Â  Â  Â = 0x0100,<br>
+  Â  Â  NegOrZero  Â  Â  Â = 0x0200,<br>
+  Â  Â  SignProperties  = (PosOrZero|NegOrZero),<br>
+  Â  Â  Everything  Â  Â  = (NumericProperties|SignProperties)<br>
+  Â  };<br>
+<br>
+  Â  // For a given constant, deduce the set of trackable properties that this<br>
+  Â  // constant has.<br>
+  Â  static uint32_t deduce(const Constant *C);<br>
+  };<br>
+<br>
+<br>
+  // A representation of a register as it can appear in a MachineOperand,<br>
+  // i.e. a pair register:subregister.<br>
+  struct Register {<br>
+  Â  unsigned Reg, SubReg;<br>
+  Â  explicit Register(unsigned R, unsigned SR = 0) : Reg(R), SubReg(SR) {}<br>
+  Â  explicit Register(const MachineOperand &MO)<br>
+  Â  Â  : Reg(MO.getReg()), SubReg(MO.getSubReg()) {}<br>
+  Â  void print(const TargetRegisterInfo *TRI = 0) const {<br>
+  Â  Â  dbgs() << PrintReg(Reg, TRI, SubReg);<br>
+  Â  }<br>
+  Â  bool operator== (const Register &R) const {<br>
+  Â  Â  return (Reg == R.Reg) && (SubReg == R.SubReg);<br>
+  Â  }<br>
+  };<br>
+<br>
+<br>
+  // Lattice cell, based on that was described in the W-Z paper on constant<br>
+  // propagation.<br>
+  // Latice cell will be allowed to hold multiple constant values. While<br>
+  // multiple values would normally indicate "bottom", we can still derive<br>
+  // some useful information from them. For example, comparison X > 0<br>
+  // could be folded if all the values in the cell associated with X are<br>
+  // positive.<br>
+  class LatticeCell {<br>
+  private:<br>
+  Â  enum { Normal, Top, Bottom };<br>
+  Â  static const unsigned MaxCellSize = 4;<br>
+  Â  unsigned Kind:2;<br>
+  Â  unsigned Size:3;<br>
+  Â  unsigned IsSpecial:1;<br>
+  Â  unsigned :0;<br>
+<br>
+  public:<br>
+  Â  union {<br>
+  Â  Â  uint32_t Properties;<br>
+  Â  Â  const Constant *Value;<br>
+  Â  Â  const Constant *Values[MaxCellSize];<br>
+  Â  };<br>
+<br>
+  Â  LatticeCell() : Kind(Top), Size(0), IsSpecial(false) {<br>
+  Â  Â  for (unsigned i = 0; i < MaxCellSize; ++i)<br>
+  Â  Â  Â  Values[i] = 0;<br>
+  Â  }<br>
+<br>
+  Â  bool meet(const LatticeCell &L);<br>
+  Â  bool add(const Constant *C);<br>
+  Â  bool add(uint32_t Property);<br>
+  Â  uint32_t properties() const;<br>
+  Â  unsigned size() const { return Size; }<br>
+<br>
+  Â  LatticeCell &operator= (const LatticeCell &L) {<br>
+  Â  Â  if (this != &L) {<br>
+  Â  Â  Â  // This memcpy also copies Properties (when L.Size == 0).<br>
+  Â  Â  Â  uint32_t N = L.IsSpecial ? sizeof L.Properties<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â : L.Size*sizeof(const Constant*);<br>
+  Â  Â  Â  memcpy(Values, L.Values, N);<br>
+  Â  Â  Â  Kind = L.Kind;<br>
+  Â  Â  Â  Size = L.Size;<br>
+  Â  Â  Â  IsSpecial = L.IsSpecial;<br>
+  Â  Â  }<br>
+  Â  Â  return *this;<br>
+  Â  }<br>
+<br>
+  Â  bool isSingle() const { return size() == 1; }<br>
+  Â  bool isProperty() const { return IsSpecial; }<br>
+  Â  bool isTop() const { return Kind == Top; }<br>
+  Â  bool isBottom() const { return Kind == Bottom; }<br>
+  Â  bool setBottom() {<br>
+  Â  Â  bool Changed = (Kind != Bottom);<br>
+  Â  Â  Kind = Bottom;<br>
+  Â  Â  Size = 0;<br>
+  Â  Â  IsSpecial = false;<br>
+  Â  Â  return Changed;<br>
+  Â  }<br>
+  Â  void print(raw_ostream &os) const;<br>
+<br>
+  private:<br>
+  Â  void setProperty() {<br>
+  Â  Â  IsSpecial = true;<br>
+  Â  Â  Size = 0;<br>
+  Â  Â  Kind = Normal;<br>
+  Â  }<br>
+  Â  bool convertToProperty();<br>
+  };<br>
+<br>
+  raw_ostream &operator<< (raw_ostream &os, const LatticeCell &L) {<br>
+  Â  L.print(os);<br>
+  Â  return os;<br>
+  }<br>
+<br>
+  class MachineConstEvaluator;<br>
+<br>
+  class MachineConstPropagator {<br>
+  public:<br>
+  Â  MachineConstPropagator(MachineConstEvaluator &E) : MCE(E) {<br>
+  Â  Â  Bottom.setBottom();<br>
+  Â  }<br>
+<br>
+  Â  // Mapping: vreg -> cell<br>
+  Â  // The keys are registers _without_ subregisters. This won't allow<br>
+  Â  // definitions in the form of "vreg:subreg<def> = ...". Such definitions<br>
+  Â  // would be questionable from the point of view of SSA, since the "vreg"<br>
+  Â  // could not be initialized in its entirety (specifically, an instruction<br>
+  Â  // defining the "other part" of "vreg" would also count as a definition<br>
+  Â  // of "vreg", which would violate the SSA).<br>
+  Â  // If a value of a pair vreg:subreg needs to be obtained, the cell for<br>
+  Â  // "vreg" needs to be looked up, and then the value of subregister "subreg"<br>
+  Â  // needs to be evaluated.<br>
+  Â  class CellMap {<br>
+  Â  public:<br>
+  Â  Â  CellMap() {<br>
+  Â  Â  Â  assert(Top.isTop());<br>
+  Â  Â  Â  Bottom.setBottom();<br>
+  Â  Â  }<br>
+  Â  Â  void clear() { Map.clear(); }<br>
+  Â  Â  bool has(unsigned R) const {<br>
+  Â  Â  Â  // All non-virtual registers are considered "bottom".<br>
+  Â  Â  Â  if (!TargetRegisterInfo::isVirtualRegister(R))<br>
+  Â  Â  Â  Â  return true;<br>
+  Â  Â  Â  MapType::const_iterator F = Map.find(R);<br>
+  Â  Â  Â  return F != Map.end();<br>
+  Â  Â  }<br>
+  Â  Â  const LatticeCell &get(unsigned R) const {<br>
+  Â  Â  Â  if (!TargetRegisterInfo::isVirtualRegister(R))<br>
+  Â  Â  Â  Â  return Bottom;<br>
+  Â  Â  Â  MapType::const_iterator F = Map.find(R);<br>
+  Â  Â  Â  if (F != Map.end())<br>
+  Â  Â  Â  Â  return F->second;<br>
+  Â  Â  Â  return Top;<br>
+  Â  Â  }<br>
+  Â  Â  // Invalidates any const references.<br>
+  Â  Â  void update(unsigned R, const LatticeCell &L) {<br>
+  Â  Â  Â  Map[R] = L;<br>
+  Â  Â  }<br>
+  Â  Â  void print(raw_ostream &os, const TargetRegisterInfo &TRI) const;<br>
+  Â  private:<br>
+  Â  Â  typedef std::map<unsigned,LatticeCell> MapType;<br>
+  Â  Â  MapType Map;<br>
+  Â  Â  // To avoid creating "top" entries, return a const reference to<br>
+  Â  Â  // this cell in "get". Also, have a "Bottom" cell to return from<br>
+  Â  Â  // get when a value of a physical register is requested.<br>
+  Â  Â  LatticeCell Top, Bottom;<br>
+  Â  public:<br>
+  Â  Â  typedef MapType::const_iterator const_iterator;<br>
+  Â  Â  const_iterator begin() const { return Map.begin(); }<br>
+  Â  Â  const_iterator end() const { return Map.end(); }<br>
+  Â  };<br>
+<br>
+  Â  bool run(MachineFunction &MF);<br>
+<br>
+  private:<br>
+  Â  void visitPHI(const MachineInstr &PN);<br>
+  Â  void visitNonBranch(const MachineInstr &MI);<br>
+  Â  void visitBranchesFrom(const MachineInstr &BrI);<br>
+  Â  void visitUsesOf(unsigned R);<br>
+  Â  bool isExecutable(const MachineBasicBlock *MB) const;<br>
+  Â  void pushLayoutSuccessor(const MachineBasicBlock *MB);<br>
+  Â  bool computeBlockSuccessors(const MachineBasicBlock *MB,<br>
+  Â  Â  Â  Â  SetVector<const MachineBasicBlock*> &Targets);<br>
+  Â  void removeCFGEdge(MachineBasicBlock *From, MachineBasicBlock *To);<br>
+<br>
+  Â  void propagate(MachineFunction &MF);<br>
+  Â  bool rewrite(MachineFunction &MF);<br>
+<br>
+  Â  MachineRegisterInfo  Â  Â  *MRI;<br>
+  Â  MachineConstEvaluator  Â  &MCE;<br>
+<br>
+  Â  typedef std::pair<unsigned,unsigned> CFGEdge;<br>
+  Â  typedef std::set<CFGEdge> SetOfCFGEdge;<br>
+  Â  typedef std::set<const MachineInstr*> SetOfInstr;<br>
+  Â  typedef std::queue<CFGEdge> QueueOfCFGEdge;<br>
+<br>
+  Â  LatticeCell  Â  Â Bottom;<br>
+  Â  CellMap  Â  Â  Â  Â Cells;<br>
+  Â  SetOfCFGEdge  Â  EdgeExec;<br>
+  Â  SetOfInstr  Â  Â  InstrExec;<br>
+  Â  QueueOfCFGEdge  FlowQ;<br>
+  };<br>
+<br>
+<br>
+  // The "evaluator/rewriter" of machine instructions. This is an abstract<br>
+  // base class that provides the interface that the propagator will use,<br>
+  // as well as some helper functions that are target-independent.<br>
+  class MachineConstEvaluator {<br>
+  public:<br>
+  Â  MachineConstEvaluator(MachineFunction &Fn)<br>
+  Â  Â  : TRI(*Fn.getSubtarget().getRegisterInfo()),<br>
+  Â  Â  Â  MF(Fn), CX(Fn.getFunction()->getContext()) {}<br>
+  Â  virtual ~MachineConstEvaluator() {}<br>
+<br>
+  Â  // The required interface:<br>
+  Â  // - A set of three "evaluate" functions. Each returns "true" if the<br>
+  Â  //  Â  Â  Â computation succeeded, "false" otherwise.<br>
+  Â  //  Â (1) Given an instruction MI, and the map with input values "Inputs",<br>
+  Â  //  Â  Â  Â compute the set of output values "Outputs". An example of when<br>
+  Â  //  Â  Â  Â the computation can "fail" is if MI is not an instruction that<br>
+  Â  //  Â  Â  Â is recognized by the evaluator.<br>
+  Â  //  Â (2) Given a register R (as reg:subreg), compute the cell that<br>
+  Â  //  Â  Â  Â corresponds to the "subreg" part of the given register.<br>
+  Â  //  Â (3) Given a branch instruction BrI, compute the set of target blocks.<br>
+  Â  //  Â  Â  Â If the branch can fall-through, add null (0) to the list of<br>
+  Â  //  Â  Â  Â possible targets.<br>
+  Â  // - A function "rewrite", that given the cell map after propagation,<br>
+  Â  //  Â could rewrite instruction MI in a more beneficial form. Return<br>
+  Â  //  Â "true" if a change has been made, "false" otherwise.<br>
+  Â  typedef MachineConstPropagator::CellMap CellMap;<br>
+  Â  virtual bool evaluate(const MachineInstr &MI, const CellMap &Inputs,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  CellMap &Outputs) = 0;<br>
+  Â  virtual bool evaluate(const Register &R, const LatticeCell &SrcC,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  LatticeCell &Result) = 0;<br>
+  Â  virtual bool evaluate(const MachineInstr &BrI, const CellMap &Inputs,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  SetVector<const MachineBasicBlock*> &Targets,<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  bool &CanFallThru) = 0;<br>
+  Â  virtual bool rewrite(MachineInstr &MI, const CellMap &Inputs) = 0;<br>
+<br>
+  Â  const TargetRegisterInfo &TRI;<br>
+<br>
+  protected:<br>
+  Â  MachineFunction &MF;<br>
+  Â  LLVMContext  Â  Â &CX;<br>
+<br>
+  Â  struct Comparison {<br>
+  Â  Â  enum {<br>
+  Â  Â  Â  Unk = 0x00,<br>
+  Â  Â  Â  EQ  = 0x01,<br>
+  Â  Â  Â  NE  = 0x02,<br>
+  Â  Â  Â  L  Â = 0x04, // Less-than property.<br>
+  Â  Â  Â  G  Â = 0x08, // Greater-than property.<br>
+  Â  Â  Â  U  Â = 0x40, // Unsigned property.<br>
+  Â  Â  Â  LTs = L,<br>
+  Â  Â  Â  LEs = L | EQ,<br>
+  Â  Â  Â  GTs = G,<br>
+  Â  Â  Â  GEs = G | EQ,<br>
+  Â  Â  Â  LTu = L  Â  Â  | U,<br>
+  Â  Â  Â  LEu = L | EQ | U,<br>
+  Â  Â  Â  GTu = G  Â  Â  | U,<br>
+  Â  Â  Â  GEu = G | EQ | U<br>
+  Â  Â  };<br>
+  Â  Â  static uint32_t negate(uint32_t Cmp) {<br>
+  Â  Â  Â  if (Cmp == EQ)<br>
+  Â  Â  Â  Â  return NE;<br>
+  Â  Â  Â  if (Cmp == NE)<br>
+  Â  Â  Â  Â  return EQ;<br>
+  Â  Â  Â  assert((Cmp & (L|G)) != (L|G));<br>
+  Â  Â  Â  return Cmp ^ (L|G);<br>
+  Â  Â  }<br>
+  Â  };<br>
+<br>
+  Â  // Helper functions.<br>
+<br>
+  Â  bool getCell(const Register &R, const CellMap &Inputs, LatticeCell &RC);<br>
+  Â  bool constToInt(const Constant *C, APInt &Val) const;<br>
+  Â  bool constToFloat(const Constant *C, APFloat &Val) const;<br>
+  Â  const ConstantInt *intToConst(const APInt &Val) const;<br>
+<br>
+  Â  // Compares.<br>
+  Â  bool evaluateCMPrr(uint32_t Cmp, const Register &R1, const Register &R2,<br>
+  Â  Â  Â  Â  const CellMap &Inputs, bool &Result);<br>
+  Â  bool evaluateCMPri(uint32_t Cmp, const Register &R1, const APInt &A2,<br>
+  Â  Â  Â  Â  const CellMap &Inputs, bool &Result);<br>
+  Â  bool evaluateCMPrp(uint32_t Cmp, const Register &R1, uint64_t Props2,<br>
+  Â  Â  Â  Â  const CellMap &Inputs, bool &Result);<br>
+  Â  bool evaluateCMPii(uint32_t Cmp, const APInt &A1, const APInt &A2,<br>
+  Â  Â  Â  Â  bool &Result);<br>
+  Â  bool evaluateCMPpi(uint32_t Cmp, uint32_t Props, const APInt &A2,<br>
+  Â  Â  Â  Â  bool &Result);<br>
+  Â  bool evaluateCMPpp(uint32_t Cmp, uint32_t Props1, uint32_t Props2,<br>
+  Â  Â  Â  Â  bool &Result);<br>
+<br>
+  Â  bool evaluateCOPY(const Register &R1, const CellMap &Inputs,<br>
+  Â  Â  Â  Â  LatticeCell &Result);<br>
+<br>
+  Â  // Logical operations.<br>
+  Â  bool evaluateANDrr(const Register &R1, const Register &R2,<br>
+  Â  Â  Â  Â  const CellMap &Inputs, LatticeCell &Result);<br>
+  Â  bool evaluateANDri(const Register &R1, const APInt &A2,<br>
+  Â  Â  Â  Â  const CellMap &Inputs, LatticeCell &Result);<br>
+  Â  bool evaluateANDii(const APInt &A1, const APInt &A2, APInt &Result);<br>
+  Â  bool evaluateORrr(const Register &R1, const Register &R2,<br>
+  Â  Â  Â  Â  const CellMap &Inputs, LatticeCell &Result);<br>
+  Â  bool evaluateORri(const Register &R1, const APInt &A2,<br>
+  Â  Â  Â  Â  const CellMap &Inputs, LatticeCell &Result);<br>
+  Â  bool evaluateORii(const APInt &A1, const APInt &A2, APInt &Result);<br>
+  Â  bool evaluateXORrr(const Register &R1, const Register &R2,<br>
+  Â  Â  Â  Â  const CellMap &Inputs, LatticeCell &Result);<br>
+  Â  bool evaluateXORri(const Register &R1, const APInt &A2,<br>
+  Â  Â  Â  Â  const CellMap &Inputs, LatticeCell &Result);<br>
+  Â  bool evaluateXORii(const APInt &A1, const APInt &A2, APInt &Result);<br>
+<br>
+  Â  // Extensions.<br>
+  Â  bool evaluateZEXTr(const Register &R1, unsigned Width, unsigned Bits,<br>
+  Â  Â  Â  Â  const CellMap &Inputs, LatticeCell &Result);<br>
+  Â  bool evaluateZEXTi(const APInt &A1, unsigned Width, unsigned Bits,<br>
+  Â  Â  Â  Â  APInt &Result);<br>
+  Â  bool evaluateSEXTr(const Register &R1, unsigned Width, unsigned Bits,<br>
+  Â  Â  Â  Â  const CellMap &Inputs, LatticeCell &Result);<br>
+  Â  bool evaluateSEXTi(const APInt &A1, unsigned Width, unsigned Bits,<br>
+  Â  Â  Â  Â  APInt &Result);<br>
+<br>
+  Â  // Leading/trailing bits.<br>
+  Â  bool evaluateCLBr(const Register &R1, bool Zeros, bool Ones,<br>
+  Â  Â  Â  Â  const CellMap &Inputs, LatticeCell &Result);<br>
+  Â  bool evaluateCLBi(const APInt &A1, bool Zeros, bool Ones, APInt &Result);<br>
+  Â  bool evaluateCTBr(const Register &R1, bool Zeros, bool Ones,<br>
+  Â  Â  Â  Â  const CellMap &Inputs, LatticeCell &Result);<br>
+  Â  bool evaluateCTBi(const APInt &A1, bool Zeros, bool Ones, APInt &Result);<br>
+<br>
+  Â  // Bitfield extract.<br>
+  Â  bool evaluateEXTRACTr(const Register &R1, unsigned Width, unsigned Bits,<br>
+  Â  Â  Â  Â  unsigned Offset, bool Signed, const CellMap &Inputs,<br>
+  Â  Â  Â  Â  LatticeCell &Result);<br>
+  Â  bool evaluateEXTRACTi(const APInt &A1, unsigned Bits, unsigned Offset,<br>
+  Â  Â  Â  Â  bool Signed, APInt &Result);<br>
+  Â  // Vector operations.<br>
+  Â  bool evaluateSplatr(const Register &R1, unsigned Bits, unsigned Count,<br>
+  Â  Â  Â  Â  const CellMap &Inputs, LatticeCell &Result);<br>
+  Â  bool evaluateSplati(const APInt &A1, unsigned Bits, unsigned Count,<br>
+  Â  Â  Â  Â  APInt &Result);<br>
+  };<br>
+<br>
+}<br>
+<br>
+uint32_t ConstantProperties::deduce(const Constant *C) {<br>
+  if (isa<ConstantInt>(C)) {<br>
+  Â  const ConstantInt *CI = cast<ConstantInt>(C);<br>
+  Â  if (CI->isZero())<br>
+  Â  Â  return Zero | PosOrZero | NegOrZero | Finite;<br>
+  Â  uint32_t Props = (NonZero | Finite);<br>
+  Â  if (CI->isNegative())<br>
+  Â  Â  return Props | NegOrZero;<br>
+  Â  return Props | PosOrZero;<br>
+  }<br>
+<br>
+  if (isa<ConstantFP>(C)) {<br>
+  Â  const ConstantFP *CF = cast<ConstantFP>(C);<br>
+  Â  uint32_t Props = CF->isNegative() ? (NegOrZero|NonZero)<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  : PosOrZero;<br>
+  Â  if (CF->isZero())<br>
+  Â  Â  return (Props & ~NumericProperties) | (Zero|Finite);<br>
+  Â  Props = (Props & ~NumericProperties) | NonZero;<br>
+  Â  if (CF->isNaN())<br>
+  Â  Â  return (Props & ~NumericProperties) | NaN;<br>
+  Â  const APFloat &Val = CF->getValueAPF();<br>
+  Â  if (Val.isInfinity())<br>
+  Â  Â  return (Props & ~NumericProperties) | Infinity;<br>
+  Â  Props |= Finite;<br>
+  Â  return Props;<br>
+  }<br>
+<br>
+  return Unknown;<br>
+}<br>
+<br>
+<br>
+// Convert a cell from a set of specific values to a cell that tracks<br>
+// properties.<br>
+bool LatticeCell::convertToProperty() {<br>
+  if (isProperty())<br>
+  Â  return false;<br>
+  // Corner case: converting a fresh (top) cell to "special".<br>
+  // This can happen, when adding a property to a top cell.<br>
+  uint32_t Everything = ConstantProperties::Everything;<br>
+  uint32_t Ps = !isTop() ? properties()<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â  Â : Everything;<br>
+  if (Ps != ConstantProperties::Unknown) {<br>
+  Â  Properties = Ps;<br>
+  Â  setProperty();<br>
+  } else {<br>
+  Â  setBottom();<br>
+  }<br>
+  return true;<br>
+}<br>
+<br>
+<br>
+void LatticeCell::print(raw_ostream &os) const {<br>
+  if (isProperty()) {<br>
+  Â  os << "{ ";<br>
+  Â  uint32_t Ps = properties();<br>
+  Â  if (Ps & ConstantProperties::Zero)<br>
+  Â  Â  os << "zero ";<br>
+  Â  if (Ps & ConstantProperties::NonZero)<br>
+  Â  Â  os << "nonzero ";<br>
+  Â  if (Ps & ConstantProperties::Finite)<br>
+  Â  Â  os << "finite ";<br>
+  Â  if (Ps & ConstantProperties::Infinity)<br>
+  Â  Â  os << "infinity ";<br>
+  Â  if (Ps & ConstantProperties::NaN)<br>
+  Â  Â  os << "nan ";<br>
+  Â  if (Ps & ConstantProperties::PosOrZero)<br>
+  Â  Â  os << "poz ";<br>
+  Â  if (Ps & ConstantProperties::NegOrZero)<br>
+  Â  Â  os << "nez ";<br>
+  Â  os << '}';<br>
+  Â  return;<br>
+  }<br>
+<br>
+  os << "{ ";<br>
+  if (isBottom()) {<br>
+  Â  os << "bottom";<br>
+  } else if (isTop()) {<br>
+  Â  os << "top";<br>
+  } else {<br>
+  Â  for (unsigned i = 0; i < size(); ++i) {<br>
+  Â  Â  const Constant *C = Values[i];<br>
+  Â  Â  if (i != 0)<br>
+  Â  Â  Â  os << ", ";<br>
+  Â  Â  C->print(os);<br>
+  Â  }<br>
+  }<br>
+  os << " }";<br>
+}<br>
+<br>
+<br>
+// "Meet" operation on two cells. This is the key of the propagation<br>
+// algorithm.<br>
+bool LatticeCell::meet(const LatticeCell &L) {<br>
+  bool Changed = false;<br>
+  if (L.isBottom())<br>
+  Â  Changed = setBottom();<br>
+  if (isBottom() || L.isTop())<br>
+  Â  return Changed;<br>
+  if (isTop()) {<br>
+  Â  *this = L;<br>
+  Â  // L can be neither Top nor Bottom, so *this must have changed.<br>
+  Â  return true;<br>
+  }<br>
+<br>
+  // Top/bottom cases covered. Need to integrate L's set into ours.<br>
+  if (L.isProperty())<br>
+  Â  return add(L.properties());<br>
+  for (unsigned i = 0; i < L.size(); ++i) {<br>
+  Â  const Constant *LC = L.Values[i];<br>
+  Â  Changed |= add(LC);<br>
+  }<br>
+  return Changed;<br>
+}<br>
+<br>
+<br>
+// Add a new constant to the cell. This is actually where the cell update<br>
+// happens. If a cell has room for more constants, the new constant is added.<br>
+// Otherwise, the cell is converted to a "property" cell (i.e. a cell that<br>
+// will track properties of the associated values, and not the values<br>
+// themselves. Care is taken to handle special cases, like "bottom", etc.<br>
+bool LatticeCell::add(const Constant *LC) {<br>
+  assert(LC);<br>
+  if (isBottom())<br>
+  Â  return false;<br>
+<br>
+  if (!isProperty()) {<br>
+  Â  // Cell is not special. Try to add the constant here first,<br>
+  Â  // if there is room.<br>
+  Â  unsigned Index = 0;<br>
+  Â  while (Index < Size) {<br>
+  Â  Â  const Constant *C = Values[Index];<br>
+  Â  Â  // If the constant is already here, no change is needed.<br>
+  Â  Â  if (C == LC)<br>
+  Â  Â  Â  return false;<br>
+  Â  Â  Index++;<br>
+  Â  }<br>
+  Â  if (Index < MaxCellSize) {<br>
+  Â  Â  Values[Index] = LC;<br>
+  Â  Â  Kind = Normal;<br>
+  Â  Â  Size++;<br>
+  Â  Â  return true;<br>
+  Â  }<br>
+  }<br>
+<br>
+  bool Changed = false;<br>
+<br>
+  // This cell is special, or is not special, but is full. After this<br>
+  // it will be special.<br>
+  Changed = convertToProperty();<br>
+  uint32_t Ps = properties();<br>
+  uint32_t NewPs = Ps & ConstantProperties::deduce(LC);<br>
+  if (NewPs == ConstantProperties::Unknown) {<br>
+  Â  setBottom();<br>
+  Â  return true;<br>
+  }<br>
+  if (Ps != NewPs) {<br>
+  Â  Properties = NewPs;<br>
+  Â  Changed = true;<br>
+  }<br>
+  return Changed;<br>
+}<br>
+<br>
+<br>
+// Add a property to the cell. This will force the cell to become a property-<br>
+// tracking cell.<br>
+bool LatticeCell::add(uint32_t Property) {<br>
+  bool Changed = convertToProperty();<br>
+  uint32_t Ps = properties();<br>
+  if (Ps == (Ps & Property))<br>
+  Â  return Changed;<br>
+  Properties = Property & Ps;<br>
+  return true;<br>
+}<br>
+<br>
+<br>
+// Return the properties of the values in the cell. This is valid for any<br>
+// cell, and does not alter the cell itself.<br>
+uint32_t LatticeCell::properties() const {<br>
+  if (isProperty())<br>
+  Â  return Properties;<br>
+  assert(!isTop() && "Should not call this for a top cell");<br>
+  if (isBottom())<br>
+  Â  return ConstantProperties::Unknown;<br>
+<br>
+  assert(size() > 0 && "Empty cell");<br>
+  uint32_t Ps = ConstantProperties::deduce(Values[0]);<br>
+  for (unsigned i = 1; i < size(); ++i) {<br>
+  Â  if (Ps == ConstantProperties::Unknown)<br>
+  Â  Â  break;<br>
+  Â  Ps &= ConstantProperties::deduce(Values[i]);<br>
+  }<br>
+  return Ps;<br>
+}<br>
+<br>
+<br>
+void MachineConstPropagator::CellMap::print(raw_ostream &os,<br>
+  Â  Â  const TargetRegisterInfo &TRI) const {<br>
+  for (auto &I : Map)<br>
+  Â  dbgs() << "  " << PrintReg(I.first, &TRI) << " -> " << I.second << '\n';<br>
+}<br>
+<br>
+<br>
+void MachineConstPropagator::visitPHI(const MachineInstr &PN) {<br>
+  const MachineBasicBlock *MB = PN.getParent();<br>
+  unsigned MBN = MB->getNumber();<br>
+  DEBUG(dbgs() << "Visiting FI(BB#" << MBN << "): " << PN);<br>
+<br>
+  const MachineOperand &MD = PN.getOperand(0);<br>
+  Register DefR(MD);<br>
+  assert(TargetRegisterInfo::isVirtualRegister(DefR.Reg));<br>
+<br>
+  bool Changed = false;<br>
+<br>
+  // If the def has a sub-register, set the corresponding cell to "bottom".<br>
+  if (DefR.SubReg) {<br>
+Bottomize:<br>
+  Â  const LatticeCell &T = Cells.get(DefR.Reg);<br>
+  Â  Changed = !T.isBottom();<br>
+  Â  Cells.update(DefR.Reg, Bottom);<br>
+  Â  if (Changed)<br>
+  Â  Â  visitUsesOf(DefR.Reg);<br>
+  Â  return;<br>
+  }<br>
+<br>
+  LatticeCell DefC = Cells.get(DefR.Reg);<br>
+<br>
+  for (unsigned i = 1, n = PN.getNumOperands(); i < n; i += 2) {<br>
+  Â  const MachineBasicBlock *PB = PN.getOperand(i+1).getMBB();<br>
+  Â  unsigned PBN = PB->getNumber();<br>
+  Â  if (!EdgeExec.count(CFGEdge(PBN, MBN))) {<br>
+  Â  Â  DEBUG(dbgs() << "  edge BB#" << PBN << "->BB#" << MBN<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â << " not executable\n");<br>
+  Â  Â  continue;<br>
+  Â  }<br>
+  Â  const MachineOperand &SO = PN.getOperand(i);<br>
+  Â  Register UseR(SO);<br>
+  Â  // If the input is not a virtual register, we don't really know what<br>
+  Â  // value it holds.<br>
+  Â  if (!TargetRegisterInfo::isVirtualRegister(UseR.Reg))<br>
+  Â  Â  goto Bottomize;<br>
+  Â  // If there is no cell for an input register, it means top.<br>
+  Â  if (!Cells.has(UseR.Reg))<br>
+  Â  Â  continue;<br>
+<br>
+  Â  LatticeCell SrcC;<br>
+  Â  bool Eval = MCE.evaluate(UseR, Cells.get(UseR.Reg), SrcC);<br>
+  Â  DEBUG(dbgs() << "  edge from BB#" << PBN << ": "<br>
+  Â  Â  Â  Â  Â  Â  Â  Â << PrintReg(UseR.Reg, &MCE.TRI, UseR.SubReg)<br>
+  Â  Â  Â  Â  Â  Â  Â  Â << SrcC << '\n');<br>
+  Â  Changed |= Eval ? DefC.meet(SrcC)<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  : DefC.setBottom();<br>
+  Â  Cells.update(DefR.Reg, DefC);<br>
+  Â  if (DefC.isBottom())<br>
+  Â  Â  break;<br>
+  }<br>
+  if (Changed)<br>
+  Â  visitUsesOf(DefR.Reg);<br>
+}<br>
+<br>
+<br>
+void MachineConstPropagator::visitNonBranch(const MachineInstr &MI) {<br>
+  DEBUG(dbgs() << "Visiting MI(BB#" << MI.getParent()->getNumber()<br>
+  Â  Â  Â  Â  Â  Â  Â << "): " << MI);<br>
+  CellMap Outputs;<br>
+  bool Eval = MCE.evaluate(MI, Cells, Outputs);<br>
+  DEBUG({<br>
+  Â  if (Eval) {<br>
+  Â  Â  dbgs() << "  outputs:";<br>
+  Â  Â  for (auto &I : Outputs)<br>
+  Â  Â  Â  dbgs() << ' ' << I.second;<br>
+  Â  Â  dbgs() << '\n';<br>
+  Â  }<br>
+  });<br>
+<br>
+  // Update outputs. If the value was not computed, set all the<br>
+  // def cells to bottom.<br>
+  for (const MachineOperand &MO : MI.operands()) {<br>
+  Â  if (!MO.isReg() || !MO.isDef())<br>
+  Â  Â  continue;<br>
+  Â  Register DefR(MO);<br>
+  Â  // Only track virtual registers.<br>
+  Â  if (!TargetRegisterInfo::isVirtualRegister(DefR.Reg))<br>
+  Â  Â  continue;<br>
+  Â  bool Changed = false;<br>
+  Â  // If the evaluation failed, set cells for all output registers to bottom.<br>
+  Â  if (!Eval) {<br>
+  Â  Â  const LatticeCell &T = Cells.get(DefR.Reg);<br>
+  Â  Â  Changed = !T.isBottom();<br>
+  Â  Â  Cells.update(DefR.Reg, Bottom);<br>
+  Â  } else {<br>
+  Â  Â  // Find the corresponding cell in the computed outputs.<br>
+  Â  Â  // If it's not there, go on to the next def.<br>
+  Â  Â  if (!Outputs.has(DefR.Reg))<br>
+  Â  Â  Â  continue;<br>
+  Â  Â  LatticeCell RC = Cells.get(DefR.Reg);<br>
+  Â  Â  Changed = RC.meet(Outputs.get(DefR.Reg));<br>
+  Â  Â  Cells.update(DefR.Reg, RC);<br>
+  Â  }<br>
+  Â  if (Changed)<br>
+  Â  Â  visitUsesOf(DefR.Reg);<br>
+  }<br>
+}<br>
+<br>
+<br>
+// \brief Starting at a given branch, visit remaining branches in the block.<br>
+// Traverse over the subsequent branches for as long as the preceding one<br>
+// can fall through. Add all the possible targets to the flow work queue,<br>
+// including the potential fall-through to the layout-successor block.<br>
+void MachineConstPropagator::visitBranchesFrom(const MachineInstr &BrI) {<br>
+  const MachineBasicBlock &B = *BrI.getParent();<br>
+  unsigned MBN = B.getNumber();<br>
+  MachineBasicBlock::const_iterator It = BrI.getIterator();<br>
+  MachineBasicBlock::const_iterator End = B.end();<br>
+<br>
+  SetVector<const MachineBasicBlock*> Targets;<br>
+  bool EvalOk = true, FallsThru = true;<br>
+  while (It != End) {<br>
+  Â  const MachineInstr &MI = *It;<br>
+  Â  InstrExec.insert(&MI);<br>
+  Â  DEBUG(dbgs() << "Visiting " << (EvalOk ? "BR" : "br") << "(BB#"<br>
+  Â  Â  Â  Â  Â  Â  Â  Â << MBN << "): " << MI);<br>
+  Â  // Do not evaluate subsequent branches if the evaluation of any of the<br>
+  Â  // previous branches failed. Keep iterating over the branches only<br>
+  Â  // to mark them as executable.<br>
+  Â  EvalOk = EvalOk && MCE.evaluate(MI, Cells, Targets, FallsThru);<br>
+  Â  if (!EvalOk)<br>
+  Â  Â  FallsThru = true;<br>
+  Â  if (!FallsThru)<br>
+  Â  Â  break;<br>
+  Â  ++It;<br>
+  }<br>
+<br>
+  if (EvalOk) {<br>
+  Â  // Need to add all CFG successors that lead to EH landing pads.<br>
+  Â  // There won't be explicit branches to these blocks, but they must<br>
+  Â  // be processed.<br>
+  Â  for (const MachineBasicBlock *SB : B.successors()) {<br>
+  Â  Â  if (SB->isEHPad())<br>
+  Â  Â  Â  Targets.insert(SB);<br>
+  Â  }<br>
+  Â  if (FallsThru) {<br>
+  Â  Â  const MachineFunction &MF = *B.getParent();<br>
+  Â  Â  MachineFunction::const_iterator BI = B.getIterator();<br>
+  Â  Â  MachineFunction::const_iterator Next = std::next(BI);<br>
+  Â  Â  if (Next != MF.end())<br>
+  Â  Â  Â  Targets.insert(&*Next);<br>
+  Â  }<br>
+  } else {<br>
+  Â  // If the evaluation of the branches failed, make "Targets" to be the<br>
+  Â  // set of all successors of the block from the CFG.<br>
+  Â  // If the evaluation succeeded for all visited branches, then if the<br>
+  Â  // last one set "FallsThru", then add an edge to the layout successor<br>
+  Â  // to the targets.<br>
+  Â  Targets.clear();<br>
+  Â  DEBUG(dbgs() << "  failed to evaluate a branch...adding all CFG "<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  "successors\n");<br>
+  Â  for (const MachineBasicBlock *SB : B.successors())<br>
+  Â  Â  Targets.insert(SB);<br>
+  }<br>
+<br>
+  for (const MachineBasicBlock *TB : Targets) {<br>
+  Â  unsigned TBN = TB->getNumber();<br>
+  Â  DEBUG(dbgs() << "  pushing edge BB#" << MBN << " -> BB#" << TBN << "\n");<br>
+  Â  FlowQ.push(CFGEdge(MBN, TBN));<br>
+  }<br>
+}<br>
+<br>
+<br>
+void MachineConstPropagator::visitUsesOf(unsigned Reg) {<br>
+  DEBUG(dbgs() << "Visiting uses of " << PrintReg(Reg, &MCE.TRI)<br>
+  Â  Â  Â  Â  Â  Â  Â << Cells.get(Reg) << '\n');<br>
+  for (MachineInstr &MI : MRI->use_nodbg_instructions(Reg)) {<br>
+  Â  // Do not process non-executable instructions. They can become exceutable<br>
+  Â  // later (via a flow-edge in the work queue). In such case, the instruc-<br>
+  Â  // tion will be visited at that time.<br>
+  Â  if (!InstrExec.count(&MI))<br>
+  Â  Â  continue;<br>
+  Â  if (MI.isPHI())<br>
+  Â  Â  visitPHI(MI);<br>
+  Â  else if (!MI.isBranch())<br>
+  Â  Â  visitNonBranch(MI);<br>
+  Â  else<br>
+  Â  Â  visitBranchesFrom(MI);<br>
+  }<br>
+}<br>
+<br>
+<br>
+bool MachineConstPropagator::isExecutable(const MachineBasicBlock *MB) const {<br>
+  unsigned MBN = MB->getNumber();<br>
+  for (const MachineBasicBlock *PB : MB->predecessors()) {<br>
+  Â  unsigned PBN = PB->getNumber();<br>
+  Â  if (EdgeExec.count(CFGEdge(PBN, MBN)))<br>
+  Â  Â  return true;<br>
+  }<br>
+  return false;<br>
+}<br>
+<br>
+<br>
+void MachineConstPropagator::pushLayoutSuccessor(const MachineBasicBlock *MB) {<br>
+  MachineFunction::const_iterator BI = MB->getIterator();<br>
+  unsigned MBN = MB->getNumber();<br>
+  unsigned SBN = std::next(BI)->getNumber();<br>
+  FlowQ.push(CFGEdge(MBN, SBN));<br>
+}<br>
+<br>
+<br>
+bool MachineConstPropagator::computeBlockSuccessors(const MachineBasicBlock *MB,<br>
+  Â  Â  SetVector<const MachineBasicBlock*> &Targets) {<br>
+  MachineBasicBlock::const_iterator FirstBr = MB->end();<br>
+  for (const MachineInstr &MI : *MB) {<br>
+  Â  if (MI.isDebugValue())<br>
+  Â  Â  continue;<br>
+  Â  if (MI.isBranch()) {<br>
+  Â  Â  FirstBr = MI.getIterator();<br>
+  Â  Â  break;<br>
+  Â  }<br>
+  }<br>
+<br>
+  Targets.clear();<br>
+  MachineBasicBlock::const_iterator End = MB->end();<br>
+<br>
+  bool DoNext = true;<br>
+  for (MachineBasicBlock::const_iterator I = FirstBr; I != End; ++I) {<br>
+  Â  const MachineInstr &MI = *I;<br>
+  Â  // Can there be debug instructions between branches?<br>
+  Â  if (MI.isDebugValue())<br>
+  Â  Â  continue;<br>
+  Â  if (!InstrExec.count(&MI))<br>
+  Â  Â  continue;<br>
+  Â  bool Eval = MCE.evaluate(MI, Cells, Targets, DoNext);<br>
+  Â  if (!Eval)<br>
+  Â  Â  return false;<br>
+  Â  if (!DoNext)<br>
+  Â  Â  break;<br>
+  }<br>
+  // If the last branch could fall-through, add block's layout successor.<br>
+  if (DoNext) {<br>
+  Â  MachineFunction::const_iterator BI = MB->getIterator();<br>
+  Â  MachineFunction::const_iterator NextI = std::next(BI);<br>
+  Â  if (NextI != MB->getParent()->end())<br>
+  Â  Â  Targets.insert(&*NextI);<br>
+  }<br>
+<br>
+  // Add all the EH landing pads.<br>
+  for (const MachineBasicBlock *SB : MB->successors())<br>
+  Â  if (SB->isEHPad())<br>
+  Â  Â  Targets.insert(SB);<br>
+<br>
+  return true;<br>
+}<br>
+<br>
+<br>
+void MachineConstPropagator::removeCFGEdge(MachineBasicBlock *From,<br>
+  Â  Â  MachineBasicBlock *To) {<br>
+  // First, remove the CFG successor/predecessor information.<br>
+  From->removeSuccessor(To);<br>
+  // Remove all corresponding PHI operands in the To block.<br>
+  for (auto I = To->begin(), E = To->getFirstNonPHI(); I != E; ++I) {<br>
+  Â  MachineInstr *PN = &*I;<br>
+  Â  // reg0 = PHI reg1, bb2, reg3, bb4, ...<br>
+  Â  int N = PN->getNumOperands()-2;<br>
+  Â  while (N > 0) {<br>
+  Â  Â  if (PN->getOperand(N+1).getMBB() == From) {<br>
+  Â  Â  Â  PN->RemoveOperand(N+1);<br>
+  Â  Â  Â  PN->RemoveOperand(N);<br>
+  Â  Â  }<br>
+  Â  Â  N -= 2;<br>
+  Â  }<br>
+  }<br>
+}<br>
+<br>
+<br>
+void MachineConstPropagator::propagate(MachineFunction &MF) {<br>
+  MachineBasicBlock *Entry = GraphTraits<MachineFunction*>::getEntryNode(&MF);<br>
+  unsigned EntryNum = Entry->getNumber();<br>
+<br>
+  // Start with a fake edge, just to process the entry node.<br>
+  FlowQ.push(CFGEdge(EntryNum, EntryNum));<br>
+<br>
+  while (!FlowQ.empty()) {<br>
+  Â  CFGEdge Edge = FlowQ.front();<br>
+  Â  FlowQ.pop();<br>
+<br>
+  Â  DEBUG(dbgs() << "Picked edge BB#" << Edge.first << "->BB#"<br>
+  Â  Â  Â  Â  Â  Â  Â  Â << Edge.second << '\n');<br>
+  Â  if (Edge.first != EntryNum)<br>
+  Â  Â  if (EdgeExec.count(Edge))<br>
+  Â  Â  Â  continue;<br>
+  Â  EdgeExec.insert(Edge);<br>
+  Â  MachineBasicBlock *SB = MF.getBlockNumbered(Edge.second);<br>
+<br>
+  Â  // Process the block in three stages:<br>
+  Â  // - visit all PHI nodes,<br>
+  Â  // - visit all non-branch instructions,<br>
+  Â  // - visit block branches.<br>
+  Â  MachineBasicBlock::const_iterator It = SB->begin(), End = SB->end();<br>
+<br>
+  Â  // Visit PHI nodes in the successor block.<br>
+  Â  while (It != End && It->isPHI()) {<br>
+  Â  Â  InstrExec.insert(&*It);<br>
+  Â  Â  visitPHI(*It);<br>
+  Â  Â  ++It;<br>
+  Â  }<br>
+<br>
+  Â  // If the successor block just became executable, visit all instructions.<br>
+  Â  // To see if this is the first time we're visiting it, check the first<br>
+  Â  // non-debug instruction to see if it is executable.<br>
+  Â  while (It != End && It->isDebugValue())<br>
+  Â  Â  ++It;<br>
+  Â  assert(It == End || !It->isPHI());<br>
+  Â  // If this block has been visited, go on to the next one.<br>
+  Â  if (It != End && InstrExec.count(&*It))<br>
+  Â  Â  continue;<br>
+  Â  // For now, scan all non-branch instructions. Branches require different<br>
+  Â  // processing.<br>
+  Â  while (It != End && !It->isBranch()) {<br>
+  Â  Â  if (!It->isDebugValue()) {<br>
+  Â  Â  Â  InstrExec.insert(&*It);<br>
+  Â  Â  Â  visitNonBranch(*It);<br>
+  Â  Â  }<br>
+  Â  Â  ++It;<br>
+  Â  }<br>
+<br>
+  Â  // Time to process the end of the block. This is different from<br>
+  Â  // processing regular (non-branch) instructions, because there can<br>
+  Â  // be multiple branches in a block, and they can cause the block to<br>
+  Â  // terminate early.<br>
+  Â  if (It != End) {<br>
+  Â  Â  visitBranchesFrom(*It);<br>
+  Â  } else {<br>
+  Â  Â  // If the block didn't have a branch, add all successor edges to the<br>
+  Â  Â  // work queue. (There should really be only one successor in such case.)<br>
+  Â  Â  unsigned SBN = SB->getNumber();<br>
+  Â  Â  for (const MachineBasicBlock *SSB : SB->successors())<br>
+  Â  Â  Â  FlowQ.push(CFGEdge(SBN, SSB->getNumber()));<br>
+  Â  }<br>
+  } // while (FlowQ)<br>
+<br>
+  DEBUG({<br>
+  Â  dbgs() << "Cells after propagation:\n";<br>
+  Â  Cells.print(dbgs(), MCE.TRI);<br>
+  Â  dbgs() << "Dead CFG edges:\n";<br>
+  Â  for (const MachineBasicBlock &B : MF) {<br>
+  Â  Â  unsigned BN = B.getNumber();<br>
+  Â  Â  for (const MachineBasicBlock *SB : B.successors()) {<br>
+  Â  Â  Â  unsigned SN = SB->getNumber();<br>
+  Â  Â  Â  if (!EdgeExec.count(CFGEdge(BN, SN)))<br>
+  Â  Â  Â  Â  dbgs() << "  BB#" << BN << " -> BB#" << SN << '\n';<br>
+  Â  Â  }<br>
+  Â  }<br>
+  });<br>
+}<br>
+<br>
+<br>
+bool MachineConstPropagator::rewrite(MachineFunction &MF) {<br>
+  bool Changed = false;<br>
+  // Rewrite all instructions based on the collected cell information.<br>
+  //<br>
+  // Traverse the instructions in a post-order, so that rewriting an<br>
+  // instruction can make changes "downstream" in terms of control-flow<br>
+  // without affecting the rewriting process. (We should not change<br>
+  // instructions that have not yet been visited by the rewriter.)<br>
+  // The reason for this is that the rewriter can introduce new vregs,<br>
+  // and replace uses of old vregs (which had corresponding cells<br>
+  // computed during propagation) with these new vregs (which at this<br>
+  // point would not have any cells, and would appear to be "top").<br>
+  // If an attempt was made to evaluate an instruction with a fresh<br>
+  // "top" vreg, it would cause an error (abend) in the evaluator.<br>
+<br>
+  // Collect the post-order-traversal block ordering. The subsequent<br>
+  // traversal/rewrite will update block successors, so it's safer<br>
+  // if the visiting order it computed ahead of time.<br>
+  std::vector<MachineBasicBlock*> POT;<br>
+  for (MachineBasicBlock *B : post_order(&MF))<br>
+  Â  if (!B->empty())<br>
+  Â  Â  POT.push_back(B);<br>
+<br>
+  for (MachineBasicBlock *B : POT) {<br>
+  Â  // Walk the block backwards (which usually begin with the branches).<br>
+  Â  // If any branch is rewritten, we may need to update the successor<br>
+  Â  // information for this block. Unless the block's successors can be<br>
+  Â  // precisely determined (which may not be the case for indirect<br>
+  Â  // branches), we cannot modify any branch.<br>
+<br>
+  Â  // Compute the successor information.<br>
+  Â  SetVector<const MachineBasicBlock*> Targets;<br>
+  Â  bool HaveTargets = computeBlockSuccessors(B, Targets);<br>
+  Â  // Rewrite the executable instructions. Skip branches if we don't<br>
+  Â  // have block successor information.<br>
+  Â  for (auto I = B->rbegin(), E = B->rend(); I != E; ++I) {<br>
+  Â  Â  MachineInstr &MI = *I;<br>
+  Â  Â  if (InstrExec.count(&MI)) {<br>
+  Â  Â  Â  if (MI.isBranch() && !HaveTargets)<br>
+  Â  Â  Â  Â  continue;<br>
+  Â  Â  Â  Changed |= MCE.rewrite(MI, Cells);<br>
+  Â  Â  }<br>
+  Â  }<br>
+  Â  // The rewriting could rewrite PHI nodes to non-PHI nodes, causing<br>
+  Â  // regular instructions to appear in between PHI nodes. Bring all<br>
+  Â  // the PHI nodes to the beginning of the block.<br>
+  Â  for (auto I = B->begin(), E = B->end(); I != E; ++I) {<br>
+  Â  Â  if (I->isPHI())<br>
+  Â  Â  Â  continue;<br>
+  Â  Â  // I is not PHI. Find the next PHI node P.<br>
+  Â  Â  auto P = I;<br>
+  Â  Â  while (++P != E)<br>
+  Â  Â  Â  if (P->isPHI())<br>
+  Â  Â  Â  Â  break;<br>
+  Â  Â  // Not found.<br>
+  Â  Â  if (P == E)<br>
+  Â  Â  Â  break;<br>
+  Â  Â  // Splice P right before I.<br>
+  Â  Â  B->splice(I, B, P);<br>
+  Â  Â  // Reset I to point at the just spliced PHI node.<br>
+  Â  Â  --I;<br>
+  Â  }<br>
+  Â  // Update the block successor information: remove unnecessary successors.<br>
+  Â  if (HaveTargets) {<br>
+  Â  Â  SmallVector<MachineBasicBlock*,2> ToRemove;<br>
+  Â  Â  for (MachineBasicBlock *SB : B->successors()) {<br>
+  Â  Â  Â  if (!Targets.count(SB))<br>
+  Â  Â  Â  Â  ToRemove.push_back(const_cast<MachineBasicBlock*>(SB));<br>
+  Â  Â  Â  Targets.remove(SB);<br>
+  Â  Â  }<br>
+  Â  Â  for (unsigned i = 0, n = ToRemove.size(); i < n; ++i)<br>
+  Â  Â  Â  removeCFGEdge(B, ToRemove[i]);<br>
+  Â  Â  // If there are any blocks left in the computed targets, it means that<br>
+  Â  Â  // we think that the block could go somewhere, but the CFG does not.<br>
+  Â  Â  // This could legitimately happen in blocks that have non-returning<br>
+  Â  Â  // calls---we would think that the execution can continue, but the<br>
+  Â  Â  // CFG will not have a successor edge.<br>
+  Â  }<br>
+  }<br>
+  // Need to do some final post-processing.<br>
+  // If a branch was not executable, it will not get rewritten, but should<br>
+  // be removed (or replaced with something equivalent to a A2_nop). We can't<br>
+  // erase instructions during rewriting, so this needs to be delayed until<br>
+  // now.<br>
+  for (MachineBasicBlock &B : MF) {<br>
+  Â  MachineBasicBlock::iterator I = B.begin(), E = B.end();<br>
+  Â  while (I != E) {<br>
+  Â  Â  auto Next = std::next(I);<br>
+  Â  Â  if (I->isBranch() && !InstrExec.count(&*I))<br>
+  Â  Â  Â  B.erase(I);<br>
+  Â  Â  I = Next;<br>
+  Â  }<br>
+  }<br>
+  return Changed;<br>
+}<br>
+<br>
+<br>
+// This is the constant propagation algorithm as described by Wegman-Zadeck.<br>
+// Most of the terminology comes from there.<br>
+bool MachineConstPropagator::run(MachineFunction &MF) {<br>
+  DEBUG(MF.print(dbgs() << "Starting MachineConstPropagator\n", 0));<br>
+<br>
+  MRI = &MF.getRegInfo();<br>
+<br>
+  Cells.clear();<br>
+  EdgeExec.clear();<br>
+  InstrExec.clear();<br>
+  assert(FlowQ.empty());<br>
+<br>
+  propagate(MF);<br>
+  bool Changed = rewrite(MF);<br>
+<br>
+  DEBUG({<br>
+  Â  dbgs() << "End of MachineConstPropagator (Changed=" << Changed << ")\n";<br>
+  Â  if (Changed)<br>
+  Â  Â  MF.print(dbgs(), 0);<br>
+  });<br>
+  return Changed;<br>
+}<br>
+<br>
+<br>
+// --------------------------------------------------------------------<br>
+// Machine const evaluator.<br>
+<br>
+bool MachineConstEvaluator::getCell(const Register &R, const CellMap &Inputs,<br>
+  Â  Â  LatticeCell &RC) {<br>
+  if (!TargetRegisterInfo::isVirtualRegister(R.Reg))<br>
+  Â  return false;<br>
+  const LatticeCell &L = Inputs.get(R.Reg);<br>
+  if (!R.SubReg) {<br>
+  Â  RC = L;<br>
+  Â  return !RC.isBottom();<br>
+  }<br>
+  bool Eval = evaluate(R, L, RC);<br>
+  return Eval && !RC.isBottom();<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::constToInt(const Constant *C,<br>
+  Â  Â  APInt &Val) const {<br>
+  const ConstantInt *CI = dyn_cast<ConstantInt>(C);<br>
+  if (!CI)<br>
+  Â  return false;<br>
+  Val = CI->getValue();<br>
+  return true;<br>
+}<br>
+<br>
+<br>
+const ConstantInt *MachineConstEvaluator::intToConst(const APInt &Val) const {<br>
+  return ConstantInt::get(CX, Val);<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateCMPrr(uint32_t Cmp, const Register &R1,<br>
+  Â  Â  const Register &R2, const CellMap &Inputs, bool &Result) {<br>
+  assert(Inputs.has(R1.Reg) && Inputs.has(R2.Reg));<br>
+  LatticeCell LS1, LS2;<br>
+  if (!getCell(R1, Inputs, LS1) || !getCell(R2, Inputs, LS2))<br>
+  Â  return false;<br>
+<br>
+  bool IsProp1 = LS1.isProperty();<br>
+  bool IsProp2 = LS2.isProperty();<br>
+  if (IsProp1) {<br>
+  Â  uint32_t Prop1 = LS1.properties();<br>
+  Â  if (IsProp2)<br>
+  Â  Â  return evaluateCMPpp(Cmp, Prop1, LS2.properties(), Result);<br>
+  Â  uint32_t NegCmp = Comparison::negate(Cmp);<br>
+  Â  return evaluateCMPrp(NegCmp, R2, Prop1, Inputs, Result);<br>
+  }<br>
+  if (IsProp2) {<br>
+  Â  uint32_t Prop2 = LS2.properties();<br>
+  Â  return evaluateCMPrp(Cmp, R1, Prop2, Inputs, Result);<br>
+  }<br>
+<br>
+  APInt A;<br>
+  bool IsTrue = true, IsFalse = true;<br>
+  for (unsigned i = 0; i < LS2.size(); ++i) {<br>
+  Â  bool Res;<br>
+  Â  bool Computed = constToInt(LS2.Values[i], A) &&<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  evaluateCMPri(Cmp, R1, A, Inputs, Res);<br>
+  Â  if (!Computed)<br>
+  Â  Â  return false;<br>
+  Â  IsTrue &= Res;<br>
+  Â  IsFalse &= !Res;<br>
+  }<br>
+  assert(!IsTrue || !IsFalse);<br>
+  // The actual logical value of the comparison is same as IsTrue.<br>
+  Result = IsTrue;<br>
+  // Return true if the result was proven to be true or proven to be false.<br>
+  return IsTrue || IsFalse;<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateCMPri(uint32_t Cmp, const Register &R1,<br>
+  Â  Â  const APInt &A2, const CellMap &Inputs, bool &Result) {<br>
+  assert(Inputs.has(R1.Reg));<br>
+  LatticeCell LS;<br>
+  if (!getCell(R1, Inputs, LS))<br>
+  Â  return false;<br>
+  if (LS.isProperty())<br>
+  Â  return evaluateCMPpi(Cmp, LS.properties(), A2, Result);<br>
+<br>
+  APInt A;<br>
+  bool IsTrue = true, IsFalse = true;<br>
+  for (unsigned i = 0; i < LS.size(); ++i) {<br>
+  Â  bool Res;<br>
+  Â  bool Computed = constToInt(LS.Values[i], A) &&<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  evaluateCMPii(Cmp, A, A2, Res);<br>
+  Â  if (!Computed)<br>
+  Â  Â  return false;<br>
+  Â  IsTrue &= Res;<br>
+  Â  IsFalse &= !Res;<br>
+  }<br>
+  assert(!IsTrue || !IsFalse);<br>
+  // The actual logical value of the comparison is same as IsTrue.<br>
+  Result = IsTrue;<br>
+  // Return true if the result was proven to be true or proven to be false.<br>
+  return IsTrue || IsFalse;<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateCMPrp(uint32_t Cmp, const Register &R1,<br>
+  Â  Â  uint64_t Props2, const CellMap &Inputs, bool &Result) {<br>
+  assert(Inputs.has(R1.Reg));<br>
+  LatticeCell LS;<br>
+  if (!getCell(R1, Inputs, LS))<br>
+  Â  return false;<br>
+  if (LS.isProperty())<br>
+  Â  return evaluateCMPpp(Cmp, LS.properties(), Props2, Result);<br>
+<br>
+  APInt A;<br>
+  uint32_t NegCmp = Comparison::negate(Cmp);<br>
+  bool IsTrue = true, IsFalse = true;<br>
+  for (unsigned i = 0; i < LS.size(); ++i) {<br>
+  Â  bool Res;<br>
+  Â  bool Computed = constToInt(LS.Values[i], A) &&<br>
+  Â  Â  Â  Â  Â  Â  Â  Â  Â  evaluateCMPpi(NegCmp, Props2, A, Res);<br>
+  Â  if (!Computed)<br>
+  Â  Â  return false;<br>
+  Â  IsTrue &= Res;<br>
+  Â  IsFalse &= !Res;<br>
+  }<br>
+  assert(!IsTrue || !IsFalse);<br>
+  Result = IsTrue;<br>
+  return IsTrue || IsFalse;<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateCMPii(uint32_t Cmp, const APInt &A1,<br>
+  Â  Â  const APInt &A2, bool &Result) {<br>
+  // NE is a special kind of comparison (not composed of smaller properties).<br>
+  if (Cmp == Comparison::NE) {<br>
+  Â  Result = !APInt::isSameValue(A1, A2);<br>
+  Â  return true;<br>
+  }<br>
+  if (Cmp == Comparison::EQ) {<br>
+  Â  Result = APInt::isSameValue(A1, A2);<br>
+  Â  return true;<br>
+  }<br>
+  if (Cmp & Comparison::EQ) {<br>
+  Â  if (APInt::isSameValue(A1, A2))<br>
+  Â  Â  return (Result = true);<br>
+  }<br>
+  assert((Cmp & (Comparison::L | Comparison::G)) && "Malformed comparison");<br>
+  Result = false;<br>
+<br>
+  unsigned W1 = A1.getBitWidth();<br>
+  unsigned W2 = A2.getBitWidth();<br>
+  unsigned MaxW = (W1 >= W2) ? W1 : W2;<br>
+  if (Cmp & Comparison::U) {<br>
+  Â  const APInt Zx1 = A1.zextOrSelf(MaxW);<br>
+  Â  const APInt Zx2 = A2.zextOrSelf(MaxW);<br>
+  Â  if (Cmp & Comparison::L)<br>
+  Â  Â  Result = Zx1.ult(Zx2);<br>
+  Â  else if (Cmp & Comparison::G)<br>
+  Â  Â  Result = Zx2.ult(Zx1);<br>
+  Â  return true;<br>
+  }<br>
+<br>
+  // Signed comparison.<br>
+  const APInt Sx1 = A1.sextOrSelf(MaxW);<br>
+  const APInt Sx2 = A2.sextOrSelf(MaxW);<br>
+  if (Cmp & Comparison::L)<br>
+  Â  Result = Sx1.slt(Sx2);<br>
+  else if (Cmp & Comparison::G)<br>
+  Â  Result = Sx2.slt(Sx1);<br>
+  return true;<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateCMPpi(uint32_t Cmp, uint32_t Props,<br>
+  Â  Â  const APInt &A2, bool &Result) {<br>
+  if (Props == ConstantProperties::Unknown)<br>
+  Â  return false;<br>
+<br>
+  // Should never see NaN here, but check for it for completeness.<br>
+  if (Props & ConstantProperties::NaN)<br>
+  Â  return false;<br>
+  // Infinity could theoretically be compared to a number, but the<br>
+  // presence of infinity here would be very suspicious. If we don't<br>
+  // know for sure that the number is finite, bail out.<br>
+  if (!(Props & ConstantProperties::Finite))<br>
+  Â  return false;<br>
+<br>
+  // Let X be a number that has properties Props.<br>
+<br>
+  if (Cmp & Comparison::U) {<br>
+  Â  // In case of unsigned comparisons, we can only compare against 0.<br>
+  Â  if (A2 == 0) {<br>
+  Â  Â  // Any x!=0 will be considered >0 in an unsigned comparison.<br>
+  Â  Â  if (Props & ConstantProperties::Zero)<br>
+  Â  Â  Â  Result = (Cmp & Comparison::EQ);<br>
+  Â  Â  else if (Props & ConstantProperties::NonZero)<br>
+  Â  Â  Â  Result = (Cmp & Comparison::G) || (Cmp == Comparison::NE);<br>
+  Â  Â  else<br>
+  Â  Â  Â  return false;<br>
+  Â  Â  return true;<br>
+  Â  }<br>
+  Â  // A2 is not zero. The only handled case is if X = 0.<br>
+  Â  if (Props & ConstantProperties::Zero) {<br>
+  Â  Â  Result = (Cmp & Comparison::L) || (Cmp == Comparison::NE);<br>
+  Â  Â  return true;<br>
+  Â  }<br>
+  Â  return false;<br>
+  }<br>
+<br>
+  // Signed comparisons are different.<br>
+  if (Props & ConstantProperties::Zero) {<br>
+  Â  if (A2 == 0)<br>
+  Â  Â  Result = (Cmp & Comparison::EQ);<br>
+  Â  else<br>
+  Â  Â  Result = (Cmp == Comparison::NE) ||<br>
+  Â  Â  Â  Â  Â  Â  Â ((Cmp & Comparison::L) && !A2.isNegative()) ||<br>
+  Â  Â  Â  Â  Â  Â  Â ((Cmp & Comparison::G) &&  A2.isNegative());<br>
+  Â  return true;<br>
+  }<br>
+  if (Props & ConstantProperties::PosOrZero) {<br>
+  Â  // X >= 0 and !(A2 < 0) => cannot compare<br>
+  Â  if (!A2.isNegative())<br>
+  Â  Â  return false;<br>
+  Â  // X >= 0 and A2 < 0<br>
+  Â  Result = (Cmp & Comparison::G) || (Cmp == Comparison::NE);<br>
+  Â  return true;<br>
+  }<br>
+  if (Props & ConstantProperties::NegOrZero) {<br>
+  Â  // X <= 0 and Src1 < 0 => cannot compare<br>
+  Â  if (A2 == 0 || A2.isNegative())<br>
+  Â  Â  return false;<br>
+  Â  // X <= 0 and A2 > 0<br>
+  Â  Result = (Cmp & Comparison::L) || (Cmp == Comparison::NE);<br>
+  Â  return true;<br>
+  }<br>
+<br>
+  return false;<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateCMPpp(uint32_t Cmp, uint32_t Props1,<br>
+  Â  Â  uint32_t Props2, bool &Result) {<br>
+  typedef ConstantProperties P;<br>
+  if ((Props1 & P::NaN) && (Props2 & P::NaN))<br>
+  Â  return false;<br>
+  if (!(Props1 & P::Finite) || !(Props2 & P::Finite))<br>
+  Â  return false;<br>
+<br>
+  bool Zero1 = (Props1 & P::Zero), Zero2 = (Props2 & P::Zero);<br>
+  bool NonZero1 = (Props1 & P::NonZero), NonZero2 = (Props2 & P::NonZero);<br>
+  if (Zero1 && Zero2) {<br>
+  Â  Result = (Cmp & Comparison::EQ);<br>
+  Â  return true;<br>
+  }<br>
+  if (Cmp == Comparison::NE) {<br>
+  Â  if ((Zero1 && NonZero2) || (NonZero1 && Zero2))<br>
+  Â  Â  return (Result = true);<br>
+  Â  return false;<br>
+  }<br>
+<br>
+  if (Cmp & Comparison::U) {<br>
+  Â  // In unsigned comparisons, we can only compare against a known zero,<br>
+  Â  // or a known non-zero.<br>
+  Â  if (Zero1 && NonZero2) {<br>
+  Â  Â  Result = (Cmp & Comparison::L);<br>
+  Â  Â  return true;<br>
+  Â  }<br>
+  Â  if (NonZero1 && Zero2) {<br>
+  Â  Â  Result = (Cmp & Comparison::G);<br>
+  Â  Â  return true;<br>
+  Â  }<br>
+  Â  return false;<br>
+  }<br>
+<br>
+  // Signed comparison. The comparison is not NE.<br>
+  bool Poz1 = (Props1 & P::PosOrZero), Poz2 = (Props2 & P::PosOrZero);<br>
+  bool Nez1 = (Props1 & P::NegOrZero), Nez2 = (Props2 & P::NegOrZero);<br>
+  if (Nez1 && Poz2) {<br>
+  Â  if (NonZero1 || NonZero2) {<br>
+  Â  Â  Result = (Cmp & Comparison::L);<br>
+  Â  Â  return true;<br>
+  Â  }<br>
+  Â  // Either (or both) could be zero. Can only say that X <= Y.<br>
+  Â  if ((Cmp & Comparison::EQ) && (Cmp & Comparison::L))<br>
+  Â  Â  return (Result = true);<br>
+  }<br>
+  if (Poz1 && Nez2) {<br>
+  Â  if (NonZero1 || NonZero2) {<br>
+  Â  Â  Result = (Cmp & Comparison::G);<br>
+  Â  Â  return true;<br>
+  Â  }<br>
+  Â  // Either (or both) could be zero. Can only say that X >= Y.<br>
+  Â  if ((Cmp & Comparison::EQ) && (Cmp & Comparison::G))<br>
+  Â  Â  return (Result = true);<br>
+  }<br>
+<br>
+  return false;<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateCOPY(const Register &R1,<br>
+  Â  Â  const CellMap &Inputs, LatticeCell &Result) {<br>
+  return getCell(R1, Inputs, Result);<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateANDrr(const Register &R1,<br>
+  Â  Â  const Register &R2, const CellMap &Inputs, LatticeCell &Result) {<br>
+  assert(Inputs.has(R1.Reg) && Inputs.has(R2.Reg));<br>
+  const LatticeCell &L1 = Inputs.get(R2.Reg);<br>
+  const LatticeCell &L2 = Inputs.get(R2.Reg);<br>
+  // If both sources are bottom, exit. Otherwise try to evaluate ANDri<br>
+  // with the non-bottom argument passed as the immediate. This is to<br>
+  // catch cases of ANDing with 0.<br>
+  if (L2.isBottom()) {<br>
+  Â  if (L1.isBottom())<br>
+  Â  Â  return false;<br>
+  Â  return evaluateANDrr(R2, R1, Inputs, Result);<br>
+  }<br>
+  LatticeCell LS2;<br>
+  if (!evaluate(R2, L2, LS2))<br>
+  Â  return false;<br>
+  if (LS2.isBottom() || LS2.isProperty())<br>
+  Â  return false;<br>
+<br>
+  APInt A;<br>
+  for (unsigned i = 0; i < LS2.size(); ++i) {<br>
+  Â  LatticeCell RC;<br>
+  Â  bool Eval = constToInt(LS2.Values[i], A) &&<br>
+  Â  Â  Â  Â  Â  Â  Â  evaluateANDri(R1, A, Inputs, RC);<br>
+  Â  if (!Eval)<br>
+  Â  Â  return false;<br>
+  Â  Result.meet(RC);<br>
+  }<br>
+  return !Result.isBottom();<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateANDri(const Register &R1,<br>
+  Â  Â  const APInt &A2, const CellMap &Inputs, LatticeCell &Result) {<br>
+  assert(Inputs.has(R1.Reg));<br>
+  if (A2 == -1)<br>
+  Â  return getCell(R1, Inputs, Result);<br>
+  if (A2 == 0) {<br>
+  Â  LatticeCell RC;<br>
+  Â  RC.add(intToConst(A2));<br>
+  Â  // Overwrite Result.<br>
+  Â  Result = RC;<br>
+  Â  return true;<br>
+  }<br>
+  LatticeCell LS1;<br>
+  if (!getCell(R1, Inputs, LS1))<br>
+  Â  return false;<br>
+  if (LS1.isBottom() || LS1.isProperty())<br>
+  Â  return false;<br>
+<br>
+  APInt A, ResA;<br>
+  for (unsigned i = 0; i < LS1.size(); ++i) {<br>
+  Â  bool Eval = constToInt(LS1.Values[i], A) &&<br>
+  Â  Â  Â  Â  Â  Â  Â  evaluateANDii(A, A2, ResA);<br>
+  Â  if (!Eval)<br>
+  Â  Â  return false;<br>
+  Â  const Constant *C = intToConst(ResA);<br>
+  Â  Result.add(C);<br>
+  }<br>
+  return !Result.isBottom();<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateANDii(const APInt &A1,<br>
+  Â  Â  const APInt &A2, APInt &Result) {<br>
+  Result = A1 & A2;<br>
+  return true;<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateORrr(const Register &R1,<br>
+  Â  Â  const Register &R2, const CellMap &Inputs, LatticeCell &Result) {<br>
+  assert(Inputs.has(R1.Reg) && Inputs.has(R2.Reg));<br>
+  const LatticeCell &L1 = Inputs.get(R2.Reg);<br>
+  const LatticeCell &L2 = Inputs.get(R2.Reg);<br>
+  // If both sources are bottom, exit. Otherwise try to evaluate ORri<br>
+  // with the non-bottom argument passed as the immediate. This is to<br>
+  // catch cases of ORing with -1.<br>
+  if (L2.isBottom()) {<br>
+  Â  if (L1.isBottom())<br>
+  Â  Â  return false;<br>
+  Â  return evaluateORrr(R2, R1, Inputs, Result);<br>
+  }<br>
+  LatticeCell LS2;<br>
+  if (!evaluate(R2, L2, LS2))<br>
+  Â  return false;<br>
+  if (LS2.isBottom() || LS2.isProperty())<br>
+  Â  return false;<br>
+<br>
+  APInt A;<br>
+  for (unsigned i = 0; i < LS2.size(); ++i) {<br>
+  Â  LatticeCell RC;<br>
+  Â  bool Eval = constToInt(LS2.Values[i], A) &&<br>
+  Â  Â  Â  Â  Â  Â  Â  evaluateORri(R1, A, Inputs, RC);<br>
+  Â  if (!Eval)<br>
+  Â  Â  return false;<br>
+  Â  Result.meet(RC);<br>
+  }<br>
+  return !Result.isBottom();<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateORri(const Register &R1,<br>
+  Â  Â  const APInt &A2, const CellMap &Inputs, LatticeCell &Result) {<br>
+  assert(Inputs.has(R1.Reg));<br>
+  if (A2 == 0)<br>
+  Â  return getCell(R1, Inputs, Result);<br>
+  if (A2 == -1) {<br>
+  Â  LatticeCell RC;<br>
+  Â  RC.add(intToConst(A2));<br>
+  Â  // Overwrite Result.<br>
+  Â  Result = RC;<br>
+  Â  return true;<br>
+  }<br>
+  LatticeCell LS1;<br>
+  if (!getCell(R1, Inputs, LS1))<br>
+  Â  return false;<br>
+  if (LS1.isBottom() || LS1.isProperty())<br>
+  Â  return false;<br>
+<br>
+  APInt A, ResA;<br>
+  for (unsigned i = 0; i < LS1.size(); ++i) {<br>
+  Â  bool Eval = constToInt(LS1.Values[i], A) &&<br>
+  Â  Â  Â  Â  Â  Â  Â  evaluateORii(A, A2, ResA);<br>
+  Â  if (!Eval)<br>
+  Â  Â  return false;<br>
+  Â  const Constant *C = intToConst(ResA);<br>
+  Â  Result.add(C);<br>
+  }<br>
+  return !Result.isBottom();<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateORii(const APInt &A1,<br>
+  Â  Â  const APInt &A2, APInt &Result) {<br>
+  Result = A1 | A2;<br>
+  return true;<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateXORrr(const Register &R1,<br>
+  Â  Â  const Register &R2, const CellMap &Inputs, LatticeCell &Result) {<br>
+  assert(Inputs.has(R1.Reg) && Inputs.has(R2.Reg));<br>
+  LatticeCell LS1, LS2;<br>
+  if (!getCell(R1, Inputs, LS1) || !getCell(R2, Inputs, LS2))<br>
+  Â  return false;<br>
+  if (LS1.isProperty()) {<br>
+  Â  if (LS1.properties() & ConstantProperties::Zero)<br>
+  Â  Â  return !(Result = LS2).isBottom();<br>
+  Â  return false;<br>
+  }<br>
+  if (LS2.isProperty()) {<br>
+  Â  if (LS2.properties() & ConstantProperties::Zero)<br>
+  Â  Â  return !(Result = LS1).isBottom();<br>
+  Â  return false;<br>
+  }<br>
+<br>
+  APInt A;<br>
+  for (unsigned i = 0; i < LS2.size(); ++i) {<br>
+  Â  LatticeCell RC;<br>
+  Â  bool Eval = constToInt(LS2.Values[i], A) &&<br>
+  Â  Â  Â  Â  Â  Â  Â  evaluateXORri(R1, A, Inputs, RC);<br>
+  Â  if (!Eval)<br>
+  Â  Â  return false;<br>
+  Â  Result.meet(RC);<br>
+  }<br>
+  return !Result.isBottom();<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateXORri(const Register &R1,<br>
+  Â  Â  const APInt &A2, const CellMap &Inputs, LatticeCell &Result) {<br>
+  assert(Inputs.has(R1.Reg));<br>
+  LatticeCell LS1;<br>
+  if (!getCell(R1, Inputs, LS1))<br>
+  Â  return false;<br>
+  if (LS1.isProperty()) {<br>
+  Â  if (LS1.properties() & ConstantProperties::Zero) {<br>
+  Â  Â  const Constant *C = intToConst(A2);<br>
+  Â  Â  Result.add(C);<br>
+  Â  Â  return !Result.isBottom();<br>
+  Â  }<br>
+  Â  return false;<br>
+  }<br>
+<br>
+  APInt A, XA;<br>
+  for (unsigned i = 0; i < LS1.size(); ++i) {<br>
+  Â  bool Eval = constToInt(LS1.Values[i], A) &&<br>
+  Â  Â  Â  Â  Â  Â  Â  evaluateXORii(A, A2, XA);<br>
+  Â  if (!Eval)<br>
+  Â  Â  return false;<br>
+  Â  const Constant *C = intToConst(XA);<br>
+  Â  Result.add(C);<br>
+  }<br>
+  return !Result.isBottom();<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateXORii(const APInt &A1,<br>
+  Â  Â  const APInt &A2, APInt &Result) {<br>
+  Result = A1 ^ A2;<br>
+  return true;<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateZEXTr(const Register &R1, unsigned Width,<br>
+  Â  Â  unsigned Bits, const CellMap &Inputs, LatticeCell &Result) {<br>
+  assert(Inputs.has(R1.Reg));<br>
+  LatticeCell LS1;<br>
+  if (!getCell(R1, Inputs, LS1))<br>
+  Â  return false;<br>
+  if (LS1.isProperty())<br>
+  Â  return false;<br>
+<br>
+  APInt A, XA;<br>
+  for (unsigned i = 0; i < LS1.size(); ++i) {<br>
+  Â  bool Eval = constToInt(LS1.Values[i], A) &&<br>
+  Â  Â  Â  Â  Â  Â  Â  evaluateZEXTi(A, Width, Bits, XA);<br>
+  Â  if (!Eval)<br>
+  Â  Â  return false;<br>
+  Â  const Constant *C = intToConst(XA);<br>
+  Â  Result.add(C);<br>
+  }<br>
+  return true;<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateZEXTi(const APInt &A1, unsigned Width,<br>
+  Â  Â  unsigned Bits, APInt &Result) {<br>
+  unsigned BW = A1.getBitWidth();<br>
+  assert(Width >= Bits && BW >= Bits);<br>
+  APInt Mask = APInt::getLowBitsSet(Width, Bits);<br>
+  Result = A1.zextOrTrunc(Width) & Mask;<br>
+  return true;<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateSEXTr(const Register &R1, unsigned Width,<br>
+  Â  Â  unsigned Bits, const CellMap &Inputs, LatticeCell &Result) {<br>
+  assert(Inputs.has(R1.Reg));<br>
+  LatticeCell LS1;<br>
+  if (!getCell(R1, Inputs, LS1))<br>
+  Â  return false;<br>
+  if (LS1.isBottom() || LS1.isProperty())<br>
+  Â  return false;<br>
+<br>
+  APInt A, XA;<br>
+  for (unsigned i = 0; i < LS1.size(); ++i) {<br>
+  Â  bool Eval = constToInt(LS1.Values[i], A) &&<br>
+  Â  Â  Â  Â  Â  Â  Â  evaluateSEXTi(A, Width, Bits, XA);<br>
+  Â  if (!Eval)<br>
+  Â  Â  return false;<br>
+  Â  const Constant *C = intToConst(XA);<br>
+  Â  Result.add(C);<br>
+  }<br>
+  return true;<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateSEXTi(const APInt &A1, unsigned Width,<br>
+  Â  Â  unsigned Bits, APInt &Result) {<br>
+  unsigned BW = A1.getBitWidth();<br>
+  assert(Width >= Bits && BW >= Bits);<br>
+  // Special case to make things faster for smaller source widths.<br>
+  // Sign extension of 0 bits generates 0 as a result. This is consistent<br>
+  // with what the HW does.<br>
+  if (Bits == 0) {<br>
+  Â  Result = APInt(Width, 0);<br>
+  Â  return true;<br>
+  }<br>
+  // In C, shifts by 64 invoke undefined behavior: handle that case in APInt.<br>
+  if (BW <= 64 && Bits != 0) {<br>
+  Â  int64_t V = A1.getSExtValue();<br>
+  Â  switch (Bits) {<br>
+  Â  Â  case 8:<br>
+  Â  Â  Â  V = static_cast<int8_t>(V);<br>
+  Â  Â  Â  break;<br>
+  Â  Â  case 16:<br>
+  Â  Â  Â  V = static_cast<int16_t>(V);<br>
+  Â  Â  Â  break;<br>
+  Â  Â  case 32:<br>
+  Â  Â  Â  V = static_cast<int32_t>(V);<br>
+  Â  Â  Â  break;<br>
+  Â  Â  default:<br>
+  Â  Â  Â  // Shift left to lose all bits except lower "Bits" bits, then shift<br>
+  Â  Â  Â  // the value back, replicating what was a sign bit after the first<br>
+  Â  Â  Â  // shift.<br>
+  Â  Â  Â  V = (V << (64-Bits)) >> (64-Bits);<br>
+  Â  Â  Â  break;<br>
+  Â  }<br>
+  Â  // V is a 64-bit sign-extended value. Convert it to APInt of desired<br>
+  Â  // width.<br>
+  Â  Result = APInt(Width, V, true);<br>
+  Â  return true;<br>
+  }<br>
+  // Slow case: the value doesn't fit in int64_t.<br>
+  if (Bits < BW)<br>
+  Â  Result = A1.trunc(Bits).sext(Width);<br>
+  else // Bits == BW<br>
+  Â  Result = A1.sext(Width);<br>
+  return true;<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateCLBr(const Register &R1, bool Zeros,<br>
+  Â  Â  bool Ones, const CellMap &Inputs, LatticeCell &Result) {<br>
+  assert(Inputs.has(R1.Reg));<br>
+  LatticeCell LS1;<br>
+  if (!getCell(R1, Inputs, LS1))<br>
+  Â  return false;<br>
+  if (LS1.isBottom() || LS1.isProperty())<br>
+  Â  return false;<br>
+<br>
+  APInt A, CA;<br>
+  for (unsigned i = 0; i < LS1.size(); ++i) {<br>
+  Â  bool Eval = constToInt(LS1.Values[i], A) &&<br>
+  Â  Â  Â  Â  Â  Â  Â  evaluateCLBi(A, Zeros, Ones, CA);<br>
+  Â  if (!Eval)<br>
+  Â  Â  return false;<br>
+  Â  const Constant *C = intToConst(CA);<br>
+  Â  Result.add(C);<br>
+  }<br>
+  return true;<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateCLBi(const APInt &A1, bool Zeros,<br>
+  Â  Â  bool Ones, APInt &Result) {<br>
+  unsigned BW = A1.getBitWidth();<br>
+  if (!Zeros && !Ones)<br>
+  Â  return false;<br>
+  unsigned Count = 0;<br>
+  if (Zeros && (Count == 0))<br>
+  Â  Count = A1.countLeadingZeros();<br>
+  if (Ones && (Count == 0))<br>
+  Â  Count = A1.countLeadingOnes();<br>
+  Result = APInt(BW, static_cast<uint64_t>(Count), false);<br>
+  return true;<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateCTBr(const Register &R1, bool Zeros,<br>
+  Â  Â  bool Ones, const CellMap &Inputs, LatticeCell &Result) {<br>
+  assert(Inputs.has(R1.Reg));<br>
+  LatticeCell LS1;<br>
+  if (!getCell(R1, Inputs, LS1))<br>
+  Â  return false;<br>
+  if (LS1.isBottom() || LS1.isProperty())<br>
+  Â  return false;<br>
+<br>
+  APInt A, CA;<br>
+  for (unsigned i = 0; i < LS1.size(); ++i) {<br>
+  Â  bool Eval = constToInt(LS1.Values[i], A) &&<br>
+  Â  Â  Â  Â  Â  Â  Â  evaluateCTBi(A, Zeros, Ones, CA);<br>
+  Â  if (!Eval)<br>
+  Â  Â  return false;<br>
+  Â  const Constant *C = intToConst(CA);<br>
+  Â  Result.add(C);<br>
+  }<br>
+  return true;<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateCTBi(const APInt &A1, bool Zeros,<br>
+  Â  Â  bool Ones, APInt &Result) {<br>
+  unsigned BW = A1.getBitWidth();<br>
+  if (!Zeros && !Ones)<br>
+  Â  return false;<br>
+  unsigned Count = 0;<br>
+  if (Zeros && (Count == 0))<br>
+  Â  Count = A1.countTrailingZeros();<br>
+  if (Ones && (Count == 0))<br>
+  Â  Count = A1.countTrailingOnes();<br>
+  Result = APInt(BW, static_cast<uint64_t>(Count), false);<br>
+  return true;<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateEXTRACTr(const Register &R1,<br>
+  Â  Â  unsigned Width, unsigned Bits, unsigned Offset, bool Signed,<br>
+  Â  Â  const CellMap &Inputs, LatticeCell &Result) {<br>
+  assert(Inputs.has(R1.Reg));<br>
+  assert(Bits+Offset <= Width);<br>
+  LatticeCell LS1;<br>
+  if (!getCell(R1, Inputs, LS1))<br>
+  Â  return false;<br>
+  if (LS1.isBottom())<br>
+  Â  return false;<br>
+  if (LS1.isProperty()) {<br>
+  Â  uint32_t Ps = LS1.properties();<br>
+  Â  if (Ps & ConstantProperties::Zero) {<br>
+  Â  Â  const Constant *C = intToConst(APInt(Width, 0, false));<br>
+  Â  Â  Result.add(C);<br>
+  Â  Â  return true;<br>
+  Â  }<br>
+  Â  return false;<br>
+  }<br>
+<br>
+  APInt A, CA;<br>
+  for (unsigned i = 0; i < LS1.size(); ++i) {<br>
+  Â  bool Eval = constToInt(LS1.Values[i], A) &&<br>
+  Â  Â  Â  Â  Â  Â  Â  evaluateEXTRACTi(A, Bits, Offset, Signed, CA);<br>
+  Â  if (!Eval)<br>
+  Â  Â  return false;<br>
+  Â  const Constant *C = intToConst(CA);<br>
+  Â  Result.add(C);<br>
+  }<br>
+  return true;<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateEXTRACTi(const APInt &A1, unsigned Bits,<br>
+  Â  Â  unsigned Offset, bool Signed, APInt &Result) {<br>
+  unsigned BW = A1.getBitWidth();<br>
+  assert(Bits+Offset <= BW);<br>
+  // Extracting 0 bits generates 0 as a result (as indicated by the HW people).<br>
+  if (Bits == 0) {<br>
+  Â  Result = APInt(BW, 0);<br>
+  Â  return true;<br>
+  }<br>
+  if (BW <= 64) {<br>
+  Â  int64_t V = A1.getZExtValue();<br>
+  Â  V <<= (64-Bits-Offset);<br>
+  Â  if (Signed)<br>
+  Â  Â  V >>= (64-Bits);<br>
+  Â  else<br>
+  Â  Â  V = static_cast<uint64_t>(V) >> (64-Bits);<br>
+  Â  Result = APInt(BW, V, Signed);<br>
+  Â  return true;<br>
+  }<br>
+  if (Signed)<br>
+  Â  Result = A1.shl(BW-Bits-Offset).ashr(BW-Bits);<br>
+  else<br>
+  Â  Result = A1.shl(BW-Bits-Offset).lshr(BW-Bits);<br>
+  return true;<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateSplatr(const Register &R1,<br>
+  Â  Â  unsigned Bits, unsigned Count, const CellMap &Inputs,<br>
+  Â  Â  LatticeCell &Result) {<br>
+  assert(Inputs.has(R1.Reg));<br>
+  LatticeCell LS1;<br>
+  if (!getCell(R1, Inputs, LS1))<br>
+  Â  return false;<br>
+  if (LS1.isBottom() || LS1.isProperty())<br>
+  Â  return false;<br>
+<br>
+  APInt A, SA;<br>
+  for (unsigned i = 0; i < LS1.size(); ++i) {<br>
+  Â  bool Eval = constToInt(LS1.Values[i], A) &&<br>
+  Â  Â  Â  Â  Â  Â  Â  evaluateSplati(A, Bits, Count, SA);<br>
+  Â  if (!Eval)<br>
+  Â  Â  return false;<br>
+  Â  const Constant *C = intToConst(SA);<br>
+  Â  Result.add(C);<br>
+  }<br>
+  return true;<br>
+}<br>
+<br>
+<br>
+bool MachineConstEvaluator::evaluateSplati(const APInt &A1, unsigned Bits,<br>
+  Â  Â  unsigned Count, APInt &Result) {<br>
+  assert(Count > 0);<br>
+  unsigned BW = A1.getBitWidth(), SW = Count*Bits;<br>
+  APInt LoBits = (Bits < BW) ? A1.trunc(Bits) : A1.zextOrSelf(Bits);<br>
+  if (Count > 1)<br>
+  Â  LoBits = LoBits.zext(SW);<br>
+<br>
+  APInt Res(SW, 0, false);<br>
+  for (unsigned i = 0; i < Count; ++i) {<br>
+  Â  Res <<= Bits;<br>
+  Â  Res |= LoBits;<br>
+  }<br>
+  Result = Res;<br>
+  return true;<br>
+}<br>
+<br>
+<br>
+// ----------------------------------------------------------------------<br>
+// Hexagon-specific code.<br>
+<br>
+namespace llvm {<br>
+  FunctionPass *createHexagonConstPropagationPass();<br>
+  void initializeHexagonConstPropagationPass(PassRegistry &Registry);<br>
+}<br>
+<br>
+namespace {<br>
+  class HexagonConstEvaluator : public MachineConstEvaluator {<br>
+  public:<br>
+  Â  HexagonConstEvaluator(MachineFunction &Fn);<br>
+<br>
+  Â  bool evaluate(const MachineInstr &MI, const CellMap &Inputs,<br>
+  Â  Â  Â  Â  CellMap &Outputs) override;<br>
+  Â  bool evaluate(const Register &R, const LatticeCell &SrcC,<br>
+  Â  Â  Â  Â  LatticeCell &Result) override;<br>
+  Â  bool evaluate(const MachineInstr &BrI, const CellMap &Inputs,<br>
+  Â  Â  Â  Â  SetVector<const MachineBasicBlock*> &Targets, bool &FallsThru)<br>
+  Â  Â  Â  Â  override;<br>
+  Â  bool rewrite(MachineInstr &MI, const CellMap &Inputs) override;<br>
+<br>
+<br>
+  private:<br>
+  Â  unsigned getRegBitWidth(unsigned Reg) const;<br>
+<br>
+  Â  static uint32_t getCmp(unsigned Opc);<br>
+  Â  static APInt getCmpImm(unsigned Opc, unsigned OpX,<br>
+  Â  Â  Â  Â  const MachineOperand &MO);<br>
+  Â  void replaceWithNop(MachineInstr &MI);<br>
+<br>
+  Â  bool evaluateHexRSEQ32(Register RL, Register RH, const CellMap &Inputs,<br>
+  Â  Â  Â  Â  LatticeCell &Result);<br>
+  Â  bool evaluateHexCompare(const MachineInstr &MI, const CellMap &Inputs,<br>
+  Â  Â  Â  Â  CellMap &Outputs);<br>
+  Â  // This is suitable to be called for compare-and-jump instructions.<br>
+  Â  bool evaluateHexCompare2(uint32_t Cmp, const MachineOperand &Src1,<br>
+  Â  Â  Â  Â  const MachineOperand &Src2, const CellMap &Inputs, bool &Result);<br>
+  Â  bool evaluateHexLogical(const MachineInstr &MI, const CellMap &Inputs,<br>
+  Â  Â  Â  Â  CellMap &Outputs);<br>
+  Â  bool evaluateHexCondMove(const MachineInstr &MI, const CellMap &Inputs,<br>
+  Â  Â  Â  Â  CellMap &Outputs);<br>
+  Â  bool evaluateHexExt(const MachineInstr &MI, const CellMap &Inputs,<br>
+  Â  Â  Â  Â  CellMap &Outputs);<br>
+  Â  bool evaluateHexVector1(const MachineInstr &MI, const CellMap &Inputs,<br>
+  Â  Â  Â  Â  CellMap &Outputs);<br>
+  Â  bool evaluateHexVector2(const MachineInstr &MI, const CellMap &Inputs,<br>
+  Â  Â  Â  Â  CellMap &Outputs);<br>
+<br>
+  Â  void replaceAllRegUsesWith(unsigned FromReg, unsigned ToReg);<br>
+  Â  bool rewriteHexBranch(MachineInstr &BrI, const CellMap &Inputs);<br>
+  Â  bool rewriteHexConstDefs(MachineInstr &MI, const CellMap &Inputs,<br>
+  Â  Â  Â  Â  bool &AllDefs);<br>
+  Â  bool rewriteHexConstUses(MachineInstr &MI, const CellMap &Inputs);<br>
+<br>
+  Â  MachineRegisterInfo *MRI;<br>
+  Â  const HexagonInstrInfo &HII;<br>
+  Â  const HexagonRegisterInfo &HRI;<br>
+  };<br>
+<br>
+<br>
+  class HexagonConstPropagation : public MachineFunctionPass {<br>
+  public:<br>
+  Â  static char ID;<br>
+  Â  HexagonConstPropagation() : MachineFunctionPass(ID) {<br>
+  Â  Â  PassRegistry &Registry = *PassRegistry::getPassRegistry();<br>
+  Â  Â  initializeHexagonConstPropagationPass(Registry);<br>
+  Â  }<br>
+  Â  const char *getPassName() const override {<br>
+  Â  Â  return "Hexagon Constant Propagation";<br>
+  Â  }<br>
+  Â  bool runOnMachineFunction(MachineFunction &MF) override {<br>
+  Â  Â  const Function *F = MF.getFunction();<br>
+  Â  Â  if (!F)<br>
+  Â  Â  Â  return false;<br>
+  Â  Â  if (skipFunction(*F))<br>
+  Â  Â  Â  return false;<br>
+<br>
+  Â  Â  HexagonConstEvaluator HCE(MF);<br>
+  Â  Â  return MachineConstPropagator(HCE).run(MF);<br>
+  Â  }<br>
+  };<br>
+<br>
+  char HexagonConstPropagation::ID = 0;<br>
+}<br>
+<br>
+INITIALIZE_PASS(HexagonConstPropagation, "hcp", "Hexagon Constant Propagation",<br>
+  Â  Â  Â  Â  Â  Â  Â  false, false)<br>
+<br>
+<br>
+HexagonConstEvaluator::HexagonConstEvaluator(MachineFunction &Fn)<br>
+  : MachineConstEvaluator(Fn),<br>
+  Â  HII(*Fn.getSubtarget<HexagonSubtarget>().getInstrInfo()),<br>
+  Â  HRI(*Fn.getSubtarget<HexagonSubtarget>().getRegisterInfo()) {<br>
+  MRI = &Fn.getRegInfo();<br>
+}<br>
+<br>
+<br>
+bool HexagonConstEvaluator::evaluate(const MachineInstr &MI,<br>
+  Â  Â  const CellMap &Inputs, CellMap &Outputs) {<br>
+  if (MI.isCall())<br>
+  Â  return false;<br>
+  if (MI.getNumOperands() == 0 || !MI.getOperand(0).isReg())<br>
+  Â  return false;<br>
+  const MachineOperand &MD = MI.getOperand(0);<br>
+  if (!MD.isDef())<br>
+  Â  return false;<br>
+<br>
+  unsigned Opc = MI.getOpcode();<br>
+  Register DefR(MD);<br>
+  assert(!DefR.SubReg);<br>
+  if (!TargetRegisterInfo::isVirtualRegister(DefR.Reg))<br>
+  Â  return false;<br>
+<br>
+  if (MI.isCopy()) {<br>
+  Â  LatticeCell RC;<br>
+  Â  Register SrcR(MI.getOperand(1));<br>
+  Â  bool Eval = evaluateCOPY(SrcR, Inputs, RC);<br>
+  Â  if (!Eval)<br>
+  Â  Â  return false;<br>
+  Â  Outputs.update(DefR.Reg, RC);<br>
+  Â  return true;<br>
+  }<br>
+  if (MI.isRegSequence()) {<br>
+  Â  unsigned Sub1 = MI.getOperand(2).getImm();<br>
+  Â  unsigned Sub2 = MI.getOperand(4).getImm();<br>
+  Â  if (Sub1 != Hexagon::subreg_loreg && Sub1 != Hexagon::subreg_hireg)<br>
+  Â  Â  return false;<br>
+  Â  if (Sub2 != Hexagon::subreg_loreg && Sub2 != Hexagon::subreg_hireg)<br>
+  Â  Â  return false;<br>
+  Â  assert(Sub1 != Sub2);<br>
+  Â  bool LoIs1 = (Sub1 == Hexagon::subreg_loreg);<br>
+  Â  const MachineOperand &OpLo = LoIs1 ? MI.getOperand(1) : MI.getOperand(3);<br>
+  Â  const MachineOperand &OpHi = LoIs1 ? MI.getOperand(3) : MI.getOperand(1);<br>
+  Â  LatticeCell RC;<br>
+  Â  Register SrcRL(OpLo), SrcRH(OpHi);<br>
+  Â  bool Eval = evaluateHexRSEQ32(SrcRL, SrcRH, Inputs, RC);<br>
+  Â  if (!Eval)<br>
+  Â  Â  return false;<br>
+  Â  Outputs.update(DefR.Reg, RC);<br>
+  Â  return true;<br>
+  }<br>
+  if (MI.isCompare()) {<br>
+  Â  bool Eval = evaluateHexCompare(MI, Inputs, Outputs);<br>
+  Â  return Eval;<br>
+  }<br>
+<br>
+  switch (Opc) {<br>
+  Â  defa</blockquote></div><div dir="ltr">-- <br></div><div data-smartmail="gmail_signature">Mike<br>Sent from phone</div>