From 04085ecd997f5ea65e6e3be2cc99ddedd8d25fcd Mon Sep 17 00:00:00 2001
From: Qian Matteo Chen <chq.matteo@gmail.com>
Date: Thu, 17 Dec 2020 05:06:19 -0800
Subject: [PATCH] [TypeShrinking] Fix styling issues

---
 include/revng-c/TypeShrinking/MFP.h | 24 ++++++++++++------------
 lib/TypeShrinking/BitLiveness.cpp   | 20 +++++++++++++-------
 lib/TypeShrinking/TypeShrinking.cpp |  6 +++---
 3 files changed, 28 insertions(+), 22 deletions(-)

diff --git a/include/revng-c/TypeShrinking/MFP.h b/include/revng-c/TypeShrinking/MFP.h
index 597a9b78f..713e2093c 100644
--- a/include/revng-c/TypeShrinking/MFP.h
+++ b/include/revng-c/TypeShrinking/MFP.h
@@ -25,8 +25,8 @@ concept same_as = std::is_same_v<T, U>;
 
 template<typename LatticeElement>
 struct MFPResult {
-  LatticeElement inValue;
-  LatticeElement outValue;
+  LatticeElement InValue;
+  LatticeElement OutValue;
 };
 
 /// GT is an instance of llvm::GraphTraits e.g. llvm::GraphTraits<GraphType>
@@ -53,19 +53,19 @@ concept MonotoneFrameworkInstance = requires(typename MFI::LatticeElement E1,
   // clang-format on
 };
 
-template<typename Label>
+template<typename ItemType>
 struct WorklistItem {
-  size_t priority;
-  Label label;
+  size_t Priority;
+  ItemType Item;
 
-  friend bool
-  operator<(const WorklistItem<Label> &a, const WorklistItem<Label> &b) {
-    return a.priority < b.priority;
+  friend bool operator<(const WorklistItem<ItemType> &Lhs,
+                        const WorklistItem<ItemType> &Rhs) {
+    return Lhs.Priority < Rhs.Priority;
   }
 
-  friend bool
-  operator==(const WorklistItem<Label> &a, const WorklistItem<Label> &b) {
-    return a.label < b.label;
+  friend bool operator==(const WorklistItem<ItemType> &Lhs,
+                         const WorklistItem<ItemType> &Rhs) {
+    return Lhs.Item < Rhs.Item;
   }
 };
 
@@ -129,7 +129,7 @@ getMaximalFixedPoint(const typename MFI::GraphType &Flow,
   // Step 2 iteration
   while (!Worklist.empty()) {
     WorklistItem<Label> First = *Worklist.begin();
-    Label Start = First.label;
+    Label Start = First.Item;
     Worklist.erase(First);
     for (Label End : successors<GT>(Start)) {
       auto &PartialStart = PartialAnalysis.at(Start);
diff --git a/lib/TypeShrinking/BitLiveness.cpp b/lib/TypeShrinking/BitLiveness.cpp
index 4f934b2b2..0323004c9 100644
--- a/lib/TypeShrinking/BitLiveness.cpp
+++ b/lib/TypeShrinking/BitLiveness.cpp
@@ -40,14 +40,20 @@ static llvm::RegisterPass<BitLivenessPass> X("bit-liveness",
 const uint32_t Top = std::numeric_limits<uint32_t>::max();
 
 bool isDataFlowSink(const Instruction *Ins) {
-  if (Ins->mayHaveSideEffects() || Ins->getOpcode() == Instruction::Call
-      || Ins->getOpcode() == Instruction::CallBr
-      || Ins->getOpcode() == Instruction::Ret
-      || Ins->getOpcode() == Instruction::Store
-      || Ins->getOpcode() == Instruction::Br
-      || Ins->getOpcode() == Instruction::IndirectBr)
+  if (Ins->mayHaveSideEffects()) {
     return true;
-  return false;
+  }
+  switch (Ins->getOpcode()) {
+  case Instruction::Call:
+  case Instruction::CallBr:
+  case Instruction::Ret:
+  case Instruction::Store:
+  case Instruction::Br:
+  case Instruction::IndirectBr:
+    return true;
+  default:
+    return false;
+  }
 }
 
 uint32_t getMaxOperandSize(Instruction *Ins) {
diff --git a/lib/TypeShrinking/TypeShrinking.cpp b/lib/TypeShrinking/TypeShrinking.cpp
index 44094aea3..275433ca6 100644
--- a/lib/TypeShrinking/TypeShrinking.cpp
+++ b/lib/TypeShrinking/TypeShrinking.cpp
@@ -84,7 +84,7 @@ bool TypeShrinking::runOnFunction(Function &F) {
   BitLivenessPass::AnalysisResult &FixedPoints = BitLiveness.getResult();
   bool HasChanges = false;
 
-  std::vector<uint32_t> Ranks = { 8, 16, 32, 64 };
+  const std::array<uint32_t, 4> Ranks = { 8, 16, 32, 64 };
 
   for (auto &[Label, Result] : FixedPoints) {
     auto *Ins = Label->Instruction;
@@ -93,10 +93,10 @@ bool TypeShrinking::runOnFunction(Function &F) {
     // (the least significant bits of the result depend only on the least
     // significant bits of the operands) we can down cast the operands and then
     // upcast the result
-    if (Result.outValue >= MinimumWidth.getValue() && isAddLike(Ins)) {
+    if (Result.OutValue >= MinimumWidth.getValue() && isAddLike(Ins)) {
       auto ClosestRank = std::lower_bound(Ranks.begin(),
                                           Ranks.end(),
-                                          Result.outValue);
+                                          Result.OutValue);
       if (ClosestRank != Ranks.end()
           && Ins->getType()->getScalarSizeInBits() > *ClosestRank) {
         auto Rank = *ClosestRank;