printed_ = true;
    }

    if (RE2::FullMatch(pass->getName(), *dump_pass_re_)) {
      Dump(absl::StrCat(absl::string_view(pass->getName()), "_before"), op,
           absl::StrCat(absl::Hex(pass_counter_, absl::kZeroPad8)));
    }
  }

  void runAfterPass(mlir::Pass* pass, mlir::Operation* op) override {
    if (RE2::FullMatch(pass->getName(), *dump_pass_re_)) {

  // FullMatch(str, re) returns true iff regular expression re matches
  // the entire str.
  // PartialMatch(str, re) returns true iff regular expression re
  // matches a substring of str (including str itself).
  //
  // TODO(******@****.***): make FullMatch() and PartialMatch() work
  // when str contains NUL characters.
  static bool FullMatch(const ::std::string& str, const RE& re) {

          const RE2 node_name_regex(unit.node_name());
          if (!RE2::FullMatch(quantization_unit.value().node_name(),
                              node_name_regex)) {
            continue;
          }
        }

        if (!unit.func_name().empty()) {
          const RE2 func_name_regex(unit.func_name());
          if (!RE2::FullMatch(quantization_unit.value().func_name(),
                              func_name_regex)) {

  // FullMatch(str, re) returns true iff regular expression re matches
  // the entire str.
  // PartialMatch(str, re) returns true iff regular expression re
  // matches a substring of str (including str itself).
  //
  // TODO(******@****.***): make FullMatch() and PartialMatch() work
  // when str contains NUL characters.
  static bool FullMatch(const ::std::string& str, const RE& re) {

    const std::string lifted_func_name =
        xla_call_module_op->getAttrOfType<FlatSymbolRefAttr>("_entry_function")
            .getValue()
            .str();

    return RE2::FullMatch(lifted_func_name, *match_regex_);  // NOLINT
  }

 private:
  // Returns an owned `RE2` object that corresponds to the `spec`. Returns
  // `nullptr` if the `spec` is invalid.

      'attr_name' is given.
    """

    def match_node_name(name):
      if not node_name:
        return True
      compiled_regex = re.compile(node_name)
      match = re.fullmatch(compiled_regex, name)
      return match is not None

    return any(
        node.attr.get(attr_name) == attr_val
        for node in nodes
        if node.op == op_name and match_node_name(node.name)
    )