diff --git a/llvm/lib/Target/Foot/FootISelDAGToDAG.cpp b/llvm/lib/Target/Foot/FootISelDAGToDAG.cpp
index 67042c77c4e9..a71ec3b59338 100644
--- a/llvm/lib/Target/Foot/FootISelDAGToDAG.cpp
+++ b/llvm/lib/Target/Foot/FootISelDAGToDAG.cpp
@@ -1,5 +1,5 @@
-#include "FootISelLowering.h"
 #include "Foot.h"
+#include "FootISelLowering.h"
 #include "FootTargetMachine.h"
 #include "MCTargetDesc/FootMCTargetDesc.h"
 #include "llvm/CodeGen/SelectionDAGISel.h"
@@ -51,7 +51,7 @@ private:
 
   void Select(SDNode *N) override;
 
-  ConstantSDNode *DoesConstantFitImm(SDNode* N);
+  ConstantSDNode *DoesConstantFitImm(SDNode *N);
 #include "FootGenDAGISel.inc"
 };
 
@@ -59,7 +59,7 @@ class FootDAGToDAGISelLegacy : public SelectionDAGISelLegacy {
 public:
   static char ID;
   FootDAGToDAGISelLegacy(FootTargetMachine &TM)
-    : SelectionDAGISelLegacy(ID, std::make_unique<FootDAGToDAGISel>(TM)) {}
+      : SelectionDAGISelLegacy(ID, std::make_unique<FootDAGToDAGISel>(TM)) {}
 
   StringRef getPassName() const override { return "FootDAGToDAGISelLegacy"; }
 };
@@ -71,13 +71,15 @@ void FootDAGToDAGISel::SelectLoad(SDNode *N, SDLoc &Loc) {
 
   SDValue Zero = CurDAG->getTargetConstant(0, Loc, MVT::i32);
 
-  if (GlobalAddressSDNode *GAN = dyn_cast<GlobalAddressSDNode>(Addr.getNode())) {
+  if (GlobalAddressSDNode *GAN =
+          dyn_cast<GlobalAddressSDNode>(Addr.getNode())) {
     Addr = CurDAG->getTargetGlobalAddress(GAN->getGlobal(), Loc, MVT::i32);
   }
 
-  SDValue Ops[] = { Addr, Zero, Chain };
+  SDValue Ops[] = {Addr, Zero, Chain};
 
-  SDNode *NewNode = CurDAG->getMachineNode(Foot::BWOR_D_I_M_A, Loc, {MVT::i32, MVT::Other}, Ops);
+  SDNode *NewNode = CurDAG->getMachineNode(Foot::BWOR_D_I_M_A, Loc,
+                                           {MVT::i32, MVT::Other}, Ops);
 
   ReplaceNode(N, NewNode);
 }
@@ -89,16 +91,17 @@ void FootDAGToDAGISel::SelectStore(SDNode *N, SDLoc &Loc) {
   SDValue Chain = SN->getChain();
 
   SDNode *Store;
-  if (ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Val.getNode())) {
+  ConstantSDNode *CN = dyn_cast<ConstantSDNode>(Val.getNode());
+  if (CN && CN->getSExtValue() >= 0 && CN->getSExtValue() <= 0xFFFF) {
     Val = CurDAG->getTargetConstant(CN->getSExtValue(), Loc, MVT::i32);
-    SDValue Ops[] = { Addr, Val, Chain };
+    SDValue Ops[] = {Addr, Val, Chain};
     Store = CurDAG->getMachineNode(Foot::CNST_STR_I_A, Loc, MVT::Other, Ops);
-  }
-  else {
+  } else {
     SDValue Zero = CurDAG->getTargetConstant(0, Loc, MVT::i32);
 
-    SDValue Ops[] = { Addr, Val, Zero, Chain };
-    Store = CurDAG->getMachineNode(Foot::BWOR_STR_I_D_M_A, Loc, MVT::Other, Ops);
+    SDValue Ops[] = {Addr, Val, Zero, Chain};
+    Store =
+        CurDAG->getMachineNode(Foot::BWOR_STR_I_D_M_A, Loc, MVT::Other, Ops);
   }
 
   ReplaceNode(N, Store);
@@ -112,8 +115,7 @@ void FootDAGToDAGISel::SelectAdd(SDNode *N, SDLoc &Loc) {
 
   if (isa<FrameIndexSDNode>(LHS.getNode())) {
     LHS_AddrMode = FOOT_ADDRMODE_I;
-  }
-  else if (ConstantSDNode *CN = DoesConstantFitImm(LHS.getNode())) {
+  } else if (ConstantSDNode *CN = DoesConstantFitImm(LHS.getNode())) {
     LHS = CurDAG->getTargetConstant(CN->getSExtValue(), Loc, MVT::i32);
     LHS_AddrMode = FOOT_ADDRMODE_M;
   }
@@ -122,8 +124,7 @@ void FootDAGToDAGISel::SelectAdd(SDNode *N, SDLoc &Loc) {
 
   if (isa<FrameIndexSDNode>(RHS.getNode())) {
     RHS_AddrMode = FOOT_ADDRMODE_I;
-  }
-  else if (ConstantSDNode *CN = DoesConstantFitImm(RHS.getNode())) {
+  } else if (ConstantSDNode *CN = DoesConstantFitImm(RHS.getNode())) {
     RHS = CurDAG->getTargetConstant(CN->getSExtValue(), Loc, MVT::i32);
     RHS_AddrMode = FOOT_ADDRMODE_M;
   }
@@ -131,30 +132,30 @@ void FootDAGToDAGISel::SelectAdd(SDNode *N, SDLoc &Loc) {
   unsigned Opc = Foot::ADDI_D_D_D_A;
 
   switch (LHS_AddrMode + FOOT_ADDRMODE_COUNT * RHS_AddrMode) {
-  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_M:
+  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_M:
     Opc = Foot::ADDI_D_D_M_A;
     break;
-  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::ADDI_D_D_I_A;
     break;
-  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_D:
+  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_D:
     Opc = Foot::ADDI_D_M_D_A;
     break;
-  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::ADDI_D_M_I_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_D:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_D:
     Opc = Foot::ADDI_D_I_D_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_M:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_M:
     Opc = Foot::ADDI_D_I_M_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::ADDI_D_I_I_A;
     break;
   }
 
-  SDValue Ops[] = { LHS, RHS };
+  SDValue Ops[] = {LHS, RHS};
 
   SDNode *NewNode = CurDAG->getMachineNode(Opc, Loc, MVT::i32, Ops);
 
@@ -169,8 +170,7 @@ void FootDAGToDAGISel::SelectSub(SDNode *N, SDLoc &Loc) {
 
   if (isa<FrameIndexSDNode>(LHS.getNode())) {
     LHS_AddrMode = FOOT_ADDRMODE_I;
-  }
-  else if (ConstantSDNode *CN = DoesConstantFitImm(LHS.getNode())) {
+  } else if (ConstantSDNode *CN = DoesConstantFitImm(LHS.getNode())) {
     LHS = CurDAG->getTargetConstant(CN->getSExtValue(), Loc, MVT::i32);
     LHS_AddrMode = FOOT_ADDRMODE_M;
   }
@@ -179,8 +179,7 @@ void FootDAGToDAGISel::SelectSub(SDNode *N, SDLoc &Loc) {
 
   if (isa<FrameIndexSDNode>(RHS.getNode())) {
     RHS_AddrMode = FOOT_ADDRMODE_I;
-  }
-  else if (ConstantSDNode *CN = DoesConstantFitImm(RHS.getNode())) {
+  } else if (ConstantSDNode *CN = DoesConstantFitImm(RHS.getNode())) {
     RHS = CurDAG->getTargetConstant(CN->getSExtValue(), Loc, MVT::i32);
     RHS_AddrMode = FOOT_ADDRMODE_M;
   }
@@ -188,30 +187,30 @@ void FootDAGToDAGISel::SelectSub(SDNode *N, SDLoc &Loc) {
   unsigned Opc = Foot::SUBT_D_D_D_A;
 
   switch (LHS_AddrMode + FOOT_ADDRMODE_COUNT * RHS_AddrMode) {
-  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_M:
+  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_M:
     Opc = Foot::SUBT_D_D_M_A;
     break;
-  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::SUBT_D_D_I_A;
     break;
-  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_D:
+  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_D:
     Opc = Foot::SUBT_D_M_D_A;
     break;
-  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::SUBT_D_M_I_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_D:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_D:
     Opc = Foot::SUBT_D_I_D_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_M:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_M:
     Opc = Foot::SUBT_D_I_M_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::SUBT_D_I_I_A;
     break;
   }
 
-  SDValue Ops[] = { LHS, RHS };
+  SDValue Ops[] = {LHS, RHS};
 
   SDNode *NewNode = CurDAG->getMachineNode(Opc, Loc, MVT::i32, Ops);
 
@@ -226,8 +225,7 @@ void FootDAGToDAGISel::SelectMul(SDNode *N, SDLoc &Loc) {
 
   if (isa<FrameIndexSDNode>(LHS.getNode())) {
     LHS_AddrMode = FOOT_ADDRMODE_I;
-  }
-  else if (ConstantSDNode *CN = DoesConstantFitImm(LHS.getNode())) {
+  } else if (ConstantSDNode *CN = DoesConstantFitImm(LHS.getNode())) {
     LHS = CurDAG->getTargetConstant(CN->getSExtValue(), Loc, MVT::i32);
     LHS_AddrMode = FOOT_ADDRMODE_M;
   }
@@ -236,8 +234,7 @@ void FootDAGToDAGISel::SelectMul(SDNode *N, SDLoc &Loc) {
 
   if (isa<FrameIndexSDNode>(RHS.getNode())) {
     RHS_AddrMode = FOOT_ADDRMODE_I;
-  }
-  else if (ConstantSDNode *CN = DoesConstantFitImm(RHS.getNode())) {
+  } else if (ConstantSDNode *CN = DoesConstantFitImm(RHS.getNode())) {
     RHS = CurDAG->getTargetConstant(CN->getSExtValue(), Loc, MVT::i32);
     RHS_AddrMode = FOOT_ADDRMODE_M;
   }
@@ -245,30 +242,30 @@ void FootDAGToDAGISel::SelectMul(SDNode *N, SDLoc &Loc) {
   unsigned Opc = Foot::MULT_D_D_D_A;
 
   switch (LHS_AddrMode + FOOT_ADDRMODE_COUNT * RHS_AddrMode) {
-  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_M:
+  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_M:
     Opc = Foot::MULT_D_D_M_A;
     break;
-  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::MULT_D_D_I_A;
     break;
-  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_D:
+  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_D:
     Opc = Foot::MULT_D_M_D_A;
     break;
-  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::MULT_D_M_I_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_D:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_D:
     Opc = Foot::MULT_D_I_D_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_M:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_M:
     Opc = Foot::MULT_D_I_M_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::MULT_D_I_I_A;
     break;
   }
 
-  SDValue Ops[] = { LHS, RHS };
+  SDValue Ops[] = {LHS, RHS};
 
   SDNode *NewNode = CurDAG->getMachineNode(Opc, Loc, MVT::i32, Ops);
 
@@ -283,8 +280,7 @@ void FootDAGToDAGISel::SelectSrem(SDNode *N, SDLoc &Loc) {
 
   if (isa<FrameIndexSDNode>(LHS.getNode())) {
     LHS_AddrMode = FOOT_ADDRMODE_I;
-  }
-  else if (ConstantSDNode *CN = DoesConstantFitImm(LHS.getNode())) {
+  } else if (ConstantSDNode *CN = DoesConstantFitImm(LHS.getNode())) {
     LHS = CurDAG->getTargetConstant(CN->getSExtValue(), Loc, MVT::i32);
     LHS_AddrMode = FOOT_ADDRMODE_M;
   }
@@ -293,8 +289,7 @@ void FootDAGToDAGISel::SelectSrem(SDNode *N, SDLoc &Loc) {
 
   if (isa<FrameIndexSDNode>(RHS.getNode())) {
     RHS_AddrMode = FOOT_ADDRMODE_I;
-  }
-  else if (ConstantSDNode *CN = DoesConstantFitImm(RHS.getNode())) {
+  } else if (ConstantSDNode *CN = DoesConstantFitImm(RHS.getNode())) {
     RHS = CurDAG->getTargetConstant(CN->getSExtValue(), Loc, MVT::i32);
     RHS_AddrMode = FOOT_ADDRMODE_M;
   }
@@ -302,30 +297,30 @@ void FootDAGToDAGISel::SelectSrem(SDNode *N, SDLoc &Loc) {
   unsigned Opc = Foot::MODU_D_D_D_A;
 
   switch (LHS_AddrMode + FOOT_ADDRMODE_COUNT * RHS_AddrMode) {
-  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_M:
+  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_M:
     Opc = Foot::MODU_D_D_M_A;
     break;
-  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::MODU_D_D_I_A;
     break;
-  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_D:
+  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_D:
     Opc = Foot::MODU_D_M_D_A;
     break;
-  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::MODU_D_M_I_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_D:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_D:
     Opc = Foot::MODU_D_I_D_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_M:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_M:
     Opc = Foot::MODU_D_I_M_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::MODU_D_I_I_A;
     break;
   }
 
-  SDValue Ops[] = { LHS, RHS };
+  SDValue Ops[] = {LHS, RHS};
 
   SDNode *NewNode = CurDAG->getMachineNode(Opc, Loc, MVT::i32, Ops);
 
@@ -340,8 +335,7 @@ void FootDAGToDAGISel::SelectOr(SDNode *N, SDLoc &Loc) {
 
   if (isa<FrameIndexSDNode>(LHS.getNode())) {
     LHS_AddrMode = FOOT_ADDRMODE_I;
-  }
-  else if (ConstantSDNode *CN = DoesConstantFitImm(LHS.getNode())) {
+  } else if (ConstantSDNode *CN = DoesConstantFitImm(LHS.getNode())) {
     LHS = CurDAG->getTargetConstant(CN->getSExtValue(), Loc, MVT::i32);
     LHS_AddrMode = FOOT_ADDRMODE_M;
   }
@@ -350,8 +344,7 @@ void FootDAGToDAGISel::SelectOr(SDNode *N, SDLoc &Loc) {
 
   if (isa<FrameIndexSDNode>(RHS.getNode())) {
     RHS_AddrMode = FOOT_ADDRMODE_I;
-  }
-  else if (ConstantSDNode *CN = DoesConstantFitImm(RHS.getNode())) {
+  } else if (ConstantSDNode *CN = DoesConstantFitImm(RHS.getNode())) {
     RHS = CurDAG->getTargetConstant(CN->getSExtValue(), Loc, MVT::i32);
     RHS_AddrMode = FOOT_ADDRMODE_M;
   }
@@ -359,30 +352,30 @@ void FootDAGToDAGISel::SelectOr(SDNode *N, SDLoc &Loc) {
   unsigned Opc = Foot::BWOR_D_D_D_A;
 
   switch (LHS_AddrMode + FOOT_ADDRMODE_COUNT * RHS_AddrMode) {
-  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_M:
+  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_M:
     Opc = Foot::BWOR_D_D_M_A;
     break;
-  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::BWOR_D_D_I_A;
     break;
-  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_D:
+  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_D:
     Opc = Foot::BWOR_D_M_D_A;
     break;
-  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::BWOR_D_M_I_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_D:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_D:
     Opc = Foot::BWOR_D_I_D_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_M:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_M:
     Opc = Foot::BWOR_D_I_M_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::BWOR_D_I_I_A;
     break;
   }
 
-  SDValue Ops[] = { LHS, RHS };
+  SDValue Ops[] = {LHS, RHS};
 
   SDNode *NewNode = CurDAG->getMachineNode(Opc, Loc, MVT::i32, Ops);
 
@@ -397,8 +390,7 @@ void FootDAGToDAGISel::SelectAnd(SDNode *N, SDLoc &Loc) {
 
   if (isa<FrameIndexSDNode>(LHS.getNode())) {
     LHS_AddrMode = FOOT_ADDRMODE_I;
-  }
-  else if (ConstantSDNode *CN = DoesConstantFitImm(LHS.getNode())) {
+  } else if (ConstantSDNode *CN = DoesConstantFitImm(LHS.getNode())) {
     LHS = CurDAG->getTargetConstant(CN->getSExtValue(), Loc, MVT::i32);
     LHS_AddrMode = FOOT_ADDRMODE_M;
   }
@@ -407,8 +399,7 @@ void FootDAGToDAGISel::SelectAnd(SDNode *N, SDLoc &Loc) {
 
   if (isa<FrameIndexSDNode>(RHS.getNode())) {
     RHS_AddrMode = FOOT_ADDRMODE_I;
-  }
-  else if (ConstantSDNode *CN = DoesConstantFitImm(RHS.getNode())) {
+  } else if (ConstantSDNode *CN = DoesConstantFitImm(RHS.getNode())) {
     RHS = CurDAG->getTargetConstant(CN->getSExtValue(), Loc, MVT::i32);
     RHS_AddrMode = FOOT_ADDRMODE_M;
   }
@@ -416,30 +407,30 @@ void FootDAGToDAGISel::SelectAnd(SDNode *N, SDLoc &Loc) {
   unsigned Opc = Foot::BAND_D_D_D_A;
 
   switch (LHS_AddrMode + FOOT_ADDRMODE_COUNT * RHS_AddrMode) {
-  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_M:
+  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_M:
     Opc = Foot::BAND_D_D_M_A;
     break;
-  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::BAND_D_D_I_A;
     break;
-  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_D:
+  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_D:
     Opc = Foot::BAND_D_M_D_A;
     break;
-  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::BAND_D_M_I_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_D:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_D:
     Opc = Foot::BAND_D_I_D_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_M:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_M:
     Opc = Foot::BAND_D_I_M_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::BAND_D_I_I_A;
     break;
   }
 
-  SDValue Ops[] = { LHS, RHS };
+  SDValue Ops[] = {LHS, RHS};
 
   SDNode *NewNode = CurDAG->getMachineNode(Opc, Loc, MVT::i32, Ops);
 
@@ -454,8 +445,7 @@ void FootDAGToDAGISel::SelectXor(SDNode *N, SDLoc &Loc) {
 
   if (isa<FrameIndexSDNode>(LHS.getNode())) {
     LHS_AddrMode = FOOT_ADDRMODE_I;
-  }
-  else if (ConstantSDNode *CN = DoesConstantFitImm(LHS.getNode())) {
+  } else if (ConstantSDNode *CN = DoesConstantFitImm(LHS.getNode())) {
     LHS = CurDAG->getTargetConstant(CN->getSExtValue(), Loc, MVT::i32);
     LHS_AddrMode = FOOT_ADDRMODE_M;
   }
@@ -464,8 +454,7 @@ void FootDAGToDAGISel::SelectXor(SDNode *N, SDLoc &Loc) {
 
   if (isa<FrameIndexSDNode>(RHS.getNode())) {
     RHS_AddrMode = FOOT_ADDRMODE_I;
-  }
-  else if (ConstantSDNode *CN = DoesConstantFitImm(RHS.getNode())) {
+  } else if (ConstantSDNode *CN = DoesConstantFitImm(RHS.getNode())) {
     RHS = CurDAG->getTargetConstant(CN->getSExtValue(), Loc, MVT::i32);
     RHS_AddrMode = FOOT_ADDRMODE_M;
   }
@@ -473,30 +462,30 @@ void FootDAGToDAGISel::SelectXor(SDNode *N, SDLoc &Loc) {
   unsigned Opc = Foot::BXOR_D_D_D_A;
 
   switch (LHS_AddrMode + FOOT_ADDRMODE_COUNT * RHS_AddrMode) {
-  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_M:
+  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_M:
     Opc = Foot::BXOR_D_D_M_A;
     break;
-  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::BXOR_D_D_I_A;
     break;
-  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_D:
+  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_D:
     Opc = Foot::BXOR_D_M_D_A;
     break;
-  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::BXOR_D_M_I_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_D:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_D:
     Opc = Foot::BXOR_D_I_D_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_M:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_M:
     Opc = Foot::BXOR_D_I_M_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::BXOR_D_I_I_A;
     break;
   }
 
-  SDValue Ops[] = { LHS, RHS };
+  SDValue Ops[] = {LHS, RHS};
 
   SDNode *NewNode = CurDAG->getMachineNode(Opc, Loc, MVT::i32, Ops);
 
@@ -511,8 +500,7 @@ void FootDAGToDAGISel::SelectShl(SDNode *N, SDLoc &Loc) {
 
   if (isa<FrameIndexSDNode>(LHS.getNode())) {
     LHS_AddrMode = FOOT_ADDRMODE_I;
-  }
-  else if (ConstantSDNode *CN = DoesConstantFitImm(LHS.getNode())) {
+  } else if (ConstantSDNode *CN = DoesConstantFitImm(LHS.getNode())) {
     LHS = CurDAG->getTargetConstant(CN->getSExtValue(), Loc, MVT::i32);
     LHS_AddrMode = FOOT_ADDRMODE_M;
   }
@@ -521,8 +509,7 @@ void FootDAGToDAGISel::SelectShl(SDNode *N, SDLoc &Loc) {
 
   if (isa<FrameIndexSDNode>(RHS.getNode())) {
     RHS_AddrMode = FOOT_ADDRMODE_I;
-  }
-  else if (ConstantSDNode *CN = DoesConstantFitImm(RHS.getNode())) {
+  } else if (ConstantSDNode *CN = DoesConstantFitImm(RHS.getNode())) {
     RHS = CurDAG->getTargetConstant(CN->getSExtValue(), Loc, MVT::i32);
     RHS_AddrMode = FOOT_ADDRMODE_M;
   }
@@ -530,30 +517,30 @@ void FootDAGToDAGISel::SelectShl(SDNode *N, SDLoc &Loc) {
   unsigned Opc = Foot::ZLSH_D_D_D_A;
 
   switch (LHS_AddrMode + FOOT_ADDRMODE_COUNT * RHS_AddrMode) {
-  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_M:
+  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_M:
     Opc = Foot::ZLSH_D_D_M_A;
     break;
-  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::ZLSH_D_D_I_A;
     break;
-  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_D:
+  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_D:
     Opc = Foot::ZLSH_D_M_D_A;
     break;
-  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::ZLSH_D_M_I_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_D:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_D:
     Opc = Foot::ZLSH_D_I_D_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_M:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_M:
     Opc = Foot::ZLSH_D_I_M_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::ZLSH_D_I_I_A;
     break;
   }
 
-  SDValue Ops[] = { LHS, RHS };
+  SDValue Ops[] = {LHS, RHS};
 
   SDNode *NewNode = CurDAG->getMachineNode(Opc, Loc, MVT::i32, Ops);
 
@@ -568,8 +555,7 @@ void FootDAGToDAGISel::SelectSra(SDNode *N, SDLoc &Loc) {
 
   if (isa<FrameIndexSDNode>(LHS.getNode())) {
     LHS_AddrMode = FOOT_ADDRMODE_I;
-  }
-  else if (ConstantSDNode *CN = DoesConstantFitImm(LHS.getNode())) {
+  } else if (ConstantSDNode *CN = DoesConstantFitImm(LHS.getNode())) {
     LHS = CurDAG->getTargetConstant(CN->getSExtValue(), Loc, MVT::i32);
     LHS_AddrMode = FOOT_ADDRMODE_M;
   }
@@ -578,8 +564,7 @@ void FootDAGToDAGISel::SelectSra(SDNode *N, SDLoc &Loc) {
 
   if (isa<FrameIndexSDNode>(RHS.getNode())) {
     RHS_AddrMode = FOOT_ADDRMODE_I;
-  }
-  else if (ConstantSDNode *CN = DoesConstantFitImm(RHS.getNode())) {
+  } else if (ConstantSDNode *CN = DoesConstantFitImm(RHS.getNode())) {
     RHS = CurDAG->getTargetConstant(CN->getSExtValue(), Loc, MVT::i32);
     RHS_AddrMode = FOOT_ADDRMODE_M;
   }
@@ -587,30 +572,30 @@ void FootDAGToDAGISel::SelectSra(SDNode *N, SDLoc &Loc) {
   unsigned Opc = Foot::SRSH_D_D_D_A;
 
   switch (LHS_AddrMode + FOOT_ADDRMODE_COUNT * RHS_AddrMode) {
-  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_M:
+  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_M:
     Opc = Foot::SRSH_D_D_M_A;
     break;
-  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::SRSH_D_D_I_A;
     break;
-  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_D:
+  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_D:
     Opc = Foot::SRSH_D_M_D_A;
     break;
-  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::SRSH_D_M_I_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_D:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_D:
     Opc = Foot::SRSH_D_I_D_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_M:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_M:
     Opc = Foot::SRSH_D_I_M_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::SRSH_D_I_I_A;
     break;
   }
 
-  SDValue Ops[] = { LHS, RHS };
+  SDValue Ops[] = {LHS, RHS};
 
   SDNode *NewNode = CurDAG->getMachineNode(Opc, Loc, MVT::i32, Ops);
 
@@ -625,8 +610,7 @@ void FootDAGToDAGISel::SelectSrl(SDNode *N, SDLoc &Loc) {
 
   if (isa<FrameIndexSDNode>(LHS.getNode())) {
     LHS_AddrMode = FOOT_ADDRMODE_I;
-  } 
-  else if (ConstantSDNode *CN = DoesConstantFitImm(LHS.getNode())) {
+  } else if (ConstantSDNode *CN = DoesConstantFitImm(LHS.getNode())) {
     LHS = CurDAG->getTargetConstant(CN->getSExtValue(), Loc, MVT::i32);
     LHS_AddrMode = FOOT_ADDRMODE_M;
   }
@@ -635,8 +619,7 @@ void FootDAGToDAGISel::SelectSrl(SDNode *N, SDLoc &Loc) {
 
   if (isa<FrameIndexSDNode>(RHS.getNode())) {
     RHS_AddrMode = FOOT_ADDRMODE_I;
-  }
-  else if (ConstantSDNode *CN = DoesConstantFitImm(RHS.getNode())) {
+  } else if (ConstantSDNode *CN = DoesConstantFitImm(RHS.getNode())) {
     RHS = CurDAG->getTargetConstant(CN->getSExtValue(), Loc, MVT::i32);
     RHS_AddrMode = FOOT_ADDRMODE_M;
   }
@@ -644,30 +627,30 @@ void FootDAGToDAGISel::SelectSrl(SDNode *N, SDLoc &Loc) {
   unsigned Opc = Foot::ZRSH_D_D_D_A;
 
   switch (LHS_AddrMode + FOOT_ADDRMODE_COUNT * RHS_AddrMode) {
-  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_M:
+  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_M:
     Opc = Foot::ZRSH_D_D_M_A;
     break;
-  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::ZRSH_D_D_I_A;
     break;
-  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_D:
+  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_D:
     Opc = Foot::ZRSH_D_M_D_A;
     break;
-  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::ZRSH_D_M_I_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_D:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_D:
     Opc = Foot::ZRSH_D_I_D_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_M:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_M:
     Opc = Foot::ZRSH_D_I_M_A;
     break;
-  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_I:
+  case FOOT_ADDRMODE_I + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_I:
     Opc = Foot::ZRSH_D_I_I_A;
     break;
   }
 
-  SDValue Ops[] = { LHS, RHS };
+  SDValue Ops[] = {LHS, RHS};
 
   SDNode *NewNode = CurDAG->getMachineNode(Opc, Loc, MVT::i32, Ops);
 
@@ -681,7 +664,8 @@ void FootDAGToDAGISel::SelectConstant(SDNode *N, SDLoc &Loc) {
   SDNode *NewNode;
 
   int64_t Val = CN->getSExtValue();
-  assert(Val >= -static_cast<int64_t>(0xFFFFFFFF) && Val <= 0xFFFFFFFF && "Constant too large!");
+  assert(Val >= -static_cast<int64_t>(0xFFFFFFFF) && Val <= 0xFFFFFFFF &&
+         "Constant too large!");
 
   Val &= 0xFFFFFFFF;
 
@@ -689,11 +673,12 @@ void FootDAGToDAGISel::SelectConstant(SDNode *N, SDLoc &Loc) {
     APInt Adjusted(32, Val);
     ConstantInt *CI = ConstantInt::get(*CurDAG->getContext(), Adjusted);
     SDValue TgtVal = CurDAG->getTargetConstantPool(CI, MVT::i32);
-    SDNode *Addr = CurDAG->getMachineNode(Foot::CNST_D_A, Loc, MVT::i32, TgtVal);
+    SDNode *Addr =
+        CurDAG->getMachineNode(Foot::CNST_D_A, Loc, MVT::i32, TgtVal);
     SDValue Zero = CurDAG->getTargetConstant(0, Loc, MVT::i32);
-    NewNode = CurDAG->getMachineNode(Foot::BWOR_D_I_M_A, Loc, MVT::i32, {SDValue(Addr, 0), Zero});
-  }
-  else {
+    NewNode = CurDAG->getMachineNode(Foot::BWOR_D_I_M_A, Loc, MVT::i32,
+                                     {SDValue(Addr, 0), Zero});
+  } else {
     SDValue TgtVal = CurDAG->getTargetConstant(Val, Loc, MVT::i32);
     NewNode = CurDAG->getMachineNode(Foot::CNST_D_A, Loc, MVT::i32, TgtVal);
   }
@@ -705,9 +690,11 @@ void FootDAGToDAGISel::SelectGlobalAddress(SDNode *N, SDLoc &Loc) {
   assert(isa<GlobalAddressSDNode>(N) && "expected global address");
   GlobalAddressSDNode *GAN = cast<GlobalAddressSDNode>(N);
 
-  SDValue TgtGA = CurDAG->getTargetGlobalAddress(GAN->getGlobal(), Loc, MVT::i32);
+  SDValue TgtGA =
+      CurDAG->getTargetGlobalAddress(GAN->getGlobal(), Loc, MVT::i32);
 
-  SDNode *NewNode = CurDAG->getMachineNode(Foot::CNST_D_A, Loc, MVT::i32, TgtGA);
+  SDNode *NewNode =
+      CurDAG->getMachineNode(Foot::CNST_D_A, Loc, MVT::i32, TgtGA);
 
   ReplaceNode(N, NewNode);
 }
@@ -729,11 +716,13 @@ void FootDAGToDAGISel::SelectCall(SDNode *N, SDLoc &Loc) {
   SDValue RRA = CurDAG->getRegister(Foot::RRA, MVT::i32);
   SDValue One = CurDAG->getTargetConstant(1, Loc, MVT::i32);
 
-  SDValue CopyOps[] = { RRA, RPC, One, Chain };
-  SDNode *CopyToRA = CurDAG->getMachineNode(Foot::ADDI_STR_D_D_M_A, Loc, MVT::Other, CopyOps);
+  SDValue CopyOps[] = {RRA, RPC, One, Chain};
+  SDNode *CopyToRA =
+      CurDAG->getMachineNode(Foot::ADDI_STR_D_D_M_A, Loc, MVT::Other, CopyOps);
 
-  SDValue Ops[] = { RPC, Callee, SDValue(CopyToRA, 0) };
-  SDNode *Jump = CurDAG->getMachineNode(Foot::CNST_JMP_D_A, Loc, {MVT::Other, MVT::Glue}, Ops);
+  SDValue Ops[] = {RPC, Callee, SDValue(CopyToRA, 0)};
+  SDNode *Jump = CurDAG->getMachineNode(Foot::CNST_JMP_D_A, Loc,
+                                        {MVT::Other, MVT::Glue}, Ops);
 
   ReplaceNode(N, Jump);
 }
@@ -762,19 +751,20 @@ void FootDAGToDAGISel::SelectCmpChain(SDNode *N, SDLoc &Loc) {
   unsigned Opc = Foot::CMPR_D_D_A;
 
   switch (LHS_AddrMode + FOOT_ADDRMODE_COUNT * RHS_AddrMode) {
-  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_M:
+  case FOOT_ADDRMODE_D + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_M:
     Opc = Foot::CMPR_D_M_A;
     break;
-  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_D:
+  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_D:
     Opc = Foot::CMPR_M_D_A;
     break;
-  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT * FOOT_ADDRMODE_M:
+  case FOOT_ADDRMODE_M + FOOT_ADDRMODE_COUNT *FOOT_ADDRMODE_M:
     Opc = Foot::CMPR_M_M_A;
     break;
   }
 
   // swap LHS and RHS, as dst is 'b' operand, so it should be first
-  SDNode *NewNode = CurDAG->getMachineNode(Opc, Loc, MVT::Other, {RHS, LHS, Chain});
+  SDNode *NewNode =
+      CurDAG->getMachineNode(Opc, Loc, MVT::Other, {RHS, LHS, Chain});
 
   ReplaceNode(N, NewNode);
 }
@@ -785,12 +775,14 @@ void FootDAGToDAGISel::SelectBr(SDNode *N, SDLoc &Loc) {
   SDValue Target = N->getOperand(1);
 
   SDNode *NewNode;
-  if (isa<BasicBlockSDNode>(Target.getNode()) || isa<GlobalAddressSDNode>(Target.getNode())) {
-    NewNode = CurDAG->getMachineNode(Foot::CNST_JMP_D_A, Loc, MVT::Other, {PC, Target, Chain});
-  }
-  else {
+  if (isa<BasicBlockSDNode>(Target.getNode()) ||
+      isa<GlobalAddressSDNode>(Target.getNode())) {
+    NewNode = CurDAG->getMachineNode(Foot::CNST_JMP_D_A, Loc, MVT::Other,
+                                     {PC, Target, Chain});
+  } else {
     SDValue Zero = CurDAG->getTargetConstant(0, Loc, MVT::i32);
-    NewNode = CurDAG->getMachineNode(Foot::BWOR_JMP_D_D_M_A, Loc, MVT::Other, {PC, Target, Zero, Chain});
+    NewNode = CurDAG->getMachineNode(Foot::BWOR_JMP_D_D_M_A, Loc, MVT::Other,
+                                     {PC, Target, Zero, Chain});
   }
 
   ReplaceNode(N, NewNode);
@@ -802,12 +794,14 @@ void FootDAGToDAGISel::SelectBrL(SDNode *N, SDLoc &Loc) {
   SDValue Chain = N->getOperand(1);
 
   SDNode *NewNode;
-  if (isa<BasicBlockSDNode>(Target.getNode()) || isa<GlobalAddressSDNode>(Target.getNode())) {
-    NewNode = CurDAG->getMachineNode(Foot::CNST_JMP_D_L, Loc, MVT::Other, {PC, Target, Chain});
-  }
-  else {
+  if (isa<BasicBlockSDNode>(Target.getNode()) ||
+      isa<GlobalAddressSDNode>(Target.getNode())) {
+    NewNode = CurDAG->getMachineNode(Foot::CNST_JMP_D_L, Loc, MVT::Other,
+                                     {PC, Target, Chain});
+  } else {
     SDValue Zero = CurDAG->getTargetConstant(0, Loc, MVT::i32);
-    NewNode = CurDAG->getMachineNode(Foot::BWOR_JMP_D_D_M_L, Loc, MVT::Other, {PC, Target, Zero, Chain});
+    NewNode = CurDAG->getMachineNode(Foot::BWOR_JMP_D_D_M_L, Loc, MVT::Other,
+                                     {PC, Target, Zero, Chain});
   }
 
   ReplaceNode(N, NewNode);
@@ -819,12 +813,14 @@ void FootDAGToDAGISel::SelectBrLE(SDNode *N, SDLoc &Loc) {
   SDValue Chain = N->getOperand(1);
 
   SDNode *NewNode;
-  if (isa<BasicBlockSDNode>(Target.getNode()) || isa<GlobalAddressSDNode>(Target.getNode())) {
-    NewNode = CurDAG->getMachineNode(Foot::CNST_JMP_D_LE, Loc, MVT::Other, {PC, Target, Chain});
-  }
-  else {
+  if (isa<BasicBlockSDNode>(Target.getNode()) ||
+      isa<GlobalAddressSDNode>(Target.getNode())) {
+    NewNode = CurDAG->getMachineNode(Foot::CNST_JMP_D_LE, Loc, MVT::Other,
+                                     {PC, Target, Chain});
+  } else {
     SDValue Zero = CurDAG->getTargetConstant(0, Loc, MVT::i32);
-    NewNode = CurDAG->getMachineNode(Foot::BWOR_JMP_D_D_M_LE, Loc, MVT::Other, {PC, Target, Zero, Chain});
+    NewNode = CurDAG->getMachineNode(Foot::BWOR_JMP_D_D_M_LE, Loc, MVT::Other,
+                                     {PC, Target, Zero, Chain});
   }
 
   ReplaceNode(N, NewNode);
@@ -836,12 +832,14 @@ void FootDAGToDAGISel::SelectBrE(SDNode *N, SDLoc &Loc) {
   SDValue Chain = N->getOperand(1);
 
   SDNode *NewNode;
-  if (isa<BasicBlockSDNode>(Target.getNode()) || isa<GlobalAddressSDNode>(Target.getNode())) {
-    NewNode = CurDAG->getMachineNode(Foot::CNST_JMP_D_E, Loc, MVT::Other, {PC, Target, Chain});
-  }
-  else {
+  if (isa<BasicBlockSDNode>(Target.getNode()) ||
+      isa<GlobalAddressSDNode>(Target.getNode())) {
+    NewNode = CurDAG->getMachineNode(Foot::CNST_JMP_D_E, Loc, MVT::Other,
+                                     {PC, Target, Chain});
+  } else {
     SDValue Zero = CurDAG->getTargetConstant(0, Loc, MVT::i32);
-    NewNode = CurDAG->getMachineNode(Foot::BWOR_JMP_D_D_M_E, Loc, MVT::Other, {PC, Target, Zero, Chain});
+    NewNode = CurDAG->getMachineNode(Foot::BWOR_JMP_D_D_M_E, Loc, MVT::Other,
+                                     {PC, Target, Zero, Chain});
   }
 
   ReplaceNode(N, NewNode);
@@ -853,12 +851,14 @@ void FootDAGToDAGISel::SelectBrGE(SDNode *N, SDLoc &Loc) {
   SDValue Chain = N->getOperand(1);
 
   SDNode *NewNode;
-  if (isa<BasicBlockSDNode>(Target.getNode()) || isa<GlobalAddressSDNode>(Target.getNode())) {
-    NewNode = CurDAG->getMachineNode(Foot::CNST_JMP_D_GE, Loc, MVT::Other, {PC, Target, Chain});
-  }
-  else {
+  if (isa<BasicBlockSDNode>(Target.getNode()) ||
+      isa<GlobalAddressSDNode>(Target.getNode())) {
+    NewNode = CurDAG->getMachineNode(Foot::CNST_JMP_D_GE, Loc, MVT::Other,
+                                     {PC, Target, Chain});
+  } else {
     SDValue Zero = CurDAG->getTargetConstant(0, Loc, MVT::i32);
-    NewNode = CurDAG->getMachineNode(Foot::BWOR_JMP_D_D_M_GE, Loc, MVT::Other, {PC, Target, Zero, Chain});
+    NewNode = CurDAG->getMachineNode(Foot::BWOR_JMP_D_D_M_GE, Loc, MVT::Other,
+                                     {PC, Target, Zero, Chain});
   }
 
   ReplaceNode(N, NewNode);
@@ -870,12 +870,14 @@ void FootDAGToDAGISel::SelectBrG(SDNode *N, SDLoc &Loc) {
   SDValue Chain = N->getOperand(1);
 
   SDNode *NewNode;
-  if (isa<BasicBlockSDNode>(Target.getNode()) || isa<GlobalAddressSDNode>(Target.getNode())) {
-    NewNode = CurDAG->getMachineNode(Foot::CNST_JMP_D_G, Loc, MVT::Other, {PC, Target, Chain});
-  }
-  else {
+  if (isa<BasicBlockSDNode>(Target.getNode()) ||
+      isa<GlobalAddressSDNode>(Target.getNode())) {
+    NewNode = CurDAG->getMachineNode(Foot::CNST_JMP_D_G, Loc, MVT::Other,
+                                     {PC, Target, Chain});
+  } else {
     SDValue Zero = CurDAG->getTargetConstant(0, Loc, MVT::i32);
-    NewNode = CurDAG->getMachineNode(Foot::BWOR_JMP_D_D_M_G, Loc, MVT::Other, {PC, Target, Zero, Chain});
+    NewNode = CurDAG->getMachineNode(Foot::BWOR_JMP_D_D_M_G, Loc, MVT::Other,
+                                     {PC, Target, Zero, Chain});
   }
 
   ReplaceNode(N, NewNode);
@@ -887,12 +889,14 @@ void FootDAGToDAGISel::SelectBrNE(SDNode *N, SDLoc &Loc) {
   SDValue Chain = N->getOperand(1);
 
   SDNode *NewNode;
-  if (isa<BasicBlockSDNode>(Target.getNode()) || isa<GlobalAddressSDNode>(Target.getNode())) {
-    NewNode = CurDAG->getMachineNode(Foot::CNST_JMP_D_NE, Loc, MVT::Other, {PC, Target, Chain});
-  }
-  else {
+  if (isa<BasicBlockSDNode>(Target.getNode()) ||
+      isa<GlobalAddressSDNode>(Target.getNode())) {
+    NewNode = CurDAG->getMachineNode(Foot::CNST_JMP_D_NE, Loc, MVT::Other,
+                                     {PC, Target, Chain});
+  } else {
     SDValue Zero = CurDAG->getTargetConstant(0, Loc, MVT::i32);
-    NewNode = CurDAG->getMachineNode(Foot::BWOR_JMP_D_D_M_NE, Loc, MVT::Other, {PC, Target, Zero, Chain});
+    NewNode = CurDAG->getMachineNode(Foot::BWOR_JMP_D_D_M_NE, Loc, MVT::Other,
+                                     {PC, Target, Zero, Chain});
   }
 
   ReplaceNode(N, NewNode);
@@ -939,7 +943,8 @@ void FootDAGToDAGISel::SelectSelectCC(SDNode *N, SDLoc &Loc) {
 
   SDValue TCC = CurDAG->getTargetConstant(TCCVal, Loc, MVT::i32);
 
-  SDNode *Pseudo = CurDAG->getMachineNode(Foot::PSEUDO_SELECT, Loc, MVT::i32, {LHS, RHS, IfTrue, IfFalse, TCC});
+  SDNode *Pseudo = CurDAG->getMachineNode(Foot::PSEUDO_SELECT, Loc, MVT::i32,
+                                          {LHS, RHS, IfTrue, IfFalse, TCC});
 
   ReplaceNode(N, Pseudo);
 }