[mlir][llvm] Improve lookups in LLVM IR import (NFC).

[gysit]

Summary

This revision uses contains in favor of count when
searching sets and maps. Additionally it uses find
instead of count and lookup, which avoids searching
some maps twice.

[Dinistro]

LGTM!

mlir/lib/Target/LLVMIR/ModuleImport.cpp

#include "mlir/Dialect/LLVMIR/LLVMOpFromLLVMIRConversions.inc"
   return failure();
 }
 
 /// Get a topologically sorted list of blocks for the given function.
 static SetVector<llvm::BasicBlock *>
 getTopologicallySortedBlocks(llvm::Function *func) {
   SetVector<llvm::BasicBlock *> blocks;
   for (llvm::BasicBlock &bb : *func) {
-    if (blocks.count(&bb) == 0) {
+    if (!blocks.contains(&bb)) {
       llvm::ReversePostOrderTraversal<llvm::BasicBlock *> traversal(&bb);
       blocks.insert(traversal.begin(), traversal.end());
     }
   }
   assert(blocks.size() == func->size() && "some blocks are not sorted");
 
   return blocks;
 }

 
 LogicalResult ModuleImport::processTBAAMetadata(const llvm::MDNode *node) {
   Location loc = mlirModule.getLoc();
   SmallVector<const llvm::MDNode *> workList;
   SetVector<const llvm::MDNode *> nodesToConvert;
   workList.push_back(node);
   while (!workList.empty()) {
     const llvm::MDNode *current = workList.pop_back_val();
-    if (tbaaMapping.count(current))
+    if (tbaaMapping.contains(current))
       continue;
     // Allow cycles in TBAA metadata. Just import it as-is,
     // and diagnose the problem during LLVMIR dialect verification.
     if (!nodesToConvert.insert(current))
       continue;
     for (const llvm::MDOperand &operand : current->operands())
       if (auto *opNode = dyn_cast_or_null<const llvm::MDNode>(operand.get()))
         workList.push_back(opNode);
if (const auto *scope = dyn_cast<llvm::MDNode>(operand)) {
       // node before.
       if (!verifySelfRef(scope) || !domain || !verifyDescription(scope, 2))
         return emitError(loc) << "unsupported alias scope node: "
                               << diagMD(scope, llvmModule.get());
       if (!verifySelfRef(domain) || !verifyDescription(domain, 1))
         return emitError(loc) << "unsupported alias domain node: "
                               << diagMD(domain, llvmModule.get());
 
-      if (aliasScopeMapping.count(scope))
+      if (aliasScopeMapping.contains(scope))
         continue;
 
       // Set the insertion point to the end of the global metadata operation.
       MetadataOp metadataOp = getGlobalMetadataOp();
       StringAttr metadataOpName =
           SymbolTable::getSymbolName(getGlobalMetadataOp());
       OpBuilder::InsertionGuard guard(builder);
       builder.setInsertionPointToEnd(&metadataOp.getBody().back());
globalInsertionOp = builder.create<LLVM::GlobalDtorsOp>(
       mlirModule.getLoc(), builder.getArrayAttr(funcs),
       builder.getI32ArrayAttr(priorities));
   return success();
 }
 
 SetVector<llvm::Constant *>
 ModuleImport::getConstantsToConvert(llvm::Constant *constant) {
   // Return the empty set if the constant has been translated before.
-  if (valueMapping.count(constant))
+  if (valueMapping.contains(constant))
     return {};
 
   // Traverse the constants in post-order and stop the traversal if a constant
   // already has a `valueMapping` from an earlier constant translation or if the
   // constant is traversed a second time.
   SetVector<llvm::Constant *> orderedSet;
   SetVector<llvm::Constant *> workList;
   DenseMap<llvm::Constant *, SmallVector<llvm::Constant *>> adjacencyLists;
if (adjacencyIt->getSecond().empty()) {
       continue;
     }
     // Add the next dependency from the adjacency list to the `workList` and
     // continue the traversal. Remove the dependency from the adjacency list to
     // mark that it has been processed. Only enqueue the dependency if it has no
     // `valueMapping` from an earlier translation and if it has not been
     // enqueued before.
     llvm::Constant *dependency = adjacencyIt->getSecond().pop_back_val();
-    if (valueMapping.count(dependency) || workList.count(dependency) ||
-        orderedSet.count(dependency))
+    if (valueMapping.contains(dependency) || workList.contains(dependency) ||
+        orderedSet.contains(dependency))
       continue;
     workList.insert(dependency);
   }
 
   return orderedSet;
 }
 
 FailureOr<Value> ModuleImport::convertConstant(llvm::Constant *constant) {
auto guard = llvm::make_scope_exit([&]() {
       assert(!noResultOpMapping.contains(inst) &&
              "expected constant expression to return a result");
       valueMapping.erase(inst);
       inst->deleteValue();
     });
     // Note: `processInstruction` does not call `convertConstant` recursively
     // since all constant dependencies have been converted before.
     assert(llvm::all_of(inst->operands(), [&](llvm::Value *value) {
-      return valueMapping.count(value);
+      return valueMapping.contains(value);
     }));
     if (failed(processInstruction(inst)))
       return failure();
     return lookupValue(inst);
   }
 
   // Convert aggregate constants.
   if (isa<llvm::ConstantAggregate>(constant) ||
FailureOr<Value> ModuleImport::convertConstantExpr(llvm::Constant *constant) {
   return result;
 }
 
 FailureOr<Value> ModuleImport::convertValue(llvm::Value *value) {
   assert(!isa<llvm::MetadataAsValue>(value) &&
          "expected value to not be metadata");
 
   // Return the mapped value if it has been converted before.
-  if (valueMapping.count(value))
-    return lookupValue(value);
+  auto it = valueMapping.find(value);
+  if (it != valueMapping.end())
+    return it->getSecond();
 
   // Convert constants such as immediate values that have no mapping yet.
   if (auto *constant = dyn_cast<llvm::Constant>(value))
     return convertConstantExpr(constant);
 
   Location loc = mlirModule.getLoc();
   if (auto *inst = dyn_cast<llvm::Instruction>(value))
     loc = translateLoc(inst->getDebugLoc());
   return emitError(loc) << "unhandled value: " << diag(*value);
 }
 
 FailureOr<Value> ModuleImport::convertMetadataValue(llvm::Value *value) {
   // A value may be wrapped as metadata, for example, when passed to a debug
   // intrinsic. Unwrap these values before the conversion.
   auto *nodeAsVal = dyn_cast<llvm::MetadataAsValue>(value);
   if (!nodeAsVal)
     return failure();
   auto *node = dyn_cast<llvm::ValueAsMetadata>(nodeAsVal->getMetadata());
   if (!node)
     return failure();
   value = node->getValue();
 
   // Return the mapped value if it has been converted before.
-  if (valueMapping.count(value))
-    return lookupValue(value);
+  auto it = valueMapping.find(value);
+  if (it != valueMapping.end())
+    return it->getSecond();
 
   // Convert constants such as immediate values that have no mapping yet.
   if (auto *constant = dyn_cast<llvm::Constant>(value))
     return convertConstantExpr(constant);
   return failure();
 }
 
 FailureOr<SmallVector<Value>>