Use RPO for iterating blocks in TypeInference

Summary:
This reduces the time taken in TypeInference by over 35%,
and since TypeInference is the biggest part of the optimization
pipeline, it reduces the total time for compilation by over 10%.

Reviewed By: neildhar

Differential Revision: D66790755

fbshipit-source-id: f59d8d1db78ce73aaecf673dfff6e42fc2ca44b1

lib/Optimizer/Scalar/TypeInference.cpp

@@ -1158,11 +1158,19 @@ bool TypeInferenceImpl::runOnFunctionsAndVars(
       dbgs() << "\nStart Type Inference on " << functions.size()
              << " functions and " << vars.size() << "vars.\n");
 
+  // Post-order traversal of blocks for each function.
+  // Reverse when iterating, so that we visit the blocks in reverse post-order.
+  // Precomputed to avoid recomputing it in the inner loop.
+  llvh::DenseMap<Function *, std::vector<BasicBlock *>> funcPostOrders{};
+
   // Begin by clearing the existing types and storing pre-pass types.
   // This prevents us from relying on the previous inference pass's type info,
   // which can be too loose (if things have been simplified, etc.).
-  for (Function *F : functions)
+  // Also precompute the post-order traversal for each function.
+  for (Function *F : functions) {
     clearTypesInFunction(F);
+    funcPostOrders.try_emplace(F, postOrderAnalysis(F));
+  }
 
   for (Variable *V : vars) {
     prePassTypes_.try_emplace(V, V->getType());
@@ -1194,8 +1202,9 @@ bool TypeInferenceImpl::runOnFunctionsAndVars(
     // Infer types of instructions.
     bool inferredInst = false;
     for (Function *F : functions) {
-      for (auto &bbit : *F) {
-        for (auto &it : bbit) {
+      llvh::ArrayRef<BasicBlock *> postOrder = funcPostOrders[F];
+      for (auto *bbit : llvh::reverse(postOrder)) {
+        for (auto &it : *bbit) {
           Instruction *I = &it;
           inferredInst |= inferInstruction(I);
         }