diff --git a/CMakeLists.txt b/CMakeLists.txt
index 913baca1b568..ecff20a9a773 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -306,7 +306,8 @@ tvm_file_glob(GLOB_RECURSE COMPILER_SRCS
 tvm_file_glob(GLOB CODEGEN_SRCS
   src/target/*.cc
   src/target/source/*.cc
-  src/target/parsers/*.cc
+  src/target/canonicalizer/*.cc
+  src/target/canonicalizer/llvm/*.cc
     )
 
 list(APPEND COMPILER_SRCS ${CODEGEN_SRCS})
diff --git a/include/tvm/ir/config_schema.h b/include/tvm/ir/config_schema.h
new file mode 100644
index 000000000000..9720206b1d00
--- /dev/null
+++ b/include/tvm/ir/config_schema.h
@@ -0,0 +1,235 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+/*!
+ * \file tvm/ir/config_schema.h
+ * \brief Minimal schema for dynamic config canonicalization and validation.
+ *
+ * This utility is intended for dynamic map-like configs (e.g. Target options),
+ * where we still want type checking, optional defaulting, and canonicalization.
+ */
+#ifndef TVM_IR_CONFIG_SCHEMA_H_
+#define TVM_IR_CONFIG_SCHEMA_H_
+
+#include <tvm/ffi/container/map.h>
+#include <tvm/ffi/function.h>
+#include <tvm/ffi/reflection/registry.h>
+
+#include <sstream>
+#include <string>
+#include <type_traits>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+
+namespace tvm {
+namespace ir {
+
+/*!
+ * \brief Dynamic config schema for map-like options.
+ *
+ * The schema supports:
+ * - Option declaration (`def_option<T>`)
+ * - Optional canonicalizer (`set_canonicalizer`)
+ * - Resolution (`Resolve`) that performs validation/defaulting, unknown-key policy,
+ *   and canonicalization (last).
+ */
+class ConfigSchema {
+ public:
+  using ConfigMap = ffi::Map<ffi::String, ffi::Any>;
+  using Canonicalizer = ffi::TypedFunction<ConfigMap(ConfigMap)>;
+
+  /*! \brief Schema entry for one declared option. */
+  struct OptionEntry {
+    /*! \brief Option key. */
+    ffi::String key;
+    /*! \brief Type string for this option. */
+    ffi::String type_str;
+    /*! \brief Per-option validator/coercer (Any -> Any). */
+    ffi::TypedFunction<ffi::Any(ffi::Any)> validator;
+    /*! \brief Whether this option has a default value. */
+    bool has_default = false;
+    /*! \brief Default value (valid when has_default is true). */
+    ffi::Any default_value;
+  };
+
+  /*!
+   * \brief Declare a typed option.
+   *
+   * Validation/coercion is implicitly generated from `T`.
+   * Additional optional traits may be supplied (e.g. `refl::DefaultValue`, `const char*` doc).
+   *
+   * \tparam T The canonical value type of this option.
+   * \tparam Traits Optional metadata/traits.
+   * \param key Option key.
+   * \param traits Optional traits.
+   * \return Reference to `*this` for chaining.
+   */
+  template <typename T, typename... Traits>
+  ConfigSchema& def_option(const ffi::String& key, Traits&&... traits) {
+    std::string skey(key);
+    if (key_to_index_.count(skey)) {
+      TVM_FFI_THROW(ValueError) << "Duplicate config option key: '" << key << "'";
+    }
+    key_to_index_[skey] = options_.size();
+    options_.push_back(MakeEntry<T>(key, std::forward<Traits>(traits)...));
+    return *this;
+  }
+
+  /*! \brief Set whole-object canonicalizer. */
+  void set_canonicalizer(Canonicalizer f) { canonicalizer_ = std::move(f); }
+
+  /*! \brief Trait to set a custom validator for a config option. */
+  struct AttrValidator {
+    ffi::TypedFunction<ffi::Any(ffi::Any)> func;
+    explicit AttrValidator(ffi::TypedFunction<ffi::Any(ffi::Any)> f) : func(std::move(f)) {}
+  };
+
+  /*! \brief Set whether unknown keys trigger an error. */
+  void set_error_on_unknown(bool value) { error_on_unknown_ = value; }
+
+  /*!
+   * \brief Default/validate, then canonicalize a config object.
+   *
+   * Resolve flow:
+   * 1) Validate/coerce declared options in declaration order.
+   * 2) Materialize defaults and enforce required options.
+   * 3) Apply unknown-key policy.
+   * 4) Run canonicalizer as final step.
+   *
+   * \param config Input config object.
+   * \return Canonical validated config object.
+   * \throws ValueError/TypeError with option context.
+   */
+  ConfigMap Resolve(ConfigMap config) const {
+    ConfigMap result;
+
+    // Step 1: validate/coerce and materialize options in declaration order
+    for (const auto& e : options_) {
+      auto it = config.find(e.key);
+      if (it != config.end()) {
+        result.Set(e.key, e.validator((*it).second));
+      } else if (e.has_default) {
+        result.Set(e.key, e.default_value);
+      }
+      // else: missing non-required option, stays absent
+    }
+
+    // Step 2: unknown-key policy
+    if (error_on_unknown_) {
+      for (const auto& kv : config) {
+        if (!key_to_index_.count(std::string(kv.first))) {
+          std::ostringstream os;
+          os << "Unknown config option '" << kv.first << "'. Known options: ";
+          bool first = true;
+          for (const auto& e : options_) {
+            if (!first) os << ", ";
+            os << "'" << e.key << "'";
+            first = false;
+          }
+          TVM_FFI_THROW(ValueError) << os.str();
+        }
+      }
+    }
+
+    // Step 3: whole-object canonicalization (last)
+    if (canonicalizer_ != nullptr) {
+      result = canonicalizer_(result);
+    }
+
+    return result;
+  }
+
+  /*!
+   * \brief List declared options in declaration order.
+   * \return Const reference to the option entries vector.
+   */
+  const std::vector<OptionEntry>& ListOptions() const { return options_; }
+
+  /*! \brief Check if an option with the given key exists. */
+  bool HasOption(const ffi::String& key) const { return key_to_index_.count(std::string(key)) > 0; }
+
+ private:
+  template <typename T>
+  static ffi::TypedFunction<ffi::Any(ffi::Any)> MakeValidator(const ffi::String& key) {
+    return ffi::TypedFunction<ffi::Any(ffi::Any)>([key](ffi::Any val) -> ffi::Any {
+      auto opt = val.try_cast<T>();
+      if (!opt.has_value()) {
+        TVM_FFI_THROW(TypeError) << "Option '" << key << "': expected type '"
+                                 << ffi::TypeTraits<T>::TypeStr() << "' but got '"
+                                 << val.GetTypeKey() << "'";
+      }
+      return ffi::Any(opt.value());
+    });
+  }
+
+  template <typename Trait>
+  static void ApplyTrait(OptionEntry* entry, ffi::reflection::FieldInfoBuilder* info,
+                         Trait&& trait) {
+    using T = std::decay_t<Trait>;
+    if constexpr (std::is_same_v<T, AttrValidator>) {
+      entry->validator = std::move(trait.func);
+    } else if constexpr (std::is_base_of_v<ffi::reflection::InfoTrait, T>) {
+      trait.Apply(info);
+    } else if constexpr (std::is_same_v<T, const char*> || std::is_same_v<T, char*>) {
+      const char* doc = trait;
+      if (doc != nullptr && doc[0] != '\0') {
+        info->doc = TVMFFIByteArray{doc, std::char_traits<char>::length(doc)};
+      }
+    }
+  }
+
+  template <typename T, typename... Traits>
+  OptionEntry MakeEntry(const ffi::String& key, Traits&&... traits) {
+    OptionEntry e;
+    e.key = key;
+    e.type_str = ffi::String(ffi::TypeTraits<T>::TypeStr());
+    e.validator = MakeValidator<T>(key);
+    // Apply traits through a temporary FieldInfoBuilder so existing
+    // reflection traits (notably refl::DefaultValue) are reused unchanged.
+    ffi::reflection::FieldInfoBuilder info{};
+    info.flags = 0;
+    info.default_value = ffi::AnyView(nullptr).CopyToTVMFFIAny();
+    info.doc = TVMFFIByteArray{nullptr, 0};
+    (ApplyTrait(&e, &info, std::forward<Traits>(traits)), ...);
+    if (info.flags & kTVMFFIFieldFlagBitMaskHasDefault) {
+      e.has_default = true;
+      e.default_value = ffi::AnyView::CopyFromTVMFFIAny(info.default_value);
+      // Release the extra ref created by CopyToTVMFFIAny in Apply
+      if (info.default_value.type_index >= TVMFFITypeIndex::kTVMFFIStaticObjectBegin) {
+        ffi::details::ObjectUnsafe::DecRefObjectHandle(info.default_value.v_obj);
+      }
+    }
+    return e;
+  }
+
+  /*! \brief Declared options in declaration order. */
+  std::vector<OptionEntry> options_;
+  /*! \brief Map from key string to index in options_. */
+  std::unordered_map<std::string, size_t> key_to_index_;
+  /*! \brief Optional whole-config canonicalizer. */
+  Canonicalizer canonicalizer_{nullptr};
+  /*! \brief Whether unknown keys trigger an error. */
+  bool error_on_unknown_ = true;
+};
+
+}  // namespace ir
+}  // namespace tvm
+
+#endif  // TVM_IR_CONFIG_SCHEMA_H_
diff --git a/include/tvm/target/target.h b/include/tvm/target/target.h
index 50839dc1aba1..9a0bedd1cc4b 100644
--- a/include/tvm/target/target.h
+++ b/include/tvm/target/target.h
@@ -27,15 +27,12 @@
 #include <tvm/ffi/reflection/registry.h>
 #include <tvm/ir/expr.h>
 #include <tvm/ir/function.h>
-#include <tvm/node/attr_registry_map.h>
 #include <tvm/node/node.h>
 #include <tvm/runtime/device_api.h>
 #include <tvm/support/with.h>
 #include <tvm/target/target_kind.h>
 
 #include <string>
-#include <unordered_set>
-#include <vector>
 
 namespace tvm {
 
@@ -56,10 +53,8 @@ class TargetNode : public Object {
   ffi::String tag;
   /*! \brief Keys for this target */
   ffi::Array<ffi::String> keys;
-  /*! \brief Collection of attributes */
+  /*! \brief Collection of attributes (includes feature.* keys set by canonicalizer) */
   ffi::Map<ffi::String, Any> attrs;
-  /*! \brief Target features */
-  ffi::Map<ffi::String, Any> features;
 
   /*!
    * \brief The JSON string representation of the target
@@ -67,7 +62,7 @@ class TargetNode : public Object {
    */
   TVM_DLL const std::string& str() const;
   /*! \return Export target to JSON-like configuration */
-  TVM_DLL ffi::Map<ffi::String, ffi::Any> Export() const;
+  TVM_DLL ffi::Map<ffi::String, ffi::Any> ToConfig() const;
   /*! \return The ffi::Optional<Target> typed target host of the TargetNode */
   TVM_DLL ffi::Optional<Target> GetHost() const;
   /*! \return The device type for this target */
@@ -83,15 +78,6 @@ class TargetNode : public Object {
    */
   TVM_DLL bool HasKey(const std::string& query_key) const;
 
-  /*!
-   * \brief Returns a human readable representation of \p Target which includes all fields,
-   * especially the host. Useful for diagnostic messages and debugging.
-   *
-   * TODO(mbs): The ReprPrinter version should perhaps switch to this form, however currently
-   * code depends on str() and << being the same.
-   */
-  ffi::String ToDebugString() const;
-
   static void RegisterReflection() {
     namespace refl = tvm::ffi::reflection;
     refl::ObjectDef<TargetNode>()
@@ -99,7 +85,6 @@ class TargetNode : public Object {
         .def_ro("tag", &TargetNode::tag)
         .def_ro("keys", &TargetNode::keys)
         .def_ro("attrs", &TargetNode::attrs)
-        .def_ro("features", &TargetNode::features)
         .def_ro("host", &TargetNode::host);
   }
 
@@ -133,47 +118,6 @@ class TargetNode : public Object {
     return GetAttr<TObjectRef>(attr_key, ffi::Optional<TObjectRef>(default_value));
   }
 
-  /*!
-   * \brief Get a Target feature
-   *
-   * \param feature_key The feature key.
-   * \param default_value The default value if the key does not exist, defaults to nullptr.
-   *
-   * \return The result
-   *
-   * \tparam TOBjectRef the expected object type.
-   * \throw Error if the key exists but the value does not match TObjectRef
-   *
-   * \code
-   *
-   *  void GetTargetFeature(const Target& target) {
-   *    Bool has_feature = target->GetFeature<Bool>("has_feature", false).value();
-   *  }
-   *
-   * \endcode
-   */
-  template <typename TObjectRef>
-  ffi::Optional<TObjectRef> GetFeature(
-      const std::string& feature_key,
-      ffi::Optional<TObjectRef> default_value = std::nullopt) const {
-    if (auto feature = features.Get(feature_key)) {
-      return Downcast<TObjectRef>(feature.value());
-    } else {
-      return default_value;
-    }
-  }
-  // variant that uses TObjectRef to enable implicit conversion to default value.
-  template <typename TObjectRef>
-  ffi::Optional<TObjectRef> GetFeature(const std::string& attr_key,
-                                       TObjectRef default_value) const {
-    return GetFeature<TObjectRef>(attr_key, ffi::Optional<TObjectRef>(default_value));
-  }
-
-  /*! \brief Get the keys for this target as a vector of string */
-  TVM_DLL std::vector<std::string> GetKeys() const;
-  /*! \brief Get the keys for this target as an unordered_set of string */
-  TVM_DLL std::unordered_set<std::string> GetLibs() const;
-
   static constexpr TVMFFISEqHashKind _type_s_eq_hash_kind = kTVMFFISEqHashKindTreeNode;
   TVM_FFI_DECLARE_OBJECT_INFO_FINAL("target.Target", TargetNode, Object);
 
@@ -218,12 +162,7 @@ class Target : public ObjectRef {
    */
   TVM_DLL explicit Target(Target target, Target host);
   TVM_FFI_DEFINE_OBJECT_REF_METHODS_NULLABLE(Target, ObjectRef, TargetNode);
-  /*!
-   * \brief Create a new Target object with given target (w.o host) and target host.
-   * \param target The current Target typed object target, with or without host field.
-   * \param host The given Target typed object target host
-   * \return The new Target object with the given target and host field of given host.
-   */
+
   static Target WithHost(const Target& target, const Target& host);
 
   /*! \return The target with the host stripped out */
diff --git a/include/tvm/target/target_kind.h b/include/tvm/target/target_kind.h
index f2de1d6795d3..5dc261d1fd6e 100644
--- a/include/tvm/target/target_kind.h
+++ b/include/tvm/target/target_kind.h
@@ -26,6 +26,7 @@
 
 #include <tvm/ffi/function.h>
 #include <tvm/ffi/reflection/registry.h>
+#include <tvm/ir/config_schema.h>
 #include <tvm/node/attr_registry_map.h>
 #include <tvm/node/node.h>
 
@@ -39,24 +40,13 @@ namespace tvm {
 class Target;
 
 /*!
- * \brief Map containing parsed features of a specific Target
- */
-using TargetFeatures = ffi::Map<ffi::String, ffi::Any>;
-
-/*!
- * \brief TargetParser to apply on instantiation of a given TargetKind
- *
- * \param target_json Target in JSON format to be transformed during parsing.
+ * \brief Target canonicalizer applied on instantiation of a given TargetKind.
  *
+ * \param target_json Target in JSON format to be transformed during canonicalization.
  * \return The transformed Target JSON object.
  */
-using TargetJSON = ffi::Map<ffi::String, ffi::Any>;
-using FTVMTargetParser = ffi::TypedFunction<TargetJSON(TargetJSON)>;
-
-namespace detail {
-template <typename, typename, typename>
-struct ValueTypeInfoMaker;
-}
+using FTargetCanonicalizer =
+    ffi::TypedFunction<ffi::Map<ffi::String, ffi::Any>(ffi::Map<ffi::String, ffi::Any>)>;
 
 class TargetInternal;
 
@@ -72,10 +62,8 @@ class TargetKindNode : public Object {
   int default_device_type;
   /*! \brief Default keys of the target */
   ffi::Array<ffi::String> default_keys;
-  /*! \brief Function used to preprocess on target creation */
-  ffi::Function preprocessor;
-  /*! \brief Function used to parse a JSON target during creation */
-  FTVMTargetParser target_parser;
+  /*! \brief Function used to canonicalize a JSON target during creation */
+  FTargetCanonicalizer target_canonicalizer;
 
   static void RegisterReflection() {
     namespace refl = tvm::ffi::reflection;
@@ -95,22 +83,11 @@ class TargetKindNode : public Object {
   uint32_t AttrRegistryIndex() const { return index_; }
   /*! \brief Return the name stored in attr registry */
   ffi::String AttrRegistryName() const { return name; }
-  /*! \brief Stores the required type_key and type_index of a specific attr of a target */
-  struct ValueTypeInfo {
-    ffi::String type_key;
-    int32_t type_index;
-    std::unique_ptr<ValueTypeInfo> key;
-    std::unique_ptr<ValueTypeInfo> val;
-  };
-  /*! \brief A hash table that stores the type information of each attr of the target key */
-  std::unordered_map<ffi::String, ValueTypeInfo> key2vtype_;
-  /*! \brief A hash table that stores the default value of each attr of the target key */
-  std::unordered_map<ffi::String, ffi::Any> key2default_;
+  /*! \brief ConfigSchema for validating and resolving target attributes */
+  ir::ConfigSchema schema_;
   /*! \brief Index used for internal lookup of attribute registry */
   uint32_t index_;
 
-  template <typename, typename, typename>
-  friend struct detail::ValueTypeInfoMaker;
   template <typename, typename>
   friend class AttrRegistry;
   template <typename>
@@ -203,32 +180,19 @@ class TargetKindRegEntry {
    */
   inline TargetKindRegEntry& set_default_keys(std::vector<ffi::String> keys);
   /*!
-   * \brief Set the pre-processing function applied upon target creation
-   * \tparam FLambda Type of the function
-   * \param f The pre-processing function
+   * \brief Set the canonicalizer function applied upon target creation.
+   * \param canonicalizer The target canonicalizer function.
    */
-  template <typename FLambda>
-  inline TargetKindRegEntry& set_attrs_preprocessor(FLambda f);
-  /*!
-   * \brief Set the parsing function applied upon target creation
-   * \param parser The Target parsing function
-   */
-  inline TargetKindRegEntry& set_target_parser(FTVMTargetParser parser);
+  inline TargetKindRegEntry& set_target_canonicalizer(FTargetCanonicalizer canonicalizer);
   /*!
    * \brief Register a valid configuration option and its ValueType for validation
    * \param key The configuration key
+   * \param traits Optional traits (e.g. refl::DefaultValue, doc string, or raw default value)
    * \tparam ValueType The value type to be registered
+   * \tparam Traits Optional trait types
    */
-  template <typename ValueType>
-  inline TargetKindRegEntry& add_attr_option(const ffi::String& key);
-  /*!
-   * \brief Register a valid configuration option and its ValueType for validation
-   * \param key The configuration key
-   * \param default_value The default value of the key
-   * \tparam ValueType The value type to be registered
-   */
-  template <typename ValueType>
-  inline TargetKindRegEntry& add_attr_option(const ffi::String& key, ffi::Any default_value);
+  template <typename ValueType, typename... Traits>
+  inline TargetKindRegEntry& add_attr_option(const ffi::String& key, Traits&&... traits);
   /*! \brief Set name of the TargetKind to be the same as registry if it is empty */
   inline TargetKindRegEntry& set_name();
   /*!
@@ -269,85 +233,6 @@ class TargetKindRegEntry {
   friend class TargetKind;
 };
 
-namespace detail {
-template <typename Type, template <typename...> class Container>
-struct is_specialized : std::false_type {
-  using type = std::false_type;
-};
-
-template <template <typename...> class Container, typename... Args>
-struct is_specialized<Container<Args...>, Container> : std::true_type {
-  using type = std::true_type;
-};
-
-template <typename ValueType,
-          typename IsArray = typename is_specialized<ValueType, ffi::Array>::type,
-          typename IsMap = typename is_specialized<ValueType, ffi::Map>::type>
-struct ValueTypeInfoMaker {};
-
-template <typename ValueType>
-struct ValueTypeInfoMaker<ValueType, std::false_type, std::false_type> {
-  using ValueTypeInfo = TargetKindNode::ValueTypeInfo;
-
-  ValueTypeInfo operator()() const {
-    ValueTypeInfo info;
-    info.key = nullptr;
-    info.val = nullptr;
-    if constexpr (std::is_base_of_v<ObjectRef, ValueType>) {
-      int32_t tindex = ffi::TypeToRuntimeTypeIndex<ValueType>::v();
-      info.type_index = tindex;
-      info.type_key = runtime::Object::TypeIndex2Key(tindex);
-      return info;
-    } else if constexpr (std::is_same_v<ValueType, ffi::String>) {
-      // special handle string since it can be backed by multiple types.
-      info.type_index = ffi::TypeIndex::kTVMFFIStr;
-      info.type_key = ffi::TypeTraits<ValueType>::TypeStr();
-      return info;
-    } else {
-      // TODO(tqchen) consider upgrade to leverage any system to support union type
-      constexpr int32_t tindex = ffi::TypeToFieldStaticTypeIndex<ValueType>::value;
-      static_assert(tindex != ffi::TypeIndex::kTVMFFIAny, "Do not support union type for now");
-      info.type_index = tindex;
-      info.type_key = runtime::Object::TypeIndex2Key(tindex);
-      return info;
-    }
-  }
-};
-
-template <typename ValueType>
-struct ValueTypeInfoMaker<ValueType, std::true_type, std::false_type> {
-  using ValueTypeInfo = TargetKindNode::ValueTypeInfo;
-
-  ValueTypeInfo operator()() const {
-    using key_type = ValueTypeInfoMaker<typename ValueType::value_type>;
-    uint32_t tindex = ValueType::ContainerType::_GetOrAllocRuntimeTypeIndex();
-    ValueTypeInfo info;
-    info.type_index = tindex;
-    info.type_key = runtime::Object::TypeIndex2Key(tindex);
-    info.key = std::make_unique<ValueTypeInfo>(key_type()());
-    info.val = nullptr;
-    return info;
-  }
-};
-
-template <typename ValueType>
-struct ValueTypeInfoMaker<ValueType, std::false_type, std::true_type> {
-  using ValueTypeInfo = TargetKindNode::ValueTypeInfo;
-  ValueTypeInfo operator()() const {
-    using key_type = ValueTypeInfoMaker<typename ValueType::key_type>;
-    using val_type = ValueTypeInfoMaker<typename ValueType::mapped_type>;
-    uint32_t tindex = ValueType::ContainerType::_GetOrAllocRuntimeTypeIndex();
-    ValueTypeInfo info;
-    info.type_index = tindex;
-    info.type_key = runtime::Object::TypeIndex2Key(tindex);
-    info.key = std::make_unique<ValueTypeInfo>(key_type()());
-    info.val = std::make_unique<ValueTypeInfo>(val_type()());
-    return info;
-  }
-};
-
-}  // namespace detail
-
 template <typename ValueType>
 inline TargetKindAttrMap<ValueType> TargetKind::GetAttrMap(const ffi::String& attr_name) {
   return TargetKindAttrMap<ValueType>(GetAttrMapContainer(attr_name));
@@ -373,31 +258,17 @@ inline TargetKindRegEntry& TargetKindRegEntry::set_default_keys(std::vector<ffi:
   return *this;
 }
 
-template <typename FLambda>
-inline TargetKindRegEntry& TargetKindRegEntry::set_attrs_preprocessor(FLambda f) {
-  LOG(WARNING) << "set_attrs_preprocessor is deprecated please use set_target_parser instead";
-  kind_->preprocessor = ffi::Function::FromTyped(std::move(f));
-  return *this;
-}
-
-inline TargetKindRegEntry& TargetKindRegEntry::set_target_parser(FTVMTargetParser parser) {
-  kind_->target_parser = parser;
+inline TargetKindRegEntry& TargetKindRegEntry::set_target_canonicalizer(
+    FTargetCanonicalizer canonicalizer) {
+  kind_->target_canonicalizer = canonicalizer;
+  kind_->schema_.set_canonicalizer(canonicalizer);
   return *this;
 }
 
-template <typename ValueType>
-inline TargetKindRegEntry& TargetKindRegEntry::add_attr_option(const ffi::String& key) {
-  ICHECK(!kind_->key2vtype_.count(key))
-      << "AttributeError: add_attr_option failed because '" << key << "' has been set once";
-  kind_->key2vtype_[key] = detail::ValueTypeInfoMaker<ValueType>()();
-  return *this;
-}
-
-template <typename ValueType>
+template <typename ValueType, typename... Traits>
 inline TargetKindRegEntry& TargetKindRegEntry::add_attr_option(const ffi::String& key,
-                                                               Any default_value) {
-  add_attr_option<ValueType>(key);
-  kind_->key2default_[key] = default_value;
+                                                               Traits&&... traits) {
+  kind_->schema_.def_option<ValueType>(key, std::forward<Traits>(traits)...);
   return *this;
 }
 
@@ -433,6 +304,7 @@ inline TargetKindRegEntry& TargetKindRegEntry::set_name() {
       ::tvm::TargetKindRegEntry::RegisterOrGet(TargetKindName)    \
           .set_name()                                             \
           .set_default_device_type(DeviceType)                    \
+          .add_attr_option<ffi::String>("kind")                   \
           .add_attr_option<ffi::Array<ffi::String>>("keys")       \
           .add_attr_option<ffi::String>("tag")                    \
           .add_attr_option<ffi::String>("device")                 \
diff --git a/src/arith/scalable_expression.cc b/src/arith/scalable_expression.cc
index c4e26d07259a..b827dff80105 100644
--- a/src/arith/scalable_expression.cc
+++ b/src/arith/scalable_expression.cc
@@ -93,7 +93,7 @@ bool TargetHasVLA(ffi::Optional<Target> target) {
   bool has_vla{false};
   if (target.defined()) {
     // aarch64
-    has_vla = Downcast<Target>(target)->GetFeature<Bool>("has_sve").value_or(Bool(false));
+    has_vla = Downcast<Target>(target)->GetAttr<Bool>("feature.has_sve").value_or(Bool(false));
     // riscv{32,64}
     static auto target_has_feature_fn =
         tvm::ffi::Function::GetGlobalRequired("target.target_has_feature");
diff --git a/src/s_tir/meta_schedule/database/database.cc b/src/s_tir/meta_schedule/database/database.cc
index 501cecb7e8cc..87558e0611f4 100644
--- a/src/s_tir/meta_schedule/database/database.cc
+++ b/src/s_tir/meta_schedule/database/database.cc
@@ -110,7 +110,7 @@ ObjectRef TuningRecordNode::AsJSON() const {
     json_args_info = info;
   }
   if (target.defined()) {
-    json_target = target.value()->Export();
+    json_target = target.value()->ToConfig();
   }
   return ffi::Array<ObjectRef>{trace->AsJSON(false),  //
                                run_secs,              //
diff --git a/src/s_tir/meta_schedule/space_generator/space_generator.cc b/src/s_tir/meta_schedule/space_generator/space_generator.cc
index c23bfd1d5050..e3057a333b5f 100644
--- a/src/s_tir/meta_schedule/space_generator/space_generator.cc
+++ b/src/s_tir/meta_schedule/space_generator/space_generator.cc
@@ -18,7 +18,7 @@
  */
 #include <tvm/ffi/reflection/registry.h>
 
-#include "../../../target/parsers/aprofile.h"
+#include "../../../target/canonicalizer/llvm/arm_aprofile.h"
 #include "../utils.h"
 
 namespace tvm {
@@ -45,13 +45,13 @@ ffi::String GetRuleKindFromTarget(const Target& target) {
       return "rvv";
     }
 
-    TargetJSON target_json = target::parsers::aprofile::ParseTarget(target->Export());
-    TargetFeatures afeatures = Downcast<TargetFeatures>(target_json.at("features"));
+    ffi::Map<ffi::String, ffi::Any> target_json =
+        target::canonicalizer::llvm::aprofile::Canonicalize(target->ToConfig());
 
-    if (Downcast<Bool>(afeatures.at("has_dotprod"))) {
+    if (Downcast<Bool>(target_json.at("feature.has_dotprod"))) {
       return "dotprod";
     }
-    if (Downcast<Bool>(afeatures.at("has_asimd"))) {
+    if (Downcast<Bool>(target_json.at("feature.has_asimd"))) {
       return "asimd";
     }
     return "llvm";
diff --git a/src/script/printer/ir/ir.cc b/src/script/printer/ir/ir.cc
index aac5656f9146..dff435833778 100644
--- a/src/script/printer/ir/ir.cc
+++ b/src/script/printer/ir/ir.cc
@@ -130,7 +130,7 @@ TVM_STATIC_IR_FUNCTOR(IRDocsifier, vtable)
 TVM_STATIC_IR_FUNCTOR(IRDocsifier, vtable)
     .set_dispatch<VDevice>("", [](VDevice vdev, AccessPath p, IRDocsifier d) -> Doc {
       d->AddGlobalInfo("vdevice", vdev);
-      ffi::Map<ffi::String, ffi::Any> config = vdev->target->Export();
+      ffi::Map<ffi::String, ffi::Any> config = vdev->target->ToConfig();
       return IR(d, "vdevice")
           ->Call({d->AsDoc<ExprDoc>(config, p),
                   LiteralDoc::Int(vdev->vdevice_id, p->Attr("vdevice_id")),
diff --git a/src/script/printer/tir/ir.cc b/src/script/printer/tir/ir.cc
index 431dc7dcc3e5..a2409865cbb1 100644
--- a/src/script/printer/tir/ir.cc
+++ b/src/script/printer/tir/ir.cc
@@ -91,7 +91,7 @@ TVM_STATIC_IR_FUNCTOR(IRDocsifier, vtable)
 
 TVM_STATIC_IR_FUNCTOR(IRDocsifier, vtable)
     .set_dispatch<Target>("", [](Target target, AccessPath p, IRDocsifier d) -> Doc {
-      ffi::Map<ffi::String, ffi::Any> config = target->Export();
+      ffi::Map<ffi::String, ffi::Any> config = target->ToConfig();
       return TIR(d, "target")->Call({d->AsDoc<ExprDoc>(config, p)});
     });
 
diff --git a/src/target/parsers/aprofile.cc b/src/target/canonicalizer/llvm/arm_aprofile.cc
similarity index 79%
rename from src/target/parsers/aprofile.cc
rename to src/target/canonicalizer/llvm/arm_aprofile.cc
index 4edff94baeda..4b3f4ebc8dc5 100644
--- a/src/target/parsers/aprofile.cc
+++ b/src/target/canonicalizer/llvm/arm_aprofile.cc
@@ -18,21 +18,22 @@
  */
 
 /*!
- * \file tvm/target/parsers/aprofile.cc
- * \brief Target Parser for Arm(R) Cortex(R) A-Profile CPUs
+ * \file tvm/target/canonicalizer/llvm/arm_aprofile.cc
+ * \brief Target canonicalizer for Arm(R) Cortex(R) A-Profile CPUs
  */
 
-#include "aprofile.h"
+#include "arm_aprofile.h"
 
 #include <memory>
 #include <string>
 
-#include "../../support/utils.h"
-#include "../llvm/llvm_instance.h"
+#include "../../../support/utils.h"
+#include "../../llvm/llvm_instance.h"
 
 namespace tvm {
 namespace target {
-namespace parsers {
+namespace canonicalizer {
+namespace llvm {
 namespace aprofile {
 
 double GetArchVersion(ffi::Array<ffi::String> mattr) {
@@ -69,7 +70,7 @@ bool IsAArch64(ffi::Optional<ffi::String> mtriple) {
   return false;
 }
 
-bool IsArch(TargetJSON attrs) {
+bool IsArch(ffi::Map<ffi::String, ffi::Any> attrs) {
   ffi::Optional<ffi::String> mtriple =
       Downcast<ffi::Optional<ffi::String>>(attrs.Get("mtriple").value_or(nullptr));
   ffi::Optional<ffi::String> mcpu =
@@ -82,7 +83,7 @@ bool CheckContains(ffi::Array<ffi::String> array, ffi::String predicate) {
   return std::any_of(array.begin(), array.end(), [&](ffi::String var) { return var == predicate; });
 }
 
-static TargetFeatures GetFeatures(TargetJSON target) {
+static ffi::Map<ffi::String, ffi::Any> GetFeatures(ffi::Map<ffi::String, ffi::Any> target) {
 #ifdef TVM_LLVM_VERSION
   ffi::String kind = Downcast<ffi::String>(target.Get("kind").value());
   ICHECK_EQ(kind, "llvm") << "Expected target kind 'llvm', but got '" << kind << "'";
@@ -110,13 +111,13 @@ static TargetFeatures GetFeatures(TargetJSON target) {
     return features.find(feature) != features.end();
   };
 
-  return {{"is_aarch64", Bool(IsAArch64(mtriple))},
-          {"has_asimd", Bool(has_feature("neon"))},
-          {"has_sve", Bool(has_feature("sve"))},
-          {"has_dotprod", Bool(has_feature("dotprod"))},
-          {"has_matmul_i8", Bool(has_feature("i8mm"))},
-          {"has_fp16_simd", Bool(has_feature("fullfp16"))},
-          {"has_sme", Bool(has_feature("sme"))}};
+  return {{"feature.is_aarch64", Bool(IsAArch64(mtriple))},
+          {"feature.has_asimd", Bool(has_feature("neon"))},
+          {"feature.has_sve", Bool(has_feature("sve"))},
+          {"feature.has_dotprod", Bool(has_feature("dotprod"))},
+          {"feature.has_matmul_i8", Bool(has_feature("i8mm"))},
+          {"feature.has_fp16_simd", Bool(has_feature("fullfp16"))},
+          {"feature.has_sme", Bool(has_feature("sme"))}};
 #endif
 
   LOG(WARNING) << "Cannot parse Arm(R)-based target features for target " << target
@@ -140,8 +141,11 @@ static ffi::Array<ffi::String> MergeKeys(ffi::Optional<ffi::Array<ffi::String>>
   return keys;
 }
 
-TargetJSON ParseTarget(TargetJSON target) {
-  target.Set("features", GetFeatures(target));
+ffi::Map<ffi::String, ffi::Any> Canonicalize(ffi::Map<ffi::String, ffi::Any> target) {
+  ffi::Map<ffi::String, ffi::Any> features = GetFeatures(target);
+  for (const auto& kv : features) {
+    target.Set(kv.first, kv.second);
+  }
   target.Set("keys",
              MergeKeys(Downcast<ffi::Optional<ffi::Array<ffi::String>>>(target.Get("keys"))));
 
@@ -149,6 +153,7 @@ TargetJSON ParseTarget(TargetJSON target) {
 }
 
 }  // namespace aprofile
-}  // namespace parsers
+}  // namespace llvm
+}  // namespace canonicalizer
 }  // namespace target
 }  // namespace tvm
diff --git a/src/target/parsers/aprofile.h b/src/target/canonicalizer/llvm/arm_aprofile.h
similarity index 65%
rename from src/target/parsers/aprofile.h
rename to src/target/canonicalizer/llvm/arm_aprofile.h
index 7ded9ac5456a..0471bedf8d53 100644
--- a/src/target/parsers/aprofile.h
+++ b/src/target/canonicalizer/llvm/arm_aprofile.h
@@ -18,26 +18,28 @@
  */
 
 /*!
- * \file tvm/target/parsers/aprofile.h
- * \brief Target Parser for Arm(R) Cortex(R) A-Profile CPUs
+ * \file tvm/target/canonicalizer/llvm/arm_aprofile.h
+ * \brief Target canonicalizer for Arm(R) Cortex(R) A-Profile CPUs
  */
 
-#ifndef TVM_TARGET_PARSERS_APROFILE_H_
-#define TVM_TARGET_PARSERS_APROFILE_H_
+#ifndef TVM_TARGET_CANONICALIZER_LLVM_ARM_APROFILE_H_
+#define TVM_TARGET_CANONICALIZER_LLVM_ARM_APROFILE_H_
 
 #include <tvm/target/target.h>
 
 namespace tvm {
 namespace target {
-namespace parsers {
+namespace canonicalizer {
+namespace llvm {
 namespace aprofile {
 
-bool IsArch(TargetJSON target);
-TargetJSON ParseTarget(TargetJSON target);
+bool IsArch(ffi::Map<ffi::String, ffi::Any> target);
+ffi::Map<ffi::String, ffi::Any> Canonicalize(ffi::Map<ffi::String, ffi::Any> target);
 
 }  // namespace aprofile
-}  // namespace parsers
+}  // namespace llvm
+}  // namespace canonicalizer
 }  // namespace target
 }  // namespace tvm
 
-#endif  // TVM_TARGET_PARSERS_APROFILE_H_
+#endif  // TVM_TARGET_CANONICALIZER_LLVM_ARM_APROFILE_H_
diff --git a/src/target/parsers/mprofile.cc b/src/target/canonicalizer/llvm/arm_mprofile.cc
similarity index 77%
rename from src/target/parsers/mprofile.cc
rename to src/target/canonicalizer/llvm/arm_mprofile.cc
index bd3bf5848a68..b79994be5a28 100644
--- a/src/target/parsers/mprofile.cc
+++ b/src/target/canonicalizer/llvm/arm_mprofile.cc
@@ -18,22 +18,26 @@
  */
 
 /*!
- * \file tvm/target/parsers/mprofile.cc
- * \brief Target Parser for Arm(R) Cortex(R) M-Profile CPUs
+ * \file tvm/target/canonicalizer/llvm/arm_mprofile.cc
+ * \brief Target canonicalizer for Arm(R) Cortex(R) M-Profile CPUs
  */
 
-#include "mprofile.h"
+#include "arm_mprofile.h"
 
 #include <string>
 
 namespace tvm {
 namespace target {
-namespace parsers {
+namespace canonicalizer {
+namespace llvm {
 namespace mprofile {
 
-const TargetFeatures kNoExt = {{"has_dsp", false}, {"has_mve", false}};
-const TargetFeatures kHasDSP = {{"has_dsp", true}, {"has_mve", false}};
-const TargetFeatures kHasMVE = {{"has_dsp", true}, {"has_mve", true}};
+const ffi::Map<ffi::String, ffi::Any> kNoExt = {{"feature.has_dsp", false},
+                                                {"feature.has_mve", false}};
+const ffi::Map<ffi::String, ffi::Any> kHasDSP = {{"feature.has_dsp", true},
+                                                 {"feature.has_mve", false}};
+const ffi::Map<ffi::String, ffi::Any> kHasMVE = {{"feature.has_dsp", true},
+                                                 {"feature.has_mve", true}};
 
 static const char* baseCPUs[] = {"cortex-m0", "cortex-m3"};
 static const char* dspCPUs[] = {"cortex-m55", "cortex-m4",   "cortex-m7",
@@ -74,7 +78,7 @@ static inline bool HasFlag(ffi::Optional<ffi::Array<ffi::String>> attr, std::str
   return matching_attr != attr_array.end();
 }
 
-bool IsArch(TargetJSON attrs) {
+bool IsArch(ffi::Map<ffi::String, ffi::Any> attrs) {
   ffi::Optional<ffi::String> mcpu = Downcast<ffi::Optional<ffi::String>>(attrs.Get("mcpu"));
   if (mcpu) {
     bool matches_base = MatchesCpu(mcpu, baseCPUs);
@@ -85,7 +89,7 @@ bool IsArch(TargetJSON attrs) {
   return false;
 }
 
-static TargetFeatures GetFeatures(TargetJSON target) {
+static ffi::Map<ffi::String, ffi::Any> GetFeatures(ffi::Map<ffi::String, ffi::Any> target) {
   ffi::Optional<ffi::String> mcpu = Downcast<ffi::Optional<ffi::String>>(target.Get("mcpu"));
   ffi::Optional<ffi::Array<ffi::String>> mattr =
       Downcast<ffi::Optional<ffi::Array<ffi::String>>>(target.Get("mattr"));
@@ -122,8 +126,11 @@ static ffi::Array<ffi::String> MergeKeys(ffi::Optional<ffi::Array<ffi::String>>
   return keys;
 }
 
-TargetJSON ParseTarget(TargetJSON target) {
-  target.Set("features", GetFeatures(target));
+ffi::Map<ffi::String, ffi::Any> Canonicalize(ffi::Map<ffi::String, ffi::Any> target) {
+  ffi::Map<ffi::String, ffi::Any> features = GetFeatures(target);
+  for (const auto& kv : features) {
+    target.Set(kv.first, kv.second);
+  }
   target.Set("keys",
              MergeKeys(Downcast<ffi::Optional<ffi::Array<ffi::String>>>(target.Get("keys"))));
 
@@ -131,6 +138,7 @@ TargetJSON ParseTarget(TargetJSON target) {
 }
 
 }  // namespace mprofile
-}  // namespace parsers
+}  // namespace llvm
+}  // namespace canonicalizer
 }  // namespace target
 }  // namespace tvm
diff --git a/src/target/parsers/cpu.h b/src/target/canonicalizer/llvm/arm_mprofile.h
similarity index 62%
rename from src/target/parsers/cpu.h
rename to src/target/canonicalizer/llvm/arm_mprofile.h
index 588f98eea043..ed87c93c2fd0 100644
--- a/src/target/parsers/cpu.h
+++ b/src/target/canonicalizer/llvm/arm_mprofile.h
@@ -18,25 +18,28 @@
  */
 
 /*!
- * \file tvm/target/parsers/cpu.h
- * \brief Target Parser for CPU Target's
+ * \file tvm/target/canonicalizer/llvm/arm_mprofile.h
+ * \brief Target canonicalizer for Arm(R) Cortex(R) M-Profile CPUs
  */
 
-#ifndef TVM_TARGET_PARSERS_CPU_H_
-#define TVM_TARGET_PARSERS_CPU_H_
+#ifndef TVM_TARGET_CANONICALIZER_LLVM_ARM_MPROFILE_H_
+#define TVM_TARGET_CANONICALIZER_LLVM_ARM_MPROFILE_H_
 
 #include <tvm/target/target.h>
 
 namespace tvm {
 namespace target {
-namespace parsers {
-namespace cpu {
+namespace canonicalizer {
+namespace llvm {
+namespace mprofile {
 
-TargetJSON ParseTarget(TargetJSON target);
+bool IsArch(ffi::Map<ffi::String, ffi::Any> target);
+ffi::Map<ffi::String, ffi::Any> Canonicalize(ffi::Map<ffi::String, ffi::Any> target);
 
-}  // namespace cpu
-}  // namespace parsers
+}  // namespace mprofile
+}  // namespace llvm
+}  // namespace canonicalizer
 }  // namespace target
 }  // namespace tvm
 
-#endif  // TVM_TARGET_PARSERS_CPU_H_
+#endif  // TVM_TARGET_CANONICALIZER_LLVM_ARM_MPROFILE_H_
diff --git a/src/target/parsers/cpu.cc b/src/target/canonicalizer/llvm/canonicalize.cc
similarity index 84%
rename from src/target/parsers/cpu.cc
rename to src/target/canonicalizer/llvm/canonicalize.cc
index ac187a03bbdc..7ddd5420c0a5 100644
--- a/src/target/parsers/cpu.cc
+++ b/src/target/canonicalizer/llvm/canonicalize.cc
@@ -16,17 +16,17 @@
  * specific language governing permissions and limitations
  * under the License.
  */
-#include "cpu.h"
+#include "canonicalize.h"
 
 #include <string>
 
-#include "aprofile.h"
-#include "mprofile.h"
+#include "arm_aprofile.h"
+#include "arm_mprofile.h"
 
 namespace tvm {
 namespace target {
-namespace parsers {
-namespace cpu {
+namespace canonicalizer {
+namespace llvm {
 
 ffi::Optional<ffi::String> DetectSystemTriple() {
 #ifdef TVM_LLVM_VERSION
@@ -38,7 +38,7 @@ ffi::Optional<ffi::String> DetectSystemTriple() {
   return {};
 }
 
-TargetJSON ParseTarget(TargetJSON target) {
+ffi::Map<ffi::String, ffi::Any> Canonicalize(ffi::Map<ffi::String, ffi::Any> target) {
   ffi::String kind = Downcast<ffi::String>(target.Get("kind").value());
   ffi::Optional<ffi::String> mtriple = Downcast<ffi::Optional<ffi::String>>(target.Get("mtriple"));
   ffi::Optional<ffi::String> mcpu = Downcast<ffi::Optional<ffi::String>>(target.Get("mcpu"));
@@ -50,17 +50,17 @@ TargetJSON ParseTarget(TargetJSON target) {
   }
 
   if (mprofile::IsArch(target)) {
-    return mprofile::ParseTarget(target);
+    return mprofile::Canonicalize(target);
   }
 
   if (aprofile::IsArch(target)) {
-    return aprofile::ParseTarget(target);
+    return aprofile::Canonicalize(target);
   }
 
   return target;
 }
 
-}  // namespace cpu
-}  // namespace parsers
+}  // namespace llvm
+}  // namespace canonicalizer
 }  // namespace target
 }  // namespace tvm
diff --git a/src/target/parsers/mprofile.h b/src/target/canonicalizer/llvm/canonicalize.h
similarity index 67%
rename from src/target/parsers/mprofile.h
rename to src/target/canonicalizer/llvm/canonicalize.h
index 27f0e28595b9..622c9767b1c1 100644
--- a/src/target/parsers/mprofile.h
+++ b/src/target/canonicalizer/llvm/canonicalize.h
@@ -18,26 +18,25 @@
  */
 
 /*!
- * \file tvm/target/parsers/mprofile.h
- * \brief Target Parser for Arm(R) Cortex(R) M-Profile CPUs
+ * \file tvm/target/canonicalizer/llvm/canonicalize.h
+ * \brief Target canonicalizer for LLVM-based CPU targets
  */
 
-#ifndef TVM_TARGET_PARSERS_MPROFILE_H_
-#define TVM_TARGET_PARSERS_MPROFILE_H_
+#ifndef TVM_TARGET_CANONICALIZER_LLVM_CANONICALIZE_H_
+#define TVM_TARGET_CANONICALIZER_LLVM_CANONICALIZE_H_
 
 #include <tvm/target/target.h>
 
 namespace tvm {
 namespace target {
-namespace parsers {
-namespace mprofile {
+namespace canonicalizer {
+namespace llvm {
 
-bool IsArch(TargetJSON target);
-TargetJSON ParseTarget(TargetJSON target);
+ffi::Map<ffi::String, ffi::Any> Canonicalize(ffi::Map<ffi::String, ffi::Any> target);
 
-}  // namespace mprofile
-}  // namespace parsers
+}  // namespace llvm
+}  // namespace canonicalizer
 }  // namespace target
 }  // namespace tvm
 
-#endif  // TVM_TARGET_PARSERS_MPROFILE_H_
+#endif  // TVM_TARGET_CANONICALIZER_LLVM_CANONICALIZE_H_
diff --git a/src/target/llvm/llvm_instance.cc b/src/target/llvm/llvm_instance.cc
index 3227b9edbcfe..4e8b072f01cb 100644
--- a/src/target/llvm/llvm_instance.cc
+++ b/src/target/llvm/llvm_instance.cc
@@ -200,9 +200,10 @@ std::ostream& operator<<(std::ostream& os, const LLVMTargetInfo::Option& opt) {
 }
 
 LLVMTargetInfo::LLVMTargetInfo(LLVMInstance& instance, const Target& target)
-    : LLVMTargetInfo(instance, target->Export()) {}
+    : LLVMTargetInfo(instance, target->ToConfig()) {}
 
-LLVMTargetInfo::LLVMTargetInfo(LLVMInstance& instance, const TargetJSON& target) {
+LLVMTargetInfo::LLVMTargetInfo(LLVMInstance& instance,
+                               const ffi::Map<ffi::String, ffi::Any>& target) {
   triple_ = Downcast<ffi::String>(target.Get("mtriple").value_or(ffi::String("default")));
   if (triple_.empty() || triple_ == "default") {
     triple_ = llvm::sys::getDefaultTargetTriple();
diff --git a/src/target/llvm/llvm_instance.h b/src/target/llvm/llvm_instance.h
index a41c57d6fae6..71854751163d 100644
--- a/src/target/llvm/llvm_instance.h
+++ b/src/target/llvm/llvm_instance.h
@@ -184,7 +184,7 @@ class LLVMTargetInfo {
    * \param target TVM JSON Target object for target "llvm"
    */
   // NOLINTNEXTLINE(runtime/references)
-  LLVMTargetInfo(LLVMInstance& instance, const TargetJSON& target);
+  LLVMTargetInfo(LLVMInstance& instance, const ffi::Map<ffi::String, ffi::Any>& target);
 
   /*!
    * \brief Destroys LLVMTargetInfo object
diff --git a/src/target/source/codegen_opencl.cc b/src/target/source/codegen_opencl.cc
index b3926e106f6f..e213be519c16 100644
--- a/src/target/source/codegen_opencl.cc
+++ b/src/target/source/codegen_opencl.cc
@@ -719,9 +719,7 @@ TVM_FFI_STATIC_INIT_BLOCK() {
 }
 
 ffi::String DeviceScopeCompatibilityFromTarget(Target target, ffi::String memory_scope) {
-  auto prototype_keys = target->GetKeys();
-  bool is_adreno =
-      std::find(prototype_keys.begin(), prototype_keys.end(), "adreno") != prototype_keys.end();
+  bool is_adreno = target->HasKey("adreno");
   if (is_adreno) {
     return ffi::String("global");
   }
diff --git a/src/target/spirv/codegen_spirv.cc b/src/target/spirv/codegen_spirv.cc
index 00db1ddb9b69..1c0de5d06484 100644
--- a/src/target/spirv/codegen_spirv.cc
+++ b/src/target/spirv/codegen_spirv.cc
@@ -543,6 +543,7 @@ spirv::Value CodeGenSPIRV::VisitExpr_(const BroadcastNode* op) {
 
 spirv::Value CodeGenSPIRV::VisitExpr_(const BufferLoadNode* op) {
   ICHECK_EQ(op->indices.size(), 1) << "SPIR-V codegen expects flat memory buffers";
+  ICHECK(!op->predicate.defined()) << "Predicated buffer load is not supported.";
   Var buffer_var = op->buffer->data;
   PrimExpr prim_index = op->indices[0];
 
@@ -627,6 +628,7 @@ spirv::Value CodeGenSPIRV::VisitExpr_(const ShuffleNode* op) {
 
 void CodeGenSPIRV::VisitStmt_(const BufferStoreNode* op) {
   ICHECK_EQ(op->indices.size(), 1) << "SPIR-V codegen expects flat memory buffers";
+  ICHECK(!op->predicate.defined()) << "Predicated buffer store is not supported.";
   Var buffer_var = op->buffer->data;
   PrimExpr prim_index = op->indices[0];
 
diff --git a/src/target/target.cc b/src/target/target.cc
index a37fee5d8085..89769ecaa6fd 100644
--- a/src/target/target.cc
+++ b/src/target/target.cc
@@ -46,10 +46,7 @@ class TargetInternal {
  public:
   static void EnterScope(Target target) { target.EnterWithScope(); }
   static void ExitScope(Target target) { target.ExitWithScope(); }
-  static ffi::Map<ffi::String, ffi::Any> Export(Target target) { return target->Export(); }
-  static const TargetKindNode::ValueTypeInfo& FindTypeInfo(const TargetKind& kind,
-                                                           const std::string& key);
-  static Any ParseType(const Any& obj, const TargetKindNode::ValueTypeInfo& info);
+  static ffi::Map<ffi::String, ffi::Any> ToConfig(Target target) { return target->ToConfig(); }
   static ObjectPtr<TargetNode> FromString(const ffi::String& tag_or_config_or_target_str);
   static ObjectPtr<TargetNode> FromConfigString(const ffi::String& config_str);
   static ObjectPtr<TargetNode> FromConfig(ffi::Map<ffi::String, ffi::Any> config);
@@ -66,6 +63,7 @@ class TargetInternal {
 };
 
 /**********  Helper functions  **********/
+
 Target Target::WithHost(const Target& target, const Target& host) {
   return TargetInternal::WithHost(target, host);
 }
@@ -92,16 +90,6 @@ static std::vector<ffi::String> DeduplicateKeys(const std::vector<ffi::String>&
   return new_keys;
 }
 
-template <class T>
-static T ObjTypeCheck(const Any& obj, const std::string& expected_type) {
-  auto opt = obj.try_cast<T>();
-  if (!opt.has_value()) {
-    TVM_FFI_THROW(TypeError) << "Expects type \"" << expected_type << "\", but gets \""
-                             << obj.GetTypeKey() << "\" for object: " << obj;
-  }
-  return opt.value();
-}
-
 static TargetKind GetTargetKind(const ffi::String& name) {
   ffi::Optional<TargetKind> kind = TargetKind::Get(name);
   if (!kind.defined()) {
@@ -110,102 +98,9 @@ static TargetKind GetTargetKind(const ffi::String& name) {
   return kind.value();
 }
 
-const TargetKindNode::ValueTypeInfo& TargetInternal::FindTypeInfo(const TargetKind& kind,
-                                                                  const std::string& key) {
-  auto it = kind->key2vtype_.find(key);
-  if (it == kind->key2vtype_.end()) {
-    std::ostringstream os;
-    os << ": Cannot recognize \'" << key << "\'. Candidates are: ";
-    bool is_first = true;
-    for (const auto& kv : kind->key2vtype_) {
-      if (is_first) {
-        is_first = false;
-      } else {
-        os << ", ";
-      }
-      os << kv.first;
-    }
-    TVM_FFI_THROW(TypeError) << os.str();
-  }
-  return it->second;
-}
-
-/**********  Parsing  **********/
-
-Any TargetInternal::ParseType(const Any& obj, const TargetKindNode::ValueTypeInfo& info) {
-  if (info.type_index == ffi::TypeIndex::kTVMFFIInt) {
-    // Parsing integer
-    return ObjTypeCheck<int64_t>(obj, "int64_t");
-  } else if (info.type_index == ffi::TypeIndex::kTVMFFIBool) {
-    // Parsing boolean
-    return ObjTypeCheck<bool>(obj, "bool");
-  } else if (info.type_index == ffi::TypeIndex::kTVMFFIStr) {
-    // Parsing string
-    return ObjTypeCheck<ffi::String>(obj, "String");
-  } else if (info.type_index == Target::ContainerType::RuntimeTypeIndex()) {
-    // Parsing target
-    if (auto opt = obj.as<Target>()) {
-      return opt.value();
-    } else if (auto str = obj.try_cast<ffi::String>()) {
-      return Target(TargetInternal::FromString(str.value()));
-    } else if (const auto* ptr = obj.as<ffi::MapObj>()) {
-      for (const auto& kv : *ptr) {
-        if (!kv.first.as<ffi::String>()) {
-          TVM_FFI_THROW(TypeError)
-              << "Target object requires key of dict to be str, but get: " << kv.first.GetTypeKey();
-        }
-      }
-      ffi::Map<ffi::String, ffi::Any> config = ffi::GetRef<ffi::Map<ffi::String, ffi::Any>>(ptr);
-      return Target(TargetInternal::FromConfig({config.begin(), config.end()}));
-    }
-    TVM_FFI_THROW(TypeError) << "Expect type 'dict' or 'str' to construct Target, but get: " +
-                                    obj.GetTypeKey();
-  } else if (info.type_index == ffi::ArrayObj::RuntimeTypeIndex()) {
-    // Parsing array
-    const auto* array = ObjTypeCheck<const ffi::ArrayObj*>(obj, "Array");
-    std::vector<Any> result;
-    for (const Any& e : *array) {
-      try {
-        result.push_back(TargetInternal::ParseType(e, *info.key));
-      } catch (const Error& e) {
-        std::string index = '[' + std::to_string(result.size()) + ']';
-        throw Error(e.kind(), index + e.message(), e.backtrace());
-      }
-    }
-    return ffi::Array<Any>(result);
-  } else if (info.type_index == ffi::MapObj::RuntimeTypeIndex()) {
-    // Parsing map
-    const auto* map = ObjTypeCheck<const ffi::MapObj*>(obj, "Map");
-    std::unordered_map<Any, Any, ffi::AnyHash, ffi::AnyEqual> result;
-    for (const auto& kv : *map) {
-      Any key, val;
-      try {
-        key = TargetInternal::ParseType(kv.first, *info.key);
-      } catch (const Error& e) {
-        throw Error(e.kind(), e.message() + ", during parse key of map", e.backtrace());
-      }
-      try {
-        val = TargetInternal::ParseType(kv.second, *info.val);
-      } catch (const Error& e) {
-        std::ostringstream os;
-        os << ", during parseing value of map[\"" << key << "\"]";
-        throw Error(e.kind(), e.message() + os.str(), e.backtrace());
-      }
-      result[key] = val;
-    }
-    return ffi::Map<Any, Any>(result);
-  }
-  if (info.type_index != obj.type_index()) {
-    TVM_FFI_THROW(TypeError) << "Parsing type \"" << info.type_key
-                             << "\" is not supported for the given object of type \""
-                             << obj.GetTypeKey() << "\". The object is: " << obj;
-  }
-  return obj;
-}
-
 const std::string& TargetNode::str() const {
   if (str_repr_.empty()) {
-    str_repr_ = std::string(ffi::json::Stringify(Export()));
+    str_repr_ = std::string(ffi::json::Stringify(ToConfig()));
   }
   return str_repr_;
 }
@@ -227,7 +122,7 @@ Target::Target(const ffi::String& tag_or_config_or_target_str) {
 Target::Target(const ffi::Map<ffi::String, ffi::Any>& config) {
   ObjectPtr<Object> target;
   try {
-    target = TargetInternal::FromConfig({config.begin(), config.end()});
+    target = TargetInternal::FromConfig(config);
   } catch (const Error& e) {
     std::ostringstream os;
     os << ". Target creation from config dict failed: " << config;
@@ -253,34 +148,14 @@ Target::Target(TargetKind kind, ffi::Optional<ObjectRef> host, ffi::String tag,
   data_ = std::move(data);
 }
 
-std::vector<std::string> TargetNode::GetKeys() const {
-  std::vector<std::string> result;
-  for (auto& expr : keys) {
-    result.push_back(expr);
-  }
-  return result;
-}
-
-std::unordered_set<std::string> TargetNode::GetLibs() const {
-  ffi::Optional<ffi::Array<ffi::String>> libs = this->GetAttr<ffi::Array<ffi::String>>("libs");
-  if (!libs.defined()) {
-    return {};
-  }
-  std::unordered_set<std::string> result;
-  for (const auto& item : libs.value()) {
-    result.insert(item);
-  }
-  return result;
-}
-
-ffi::Map<ffi::String, ffi::Any> TargetNode::Export() const {
+ffi::Map<ffi::String, ffi::Any> TargetNode::ToConfig() const {
   ffi::Map<ffi::String, ffi::Any> result = {
       {"kind", this->kind->name},
       {"tag", this->tag},
       {"keys", this->keys},
   };
   if (this->host.defined()) {
-    result.Set("host", this->GetHost().value_or(Target())->Export());
+    result.Set("host", this->GetHost().value_or(Target())->ToConfig());
   }
   for (const auto& kv : attrs) {
     result.Set(kv.first, kv.second);
@@ -312,45 +187,6 @@ bool TargetNode::HasKey(const std::string& query_key) const {
                      [&query_key](const auto& key) { return key == query_key; });
 }
 
-ffi::String TargetNode::ToDebugString() const {
-  std::ostringstream os;
-  os << "Target(";
-  os << "id=" << std::hex << reinterpret_cast<size_t>(this);
-  os << ", kind='" << kind->name << "'";
-  if (!tag.empty()) {
-    os << ", tag='" << tag << "'";
-  }
-  if (!keys.empty()) {
-    os << ", keys={";
-    bool first = true;
-    for (const auto& key : keys) {
-      if (!first) {
-        os << ", ";
-      }
-      os << "'" << key << "'";
-      first = false;
-    }
-    os << "}";
-  }
-  if (!attrs.empty()) {
-    os << ", attrs={";
-    bool first = true;
-    for (const auto& pair : attrs) {
-      if (!first) {
-        os << ", ";
-      }
-      os << "'" << pair.first << "': " << pair.second;
-      first = false;
-    }
-    os << "}";
-  }
-  if (host.defined()) {
-    os << ", host=" << GetHost().value()->ToDebugString();
-  }
-  os << ")";
-  return os.str();
-}
-
 /*! \brief Entry to hold the Target context stack. */
 struct TVMTargetThreadLocalEntry {
   /*! \brief The current target context */
@@ -430,7 +266,7 @@ ObjectPtr<TargetNode> TargetInternal::FromString(const ffi::String& tag_or_confi
         << "\". CLI target string form (e.g. \"llvm -mcpu=xxx\") is no longer supported. "
         << "Please use JSON dict form (e.g. {\"kind\": \"llvm\", \"mcpu\": \"xxx\"}) instead.";
   }
-  return TargetInternal::FromConfig({{"kind", ffi::String(s)}});
+  return TargetInternal::FromConfig(ffi::Map<ffi::String, ffi::Any>{{"kind", ffi::String(s)}});
 }
 
 ObjectPtr<TargetNode> TargetInternal::FromConfigString(const ffi::String& config_str) {
@@ -443,7 +279,7 @@ ObjectPtr<TargetNode> TargetInternal::FromConfigString(const ffi::String& config
   if (!config.has_value()) {
     TVM_FFI_THROW(ValueError) << "Target JSON config must be a dict, got: " << config_str;
   }
-  return TargetInternal::FromConfig({config.value().begin(), config.value().end()});
+  return TargetInternal::FromConfig(config.value());
 }
 
 ObjectPtr<TargetNode> TargetInternal::FromConfig(ffi::Map<ffi::String, ffi::Any> config) {
@@ -452,29 +288,13 @@ ObjectPtr<TargetNode> TargetInternal::FromConfig(ffi::Map<ffi::String, ffi::Any>
   const ffi::String kKeys = "keys";
   const ffi::String kDeviceName = "device";
   const ffi::String kHost = "host";
-  const ffi::String kFeatures = "features";
+  const ffi::String kFromDevice = "from_device";
   ObjectPtr<TargetNode> target = ffi::make_object<TargetNode>();
 
-  ICHECK(!config.count(kFeatures)) << "Target Features should be generated by Target parser";
-
-  // parse 'kind'
+  // Step 1: Parse 'kind' (needed to look up the schema, but kept in config for canonicalizer)
   if (config.count(kKind)) {
     if (auto kind = config[kKind].try_cast<ffi::String>()) {
       target->kind = GetTargetKind(kind.value());
-      ICHECK(!(target->kind->preprocessor != nullptr && target->kind->target_parser != nullptr))
-          << "Cannot use both set_attrs_preprocessor and set_target_parser";
-
-      // Run JSON Parser over JSON input
-      if (target->kind->target_parser != nullptr) {
-        VLOG(9) << "TargetInternal::FromConfig - Running target_parser";
-        config = target->kind->target_parser(config);
-        if (config.count(kFeatures)) {
-          target->features = Downcast<ffi::Map<ffi::String, ffi::Any>>(config[kFeatures]);
-          config.erase(kFeatures);
-        }
-      }
-
-      config.erase(kKind);
     } else {
       TVM_FFI_THROW(TypeError) << "Expect type of field \"kind\" is String, but get type: "
                                << config[kKind].GetTypeKey();
@@ -482,82 +302,69 @@ ObjectPtr<TargetNode> TargetInternal::FromConfig(ffi::Map<ffi::String, ffi::Any>
   } else {
     TVM_FFI_THROW(ValueError) << "Field \"kind\" is not found";
   }
-  // parse "tag"
-  if (config.count(kTag)) {
-    if (auto tag = config[kTag].try_cast<ffi::String>()) {
+
+  // Step 2: Extract "host" before schema validation (needs special recursive parsing)
+  if (config.count(kHost)) {
+    target->host = ffi::Function(ConstructorDispatcher)(config[kHost]).cast<Target>();
+    config.erase(kHost);
+  } else {
+    target->host = std::nullopt;
+  }
+
+  // Step 3: Use ConfigSchema to validate types, apply defaults, and run canonicalizer
+  // Note: structural keys (kind, tag, keys, device) pass through to canonicalizer
+  ffi::Map<ffi::String, ffi::Any> resolved = target->kind->schema_.Resolve(config);
+
+  // Step 4: Extract structural fields from resolved config
+  if (resolved.count(kTag)) {
+    if (auto tag = resolved[kTag].try_cast<ffi::String>()) {
       target->tag = tag.value();
-      config.erase(kTag);
-    } else {
-      TVM_FFI_THROW(TypeError) << "Expect type of field \"tag\" is String, but get type: "
-                               << config[kTag].GetTypeKey();
     }
+    resolved.erase(kTag);
   } else {
     target->tag = "";
   }
-  // parse "keys"
+
   {
     std::vector<ffi::String> keys;
-    bool has_user_keys = config.count(kKeys);
-    if (has_user_keys) {
-      // user provided keys
-      if (const auto* cfg_keys = config[kKeys].as<ffi::ArrayObj>()) {
-        for (const Any& e : *cfg_keys) {
-          if (auto key = e.try_cast<ffi::String>()) {
-            keys.push_back(key.value());
-          } else {
-            TVM_FFI_THROW(TypeError) << "Expect 'keys' to be an array of strings, but it "
-                                     << "contains an element of type: " << e.GetTypeKey();
-          }
-        }
-      } else {
-        TVM_FFI_THROW(TypeError) << "Expect type of field \"keys\" is Array, but get type: "
-                                 << config[kKeys].GetTypeKey();
+    bool has_keys = resolved.count(kKeys);
+    if (has_keys) {
+      ffi::Array<ffi::String> cfg_keys = Downcast<ffi::Array<ffi::String>>(resolved.at(kKeys));
+      for (const ffi::String& key : cfg_keys) {
+        keys.push_back(key);
       }
     }
-    // add device name
-    if (config.count(kDeviceName)) {
-      if (auto device = config.at(kDeviceName).try_cast<ffi::String>()) {
+    if (resolved.count(kDeviceName)) {
+      if (auto device = resolved.at(kDeviceName).try_cast<ffi::String>()) {
         keys.push_back(device.value());
       }
     }
-    if (!has_user_keys) {
-      // add default keys
+    if (!has_keys) {
       for (const auto& key : target->kind->default_keys) {
         keys.push_back(key);
       }
     }
-    // de-duplicate keys
     target->keys = DeduplicateKeys(keys);
-    config.erase(kKeys);
+    resolved.erase(kKeys);
   }
-  // parse host
-  if (config.count(kHost)) {
-    target->host = ffi::Function(ConstructorDispatcher)(config[kHost]).cast<Target>();
-    config.erase(kHost);
-  } else {
-    target->host = std::nullopt;
-  }
-  // parse attrs
+
+  // Step 5: Build attrs from resolved entries (excluding structural keys)
+  resolved.erase(kKind);
   std::unordered_map<ffi::String, ffi::Any> attrs;
-  for (const auto& cfg_kv : config) {
-    const ffi::String& key = cfg_kv.first;
-    const ffi::Any& value = cfg_kv.second;
-    try {
-      const TargetKindNode::ValueTypeInfo& info = TargetInternal::FindTypeInfo(target->kind, key);
-      attrs[key] = TargetInternal::ParseType(value, info);
-    } catch (const Error& e) {
-      throw Error(e.kind(), std::string(e.message()) + ", during parsing target[\"" + key + "\"]",
-                  e.backtrace());
-    }
+  for (const auto& kv : resolved) {
+    attrs[kv.first] = kv.second;
   }
 
-  // If requested, query attributes from the device.  User-specified
+  // Step 6: If requested, query attributes from the device. User-specified
   // parameters take precedence over queried parameters.
-  if (attrs.count("from_device")) {
-    int device_id = attrs.at("from_device").cast<int64_t>();
-    attrs.erase("from_device");
-    auto device_params = QueryDevice(device_id, target.get());
+  int64_t from_device_id = -1;
+  if (auto it = attrs.find(kFromDevice); it != attrs.end()) {
+    from_device_id = it->second.cast<int64_t>();
+    attrs.erase(it);
+  }
 
+  if (from_device_id >= 0) {
+    auto device_params = QueryDevice(from_device_id, target.get());
     for (const auto& kv : device_params) {
       if (attrs.count(kv.first) == 0) {
         attrs[kv.first] = kv.second;
@@ -565,22 +372,9 @@ ObjectPtr<TargetNode> TargetInternal::FromConfig(ffi::Map<ffi::String, ffi::Any>
     }
   }
 
-  // set default attribute values if they do not exist
-  for (const auto& kv : target->kind->key2default_) {
-    if (!attrs.count(kv.first)) {
-      attrs[kv.first] = kv.second;
-    }
-  }
-  // do extra pre-processing
-  if (target->kind->preprocessor != nullptr) {
-    target->attrs = target->kind->preprocessor(ffi::Map<ffi::String, ffi::Any>(attrs))
-                        .cast<ffi::Map<ffi::String, ffi::Any>>();
-  } else {
-    target->attrs = attrs;
-  }
-
+  target->attrs = attrs;
   return target;
-}  // namespace tvm
+}
 
 std::unordered_map<ffi::String, ffi::Any> TargetInternal::QueryDevice(int device_id,
                                                                       const TargetNode* target) {
@@ -606,12 +400,12 @@ std::unordered_map<ffi::String, ffi::Any> TargetInternal::QueryDevice(int device
     return output;
   }
 
-  for (const auto& kv : target->kind->key2vtype_) {
-    const ffi::String& key = kv.first;
-
+  for (const auto& e : target->kind->schema_.ListOptions()) {
     ffi::Any ret;
-    api->GetTargetProperty(device, key, &ret);
-    output[key] = ret;
+    api->GetTargetProperty(device, e.key, &ret);
+    if (ret.type_index() != kTVMFFINone) {
+      output[e.key] = ret;
+    }
   }
 
   return output;
@@ -626,17 +420,18 @@ TVM_FFI_STATIC_INIT_BLOCK() {
       .def("target.TargetEnterScope", TargetInternal::EnterScope)
       .def("target.TargetExitScope", TargetInternal::ExitScope)
       .def("target.TargetCurrent", Target::Current)
-      .def("target.TargetExport", TargetInternal::Export)
+      .def("target.TargetExport", TargetInternal::ToConfig)
       .def("target.WithHost", TargetInternal::WithHost)
       .def("target.TargetGetDeviceType",
            [](const Target& target) { return target->GetTargetDeviceType(); })
       .def("target.TargetGetFeature",
            [](const Target& target, const ffi::String& feature_key) -> Any {
-             if (auto opt_any = target->GetFeature<Any>(feature_key)) {
-               return opt_any.value();
-             } else {
-               return Any();
+             ffi::String full_key = "feature." + std::string(feature_key);
+             auto it = target->attrs.find(full_key);
+             if (it != target->attrs.end()) {
+               return (*it).second;
              }
+             return Any();
            });
 }
 
diff --git a/src/target/target_kind.cc b/src/target/target_kind.cc
index 96e90f17ac79..b3f37e6cb653 100644
--- a/src/target/target_kind.cc
+++ b/src/target/target_kind.cc
@@ -32,10 +32,12 @@
 
 #include "../node/attr_registry.h"
 #include "../support/utils.h"
-#include "./parsers/cpu.h"
+#include "./canonicalizer/llvm/canonicalize.h"
 
 namespace tvm {
 
+namespace refl = ffi::reflection;
+
 TVM_FFI_STATIC_INIT_BLOCK() {
   namespace refl = tvm::ffi::reflection;
   TargetKindNode::RegisterReflection();
@@ -69,8 +71,8 @@ ffi::Array<ffi::String> TargetKindRegEntry::ListTargetKinds() {
 ffi::Map<ffi::String, ffi::String> TargetKindRegEntry::ListTargetKindOptions(
     const TargetKind& target_kind) {
   ffi::Map<ffi::String, ffi::String> options;
-  for (const auto& kv : target_kind->key2vtype_) {
-    options.Set(kv.first, kv.second.type_key);
+  for (const auto& e : target_kind->schema_.ListOptions()) {
+    options.Set(e.key, e.type_str);
   }
   return options;
 }
@@ -160,7 +162,7 @@ void CheckOrSetAttr(ffi::Map<ffi::String, ffi::Any>* attrs, const ffi::String& n
  * \param target The Target to update
  * \return The updated attributes
  */
-TargetJSON UpdateCUDAAttrs(TargetJSON target) {
+ffi::Map<ffi::String, ffi::Any> UpdateCUDAAttrs(ffi::Map<ffi::String, ffi::Any> target) {
   // Update -arch=sm_xx
   if (target.count("arch")) {
     // If -arch has been specified, validate the correctness
@@ -187,7 +189,7 @@ TargetJSON UpdateCUDAAttrs(TargetJSON target) {
  * \param target The Target to update
  * \return The updated attributes
  */
-TargetJSON UpdateNVPTXAttrs(TargetJSON target) {
+ffi::Map<ffi::String, ffi::Any> UpdateNVPTXAttrs(ffi::Map<ffi::String, ffi::Any> target) {
   CheckOrSetAttr(&target, "mtriple", "nvptx64-nvidia-cuda");
   // Update -mcpu=sm_xx
   if (target.count("mcpu")) {
@@ -215,7 +217,7 @@ TargetJSON UpdateNVPTXAttrs(TargetJSON target) {
  * \param target The Target to update
  * \return The updated attributes
  */
-TargetJSON UpdateROCmAttrs(TargetJSON target) {
+ffi::Map<ffi::String, ffi::Any> UpdateROCmAttrs(ffi::Map<ffi::String, ffi::Any> target) {
   CheckOrSetAttr(&target, "mtriple", "amdgcn-amd-amdhsa-hcc");
   // Update -mcpu=gfx
   std::string arch = "gfx900";
@@ -258,9 +260,8 @@ TargetJSON UpdateROCmAttrs(TargetJSON target) {
  * \param target The Target to update
  * \return The updated attributes
  */
-TargetJSON TestTargetParser(TargetJSON target) {
-  ffi::Map<ffi::String, ffi::Any> features = {{"is_test", true}};
-  target.Set("features", features);
+ffi::Map<ffi::String, ffi::Any> TestTargetParser(ffi::Map<ffi::String, ffi::Any> target) {
+  target.Set("feature.is_test", true);
   return target;
 }
 
@@ -291,7 +292,7 @@ TVM_REGISTER_TARGET_KIND("llvm", kDLCPU)
     .set_default_keys({"cpu"})
     // Force the external codegen kind attribute to be registered, even if no external
     // codegen targets are enabled by the TVM build.
-    .set_target_parser(tvm::target::parsers::cpu::ParseTarget);
+    .set_target_canonicalizer(tvm::target::canonicalizer::llvm::Canonicalize);
 
 // Note regarding the "cl-opt" attribute:
 // Each string in the array has the format
@@ -321,27 +322,28 @@ TVM_REGISTER_TARGET_KIND("c", kDLCPU)
     .add_attr_option<int64_t>("workspace-byte-alignment")
     .add_attr_option<int64_t>("constants-byte-alignment")
     .set_default_keys({"cpu"})
-    .set_target_parser(tvm::target::parsers::cpu::ParseTarget);
+    .set_target_canonicalizer(tvm::target::canonicalizer::llvm::Canonicalize);
 
 TVM_REGISTER_TARGET_KIND("cuda", kDLCUDA)
     .add_attr_option<ffi::String>("mcpu")
     .add_attr_option<ffi::String>("arch")
     .add_attr_option<int64_t>("max_shared_memory_per_block")
     .add_attr_option<int64_t>("max_threads_per_block")
-    .add_attr_option<int64_t>("thread_warp_size", 32)
+    .add_attr_option<int64_t>("thread_warp_size", refl::DefaultValue(32))
     .add_attr_option<int64_t>("registers_per_block")
     .add_attr_option<int64_t>("l2_cache_size_bytes")
-    .add_attr_option<int64_t>("max_num_threads", 1024)  // TODO(@zxybazh): deprecate it
+    .add_attr_option<int64_t>("max_num_threads",
+                              refl::DefaultValue(1024))  // TODO(@zxybazh): deprecate it
     .set_default_keys({"cuda", "gpu"})
-    .set_target_parser(UpdateCUDAAttrs);
+    .set_target_canonicalizer(UpdateCUDAAttrs);
 
 TVM_REGISTER_TARGET_KIND("nvptx", kDLCUDA)
     .add_attr_option<ffi::String>("mcpu")
     .add_attr_option<ffi::String>("mtriple")
-    .add_attr_option<int64_t>("max_num_threads", 1024)
-    .add_attr_option<int64_t>("thread_warp_size", 32)
+    .add_attr_option<int64_t>("max_num_threads", refl::DefaultValue(1024))
+    .add_attr_option<int64_t>("thread_warp_size", refl::DefaultValue(32))
     .set_default_keys({"cuda", "gpu"})
-    .set_target_parser(UpdateNVPTXAttrs);
+    .set_target_canonicalizer(UpdateNVPTXAttrs);
 
 TVM_REGISTER_TARGET_KIND("rocm", kDLROCM)
     .add_attr_option<ffi::String>("mcpu")
@@ -349,26 +351,26 @@ TVM_REGISTER_TARGET_KIND("rocm", kDLROCM)
     .add_attr_option<ffi::Array<ffi::String>>("mattr")
     // TODO(masahi): Support querying from a target device
     // On RDNA cards, thread_warp_size should be 32
-    .add_attr_option<int64_t>("max_num_threads", 256)
-    .add_attr_option<int64_t>("max_threads_per_block", 256)
-    .add_attr_option<int64_t>("max_shared_memory_per_block", 65536)
-    .add_attr_option<int64_t>("thread_warp_size", 64)
+    .add_attr_option<int64_t>("max_num_threads", refl::DefaultValue(256))
+    .add_attr_option<int64_t>("max_threads_per_block", refl::DefaultValue(256))
+    .add_attr_option<int64_t>("max_shared_memory_per_block", refl::DefaultValue(65536))
+    .add_attr_option<int64_t>("thread_warp_size", refl::DefaultValue(64))
     .set_default_keys({"rocm", "gpu"})
-    .set_target_parser(UpdateROCmAttrs);
+    .set_target_canonicalizer(UpdateROCmAttrs);
 
 TVM_REGISTER_TARGET_KIND("opencl", kDLOpenCL)
-    .add_attr_option<int64_t>("max_threads_per_block", 256)
-    .add_attr_option<int64_t>("max_shared_memory_per_block", 16384)
-    .add_attr_option<int64_t>("max_num_threads", 256)
-    .add_attr_option<int64_t>("thread_warp_size", 1)
-    .add_attr_option<int64_t>("texture_spatial_limit", 16384)
-    .add_attr_option<int64_t>("texture_depth_limit", 2048)
+    .add_attr_option<int64_t>("max_threads_per_block", refl::DefaultValue(256))
+    .add_attr_option<int64_t>("max_shared_memory_per_block", refl::DefaultValue(16384))
+    .add_attr_option<int64_t>("max_num_threads", refl::DefaultValue(256))
+    .add_attr_option<int64_t>("thread_warp_size", refl::DefaultValue(1))
+    .add_attr_option<int64_t>("texture_spatial_limit", refl::DefaultValue(16384))
+    .add_attr_option<int64_t>("texture_depth_limit", refl::DefaultValue(2048))
     // Faced that Qualcomm OpenCL runtime crashed without any error message in
     // the case when the number of kernel arguments was pretty big. OpenCL doesn't
     // specify any limitations on the number of kernel arguments. max_function_args
     // equals to 128 looks like a reasonable number of kernel arguments.
-    .add_attr_option<int64_t>("max_function_args", 128)
-    .add_attr_option<int64_t>("image_base_address_alignment", 64)
+    .add_attr_option<int64_t>("max_function_args", refl::DefaultValue(128))
+    .add_attr_option<int64_t>("image_base_address_alignment", refl::DefaultValue(64))
     .set_default_keys({"opencl", "gpu"});
 
 // The metal has some limitations on the number of input parameters. This is why attribute
@@ -377,22 +379,22 @@ TVM_REGISTER_TARGET_KIND("opencl", kDLOpenCL)
 // https://developer.apple.com/documentation/metal/buffers/about_argument_buffers?language=objc
 // See also https://developer.apple.com/metal/Metal-Feature-Set-Tables.pdf
 TVM_REGISTER_TARGET_KIND("metal", kDLMetal)
-    .add_attr_option<int64_t>("max_num_threads", 256)
-    .add_attr_option<int64_t>("max_threads_per_block", 256)
-    .add_attr_option<int64_t>("max_shared_memory_per_block", 32768)
-    .add_attr_option<int64_t>("thread_warp_size", 16)
-    .add_attr_option<int64_t>("max_function_args", 31)
+    .add_attr_option<int64_t>("max_num_threads", refl::DefaultValue(256))
+    .add_attr_option<int64_t>("max_threads_per_block", refl::DefaultValue(256))
+    .add_attr_option<int64_t>("max_shared_memory_per_block", refl::DefaultValue(32768))
+    .add_attr_option<int64_t>("thread_warp_size", refl::DefaultValue(16))
+    .add_attr_option<int64_t>("max_function_args", refl::DefaultValue(31))
     .set_default_keys({"metal", "gpu"});
 
 TVM_REGISTER_TARGET_KIND("vulkan", kDLVulkan)
     .add_attr_option<ffi::Array<ffi::String>>("mattr")
     // Feature support
     .add_attr_option<bool>("supports_float16")
-    .add_attr_option<bool>("supports_float32", true)
+    .add_attr_option<bool>("supports_float32", refl::DefaultValue(true))
     .add_attr_option<bool>("supports_float64")
     .add_attr_option<bool>("supports_int8")
     .add_attr_option<bool>("supports_int16")
-    .add_attr_option<bool>("supports_int32", true)
+    .add_attr_option<bool>("supports_int32", refl::DefaultValue(true))
     .add_attr_option<bool>("supports_int64")
     .add_attr_option<bool>("supports_8bit_buffer")
     .add_attr_option<bool>("supports_16bit_buffer")
@@ -403,9 +405,9 @@ TVM_REGISTER_TARGET_KIND("vulkan", kDLVulkan)
     .add_attr_option<bool>("supports_cooperative_matrix")
     .add_attr_option<int64_t>("supported_subgroup_operations")
     // Physical device limits
-    .add_attr_option<int64_t>("max_num_threads", 256)
-    .add_attr_option<int64_t>("max_threads_per_block", 256)
-    .add_attr_option<int64_t>("thread_warp_size", 1)
+    .add_attr_option<int64_t>("max_num_threads", refl::DefaultValue(256))
+    .add_attr_option<int64_t>("max_threads_per_block", refl::DefaultValue(256))
+    .add_attr_option<int64_t>("thread_warp_size", refl::DefaultValue(1))
     .add_attr_option<int64_t>("max_block_size_x")
     .add_attr_option<int64_t>("max_block_size_y")
     .add_attr_option<int64_t>("max_block_size_z")
@@ -425,7 +427,7 @@ TVM_REGISTER_TARGET_KIND("vulkan", kDLVulkan)
     .set_default_keys({"vulkan", "gpu"});
 
 TVM_REGISTER_TARGET_KIND("webgpu", kDLWebGPU)
-    .add_attr_option<int64_t>("max_num_threads", 256)
+    .add_attr_option<int64_t>("max_num_threads", refl::DefaultValue(256))
     .set_default_keys({"webgpu", "gpu"});
 
 TVM_REGISTER_TARGET_KIND("hexagon", kDLHexagon)
@@ -440,10 +442,32 @@ TVM_REGISTER_TARGET_KIND("hexagon", kDLHexagon)
 TVM_REGISTER_TARGET_KIND("ext_dev", kDLExtDev);
 
 TVM_REGISTER_TARGET_KIND("composite", kDLCPU)  // line break
-    .add_attr_option<ffi::Array<Target>>("devices");
+    .add_attr_option<ffi::Array<Target>>(
+        "devices",
+        ir::ConfigSchema::AttrValidator(ffi::TypedFunction<ffi::Any(ffi::Any)>(  //
+            [](ffi::Any val) -> ffi::Any {
+              // Allow elements to be strings or dicts, converting them to Target objects.
+              if (val.try_cast<ffi::Array<Target>>().has_value()) return val;
+              auto arr = val.cast<ffi::Array<ffi::Any>>();
+              ffi::Array<Target> result;
+              for (const auto& elem : arr) {
+                if (auto t = elem.try_cast<Target>()) {
+                  result.push_back(t.value());
+                } else if (auto s = elem.try_cast<ffi::String>()) {
+                  result.push_back(Target(s.value()));
+                } else if (auto m = elem.try_cast<ffi::Map<ffi::String, ffi::Any>>()) {
+                  result.push_back(Target(m.value()));
+                } else {
+                  TVM_FFI_THROW(TypeError)
+                      << "Expected Target, string, or dict in 'devices' array, got '"
+                      << elem.GetTypeKey() << "'";
+                }
+              }
+              return ffi::Any(result);
+            })));
 
 TVM_REGISTER_TARGET_KIND("test", kDLCPU)  // line break
-    .set_target_parser(TestTargetParser);
+    .set_target_canonicalizer(TestTargetParser);
 
 /**********  Registry  **********/
 
diff --git a/src/target/virtual_device.cc b/src/target/virtual_device.cc
index 54529acb409c..6c797143f020 100644
--- a/src/target/virtual_device.cc
+++ b/src/target/virtual_device.cc
@@ -53,7 +53,7 @@ TVM_STATIC_IR_FUNCTOR(ReprPrinter, vtable)
           if (need_sep) {
             p->stream << ", ";
           }
-          p->stream << "target=" << node->target->ToDebugString();
+          p->stream << "target=" << node->target->str();
           need_sep = true;
         }
         if (!node->memory_scope.empty()) {
@@ -69,8 +69,8 @@ TVM_STATIC_IR_FUNCTOR(ReprPrinter, vtable)
 VirtualDevice::VirtualDevice(int device_type_int, int virtual_device_id, Target target,
                              MemoryScope memory_scope) {
   ICHECK(!target.defined() || device_type_int == target->GetTargetDeviceType())
-      << "target " << target->ToDebugString() << " has device type "
-      << target->GetTargetDeviceType() << " but virtual device has device type " << device_type_int;
+      << "target " << target->str() << " has device type " << target->GetTargetDeviceType()
+      << " but virtual device has device type " << device_type_int;
   auto node = ffi::make_object<VirtualDeviceNode>();
   node->device_type_int = device_type_int;
   node->virtual_device_id = virtual_device_id;
diff --git a/tests/cpp/config_schema_test.cc b/tests/cpp/config_schema_test.cc
new file mode 100644
index 000000000000..9db23a20ec42
--- /dev/null
+++ b/tests/cpp/config_schema_test.cc
@@ -0,0 +1,323 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include <gtest/gtest.h>
+#include <tvm/ffi/container/array.h>
+#include <tvm/ffi/container/map.h>
+#include <tvm/ffi/string.h>
+#include <tvm/ir/config_schema.h>
+
+using namespace tvm;
+using namespace tvm::ir;
+namespace refl = tvm::ffi::reflection;
+
+// Basic int/bool/string option resolution
+TEST(ConfigSchema, BasicTypes) {
+  ConfigSchema schema;
+  schema.def_option<int64_t>("num_threads");
+  schema.def_option<bool>("verbose");
+  schema.def_option<ffi::String>("name");
+
+  ffi::Map<ffi::String, ffi::Any> config = {
+      {"num_threads", int64_t(8)},
+      {"verbose", true},
+      {"name", ffi::String("test")},
+  };
+
+  auto resolved = schema.Resolve(config);
+  ASSERT_EQ(resolved.at("num_threads").cast<int64_t>(), 8);
+  ASSERT_EQ(resolved.at("verbose").cast<bool>(), true);
+  ASSERT_EQ(resolved.at("name").cast<ffi::String>(), "test");
+}
+
+// Type coercion: correct type passes
+TEST(ConfigSchema, TypeCoercionPasses) {
+  ConfigSchema schema;
+  schema.def_option<int64_t>("count");
+
+  ffi::Map<ffi::String, ffi::Any> config = {{"count", int64_t(42)}};
+  auto resolved = schema.Resolve(config);
+  ASSERT_EQ(resolved.at("count").cast<int64_t>(), 42);
+}
+
+// Type mismatch rejection (TypeError)
+TEST(ConfigSchema, TypeMismatchRejection) {
+  ConfigSchema schema;
+  schema.def_option<int64_t>("count");
+
+  // Pass a string where int64_t is expected
+  ffi::Map<ffi::String, ffi::Any> config = {{"count", ffi::String("not_a_number")}};
+  try {
+    schema.Resolve(config);
+    FAIL() << "Expected TypeError";
+  } catch (const ffi::Error& e) {
+    EXPECT_EQ(e.kind(), "TypeError");
+    EXPECT_NE(std::string(e.message()).find("count"), std::string::npos);
+  }
+}
+
+TEST(ConfigSchema, TypeMismatchBoolForInt) {
+  ConfigSchema schema;
+  schema.def_option<bool>("flag");
+
+  // Pass a string where bool is expected
+  ffi::Map<ffi::String, ffi::Any> config = {{"flag", ffi::String("true")}};
+  try {
+    schema.Resolve(config);
+    FAIL() << "Expected TypeError";
+  } catch (const ffi::Error& e) {
+    EXPECT_EQ(e.kind(), "TypeError");
+    EXPECT_NE(std::string(e.message()).find("flag"), std::string::npos);
+  }
+}
+
+// Default value materialization via refl::DefaultValue
+TEST(ConfigSchema, DefaultValueMaterialization) {
+  ConfigSchema schema;
+  schema.def_option<int64_t>("max_threads", refl::DefaultValue(int64_t(256)));
+  schema.def_option<bool>("debug", refl::DefaultValue(false));
+
+  // Empty config -> defaults are applied
+  ffi::Map<ffi::String, ffi::Any> config = {};
+  auto resolved = schema.Resolve(config);
+  ASSERT_EQ(resolved.at("max_threads").cast<int64_t>(), 256);
+  ASSERT_EQ(resolved.at("debug").cast<bool>(), false);
+}
+
+// Default value materialization via refl::DefaultValue
+TEST(ConfigSchema, DefaultValueViaTrait) {
+  ConfigSchema schema;
+  schema.def_option<int64_t>("max_threads", refl::DefaultValue(int64_t(128)));
+
+  ffi::Map<ffi::String, ffi::Any> config = {};
+  auto resolved = schema.Resolve(config);
+  ASSERT_EQ(resolved.at("max_threads").cast<int64_t>(), 128);
+}
+
+// Explicit value overrides default
+TEST(ConfigSchema, ExplicitOverridesDefault) {
+  ConfigSchema schema;
+  schema.def_option<int64_t>("max_threads", refl::DefaultValue(int64_t(256)));
+
+  ffi::Map<ffi::String, ffi::Any> config = {{"max_threads", int64_t(512)}};
+  auto resolved = schema.Resolve(config);
+  ASSERT_EQ(resolved.at("max_threads").cast<int64_t>(), 512);
+}
+
+// Missing non-required option stays absent
+TEST(ConfigSchema, MissingNonRequired) {
+  ConfigSchema schema;
+  schema.def_option<ffi::String>("optional_name");  // no default
+
+  ffi::Map<ffi::String, ffi::Any> config = {};
+  auto resolved = schema.Resolve(config);
+  ASSERT_EQ(resolved.find("optional_name"), resolved.end());
+}
+
+// Unknown key rejection (ValueError)
+TEST(ConfigSchema, UnknownKeyRejection) {
+  ConfigSchema schema;
+  schema.def_option<int64_t>("known_key");
+
+  ffi::Map<ffi::String, ffi::Any> config = {
+      {"known_key", int64_t(1)},
+      {"unknown_key", ffi::String("surprise")},
+  };
+  try {
+    schema.Resolve(config);
+    FAIL() << "Expected ValueError";
+  } catch (const ffi::Error& e) {
+    EXPECT_EQ(e.kind(), "ValueError");
+    EXPECT_NE(std::string(e.message()).find("unknown_key"), std::string::npos);
+  }
+}
+
+// Unknown key allowed when error_on_unknown is false
+TEST(ConfigSchema, UnknownKeyAllowed) {
+  ConfigSchema schema;
+  schema.def_option<int64_t>("known_key");
+  schema.set_error_on_unknown(false);
+
+  ffi::Map<ffi::String, ffi::Any> config = {
+      {"known_key", int64_t(1)},
+      {"unknown_key", ffi::String("allowed")},
+  };
+  auto resolved = schema.Resolve(config);
+  // Unknown keys are silently dropped (not validated, not forwarded)
+  ASSERT_EQ(resolved.at("known_key").cast<int64_t>(), 1);
+}
+
+// Canonicalizer runs as final step
+TEST(ConfigSchema, CanonicalizerRunsLast) {
+  ConfigSchema schema;
+  schema.def_option<ffi::String>("mcpu");
+
+  auto canonicalizer = [](ffi::Map<ffi::String, ffi::Any> config) {
+    ffi::String mcpu = config.at("mcpu").cast<ffi::String>();
+    config.Set("mcpu", ffi::String("canonical_") + mcpu);
+    // Canonicalizer can add new keys
+    config.Set("feature.is_fast", true);
+    return config;
+  };
+  schema.set_canonicalizer(canonicalizer);
+
+  ffi::Map<ffi::String, ffi::Any> config = {{"mcpu", ffi::String("arm")}};
+  auto resolved = schema.Resolve(config);
+  ASSERT_EQ(resolved.at("mcpu").cast<ffi::String>(), "canonical_arm");
+  ASSERT_EQ(resolved.at("feature.is_fast").cast<bool>(), true);
+}
+
+// Option declaration order is preserved in output
+TEST(ConfigSchema, DeclarationOrderPreserved) {
+  ConfigSchema schema;
+  schema.def_option<ffi::String>("zebra");
+  schema.def_option<ffi::String>("alpha");
+  schema.def_option<ffi::String>("middle");
+
+  auto& options = schema.ListOptions();
+  ASSERT_EQ(options.size(), 3);
+  ASSERT_EQ(std::string(options[0].key), "zebra");
+  ASSERT_EQ(std::string(options[1].key), "alpha");
+  ASSERT_EQ(std::string(options[2].key), "middle");
+}
+
+// Doc string trait accepted without affecting behavior
+TEST(ConfigSchema, DocStringTrait) {
+  ConfigSchema schema;
+  schema.def_option<int64_t>("count", "Number of items to process");
+
+  ffi::Map<ffi::String, ffi::Any> config = {{"count", int64_t(5)}};
+  auto resolved = schema.Resolve(config);
+  ASSERT_EQ(resolved.at("count").cast<int64_t>(), 5);
+}
+
+// Array option type
+TEST(ConfigSchema, ArrayOptionType) {
+  ConfigSchema schema;
+  schema.def_option<ffi::Array<ffi::String>>("keys");
+
+  ffi::Map<ffi::String, ffi::Any> config = {
+      {"keys", ffi::Array<ffi::String>{"cpu", "gpu"}},
+  };
+  auto resolved = schema.Resolve(config);
+  auto keys = resolved.at("keys").cast<ffi::Array<ffi::String>>();
+  ASSERT_EQ(keys.size(), 2);
+  ASSERT_EQ(keys[0], "cpu");
+  ASSERT_EQ(keys[1], "gpu");
+}
+
+// Map option type
+TEST(ConfigSchema, MapOptionType) {
+  ConfigSchema schema;
+  schema.def_option<ffi::Map<ffi::String, int64_t>>("params");
+
+  ffi::Map<ffi::String, int64_t> params = {{"a", 1}, {"b", 2}};
+  ffi::Map<ffi::String, ffi::Any> config = {{"params", params}};
+  auto resolved = schema.Resolve(config);
+  auto result = resolved.at("params").cast<ffi::Map<ffi::String, int64_t>>();
+  ASSERT_EQ(result.size(), 2);
+  ASSERT_EQ(result["a"], 1);
+  ASSERT_EQ(result["b"], 2);
+}
+
+// Duplicate option key rejected
+TEST(ConfigSchema, DuplicateKeyRejected) {
+  ConfigSchema schema;
+  schema.def_option<int64_t>("key1");
+  try {
+    schema.def_option<int64_t>("key1");
+    FAIL() << "Expected ValueError";
+  } catch (const ffi::Error& e) {
+    EXPECT_EQ(e.kind(), "ValueError");
+    EXPECT_NE(std::string(e.message()).find("key1"), std::string::npos);
+  }
+}
+
+// ListOptions returns option entries in declaration order
+TEST(ConfigSchema, ListOptionsNames) {
+  ConfigSchema schema;
+  schema.def_option<int64_t>("no_default");
+  schema.def_option<bool>("with_default", refl::DefaultValue(true));
+
+  auto& options = schema.ListOptions();
+  ASSERT_EQ(options.size(), 2);
+  ASSERT_EQ(std::string(options[0].key), "no_default");
+  ASSERT_EQ(std::string(options[1].key), "with_default");
+  ASSERT_EQ(std::string(options[0].type_str), "int");
+  ASSERT_EQ(std::string(options[1].type_str), "bool");
+  // Check default_value
+  ASSERT_FALSE(options[0].has_default);
+  ASSERT_TRUE(options[1].has_default);
+  ASSERT_EQ(options[1].default_value.cast<bool>(), true);
+}
+
+// OptionEntry stores correct type strings
+TEST(ConfigSchema, OptionEntryTypeStr) {
+  ConfigSchema schema;
+  schema.def_option<int64_t>("count");
+  schema.def_option<bool>("flag");
+
+  auto& options = schema.ListOptions();
+  ASSERT_EQ(std::string(options[0].type_str), "int");
+  ASSERT_EQ(std::string(options[1].type_str), "bool");
+}
+
+// HasOption query
+TEST(ConfigSchema, HasOption) {
+  ConfigSchema schema;
+  schema.def_option<int64_t>("exists");
+  ASSERT_TRUE(schema.HasOption("exists"));
+  ASSERT_FALSE(schema.HasOption("does_not_exist"));
+}
+
+// Empty config with no options
+TEST(ConfigSchema, EmptySchemaEmptyConfig) {
+  ConfigSchema schema;
+  ffi::Map<ffi::String, ffi::Any> config = {};
+  auto resolved = schema.Resolve(config);
+  ASSERT_EQ(resolved.size(), 0);
+}
+
+// Canonicalizer with defaults
+TEST(ConfigSchema, CanonicalizerWithDefaults) {
+  ConfigSchema schema;
+  schema.def_option<int64_t>("threads", refl::DefaultValue(int64_t(4)));
+
+  auto canonicalizer = [](ffi::Map<ffi::String, ffi::Any> config) {
+    int64_t threads = config.at("threads").cast<int64_t>();
+    config.Set("threads", threads * 2);
+    return config;
+  };
+  schema.set_canonicalizer(canonicalizer);
+
+  // Empty config: default 4 applied, then canonicalizer doubles it
+  ffi::Map<ffi::String, ffi::Any> config = {};
+  auto resolved = schema.Resolve(config);
+  ASSERT_EQ(resolved.at("threads").cast<int64_t>(), 8);
+}
+
+// Combined doc + default traits
+TEST(ConfigSchema, DocAndDefaultTraits) {
+  ConfigSchema schema;
+  schema.def_option<int64_t>("num_cores", "CPU core count", refl::DefaultValue(int64_t(4)));
+
+  ffi::Map<ffi::String, ffi::Any> config = {};
+  auto resolved = schema.Resolve(config);
+  ASSERT_EQ(resolved.at("num_cores").cast<int64_t>(), 4);
+}
diff --git a/tests/cpp/target/canonicalizer/arm_aprofile_test.cc b/tests/cpp/target/canonicalizer/arm_aprofile_test.cc
new file mode 100644
index 000000000000..a30a4edc2574
--- /dev/null
+++ b/tests/cpp/target/canonicalizer/arm_aprofile_test.cc
@@ -0,0 +1,415 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "../src/target/canonicalizer/llvm/arm_aprofile.h"
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <cmath>
+#include <string>
+
+#include "../src/target/llvm/llvm_instance.h"
+
+namespace tvm {
+namespace target {
+namespace canonicalizer {
+namespace llvm {
+namespace aprofile {
+
+using ::testing::HasSubstr;
+
+static float defaultI8MM = 8.6;
+static float optionalI8MM[] = {8.2, 8.3, 8.4, 8.5};
+static float defaultDotProd = 8.4;
+static float optionalDotProd[] = {8.2, 8.3};
+static float optionalSME[] = {9.2, 9.3};
+
+static bool CheckArchitectureAvailability() {
+#if TVM_LLVM_VERSION > 120
+  auto llvm_instance = std::make_unique<codegen::LLVMInstance>();
+  codegen::LLVMTargetInfo llvm_backend(*llvm_instance, "llvm");
+  ffi::Array<ffi::String> targets = llvm_backend.GetAllLLVMTargets();
+  int expected_target_count = 0;
+  for (ffi::String target : targets) {
+    if (target == "aarch64" || target == "arm") {
+      expected_target_count += 1;
+    }
+  }
+  if (expected_target_count >= 2) {
+    return true;
+  }
+#endif
+  return false;
+}
+static bool has_aarch64_and_arm_targets = CheckArchitectureAvailability();
+
+class AProfileCanonicalizerTest : public ::testing::Test {
+ public:
+  void SetUp() override {
+    if (!has_aarch64_and_arm_targets) {
+      GTEST_SKIP() << "Skipping as LLVM has not been built for Arm(R)-based targets.";
+    }
+  }
+};
+
+class AProfileCanonicalizerTestWithParam : public AProfileCanonicalizerTest,
+                                           public testing::WithParamInterface<float> {};
+
+static ffi::Map<ffi::String, ffi::Any> CanonicalizeTargetWithAttrs(ffi::String mcpu,
+                                                                   ffi::String mtriple,
+                                                                   ffi::Array<ffi::String> mattr) {
+  ffi::Map<ffi::String, ffi::Any> target_json = {
+      {"kind", ffi::String("llvm")},
+      {"mtriple", mtriple},
+      {"mattr", mattr},
+  };
+  if (mcpu != "") {
+    target_json.Set("mcpu", mcpu);
+  }
+  return Canonicalize(target_json);
+}
+
+std::string FloatToStringWithoutTrailingZeros(float value) {
+  std::stringstream ss;
+  ss << value;
+  return ss.str();
+}
+
+TEST_F(AProfileCanonicalizerTest, CanonicalizeTargetKeys) {
+  ffi::Map<ffi::String, ffi::Any> target = Canonicalize({{"kind", ffi::String("llvm")}});
+  ffi::Array<ffi::String> keys = Downcast<ffi::Array<ffi::String>>(target.at("keys"));
+  ASSERT_EQ(keys.size(), 2);
+  ASSERT_EQ(keys[0], "arm_cpu");
+  ASSERT_EQ(keys[1], "cpu");
+}
+
+TEST_F(AProfileCanonicalizerTest, CanonicalizeTargetWithExistingKeys) {
+  ffi::Map<ffi::String, ffi::Any> target = Canonicalize({
+      {"kind", ffi::String("llvm")},
+      {"keys", ffi::Array<ffi::String>{"cpu"}},
+  });
+  ffi::Array<ffi::String> keys = Downcast<ffi::Array<ffi::String>>(target.at("keys"));
+  ASSERT_EQ(keys.size(), 2);
+  ASSERT_EQ(keys[0], "cpu");
+  ASSERT_EQ(keys[1], "arm_cpu");
+}
+
+TEST_F(AProfileCanonicalizerTest, CanonicalizeTargetWithDuplicateKey) {
+  ffi::Map<ffi::String, ffi::Any> target = Canonicalize({
+      {"kind", ffi::String("llvm")},
+      {"keys", ffi::Array<ffi::String>{"cpu", "arm_cpu"}},
+  });
+  ffi::Array<ffi::String> keys = Downcast<ffi::Array<ffi::String>>(target.at("keys"));
+  ASSERT_EQ(keys.size(), 2);
+  ASSERT_EQ(keys[0], "cpu");
+  ASSERT_EQ(keys[1], "arm_cpu");
+}
+
+TEST_F(AProfileCanonicalizerTest, CanonicalizeTargetDefaults) {
+  ffi::Map<ffi::String, ffi::Any> target = Canonicalize({{"kind", ffi::String("llvm")}});
+
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.is_aarch64")), false);
+}
+
+TEST_F(AProfileCanonicalizerTest, IsAArch64Triple) {
+  ffi::Map<ffi::String, ffi::Any> target =
+      CanonicalizeTargetWithAttrs("", "aarch64-arm-none-eabi", {""});
+  ASSERT_EQ(IsArch(target), true);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.is_aarch64")), true);
+}
+
+TEST_F(AProfileCanonicalizerTest, IsAArch32Triple) {
+  ffi::Map<ffi::String, ffi::Any> target =
+      CanonicalizeTargetWithAttrs("", "armv7a-arm-none-eabi", {""});
+  ASSERT_EQ(IsArch(target), true);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.is_aarch64")), false);
+
+  target = CanonicalizeTargetWithAttrs("", "armv8a-arm-none-eabi", {""});
+  ASSERT_EQ(IsArch(target), true);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.is_aarch64")), false);
+
+  target = CanonicalizeTargetWithAttrs("", "arm-unknown-linux-gnu", {""});
+  ASSERT_EQ(IsArch(target), true);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.is_aarch64")), false);
+}
+
+TEST_F(AProfileCanonicalizerTest, IsAArch32BlankCPU) {
+  ffi::Map<ffi::String, ffi::Any> target = Canonicalize({
+      {"kind", ffi::String("llvm")},
+      {"mtriple", ffi::String("arm-unknown-linux-gnu")},
+  });
+  ASSERT_EQ(IsArch(target), true);
+}
+
+TEST_F(AProfileCanonicalizerTest, IsAArch32TripleWithAProfile) {
+  ffi::Map<ffi::String, ffi::Any> target =
+      CanonicalizeTargetWithAttrs("cortex-a53", "armv7a-arm-none-eabi", {""});
+  ASSERT_EQ(IsArch(target), true);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.is_aarch64")), false);
+
+  target = CanonicalizeTargetWithAttrs("cortex-a53", "armv8a-arm-none-eabi", {""});
+  ASSERT_EQ(IsArch(target), true);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.is_aarch64")), false);
+
+  target = CanonicalizeTargetWithAttrs("cortex-a53", "arm-unknown-linux-gnu", {""});
+  ASSERT_EQ(IsArch(target), true);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.is_aarch64")), false);
+}
+
+TEST_F(AProfileCanonicalizerTest, IsAArch32TripleWithMProfile) {
+  ffi::Map<ffi::String, ffi::Any> target =
+      CanonicalizeTargetWithAttrs("cortex-m33", "armv7a-arm-none-eabi", {""});
+  ASSERT_EQ(IsArch(target), false);
+
+  target = CanonicalizeTargetWithAttrs("cortex-m33", "armv8a-arm-none-eabi", {""});
+  ASSERT_EQ(IsArch(target), false);
+
+  target = CanonicalizeTargetWithAttrs("cortex-m33", "arm-unknown-linux-gnu", {""});
+  ASSERT_EQ(IsArch(target), false);
+}
+
+TEST_F(AProfileCanonicalizerTest, AArch64HasASIMD) {
+  ffi::Map<ffi::String, ffi::Any> target =
+      CanonicalizeTargetWithAttrs("", "aarch64-arm-none-eabi", {""});
+  ASSERT_EQ(IsArch(target), true);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_asimd")), true);
+}
+
+TEST_F(AProfileCanonicalizerTest, AArch32ASIMD) {
+  ffi::Map<ffi::String, ffi::Any> target =
+      CanonicalizeTargetWithAttrs("", "armv8a-arm-none-eabi", {});
+  ASSERT_EQ(IsArch(target), true);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_asimd")), true);
+}
+
+TEST_F(AProfileCanonicalizerTest, AArch32HasASIMDWithOption) {
+  ffi::Map<ffi::String, ffi::Any> target =
+      CanonicalizeTargetWithAttrs("", "armv8a-arm-none-eabi", {"+simd"});
+  ASSERT_EQ(IsArch(target), true);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_asimd")), true);
+}
+
+TEST_F(AProfileCanonicalizerTest, AArch32HasASIMDWithAlternativeOption) {
+  ffi::Map<ffi::String, ffi::Any> target =
+      CanonicalizeTargetWithAttrs("", "armv8a-arm-none-eabi", {"+neon"});
+  ASSERT_EQ(IsArch(target), true);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_asimd")), true);
+}
+
+TEST_F(AProfileCanonicalizerTest, DefaultI8MMSupport) {
+  std::string arch_attr = "+v" + FloatToStringWithoutTrailingZeros(defaultI8MM) + "a";
+  ffi::Map<ffi::String, ffi::Any> target =
+      CanonicalizeTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr});
+  ASSERT_EQ(IsArch(target), true);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_matmul_i8")), true);
+}
+
+TEST_F(AProfileCanonicalizerTest, DefaultI8MMSupportDisable) {
+  std::string arch_attr = "+v" + FloatToStringWithoutTrailingZeros(defaultI8MM) + "a";
+  ffi::Map<ffi::String, ffi::Any> target =
+      CanonicalizeTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr, "-i8mm"});
+  ASSERT_EQ(IsArch(target), true);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_matmul_i8")), false);
+}
+
+using AProfileOptionalI8MM = AProfileCanonicalizerTestWithParam;
+TEST_P(AProfileOptionalI8MM, OptionalI8MMSupport) {
+  std::string arch_attr = "+v" + FloatToStringWithoutTrailingZeros(GetParam()) + "a";
+
+  ffi::Map<ffi::String, ffi::Any> target =
+      CanonicalizeTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr});
+  ASSERT_EQ(IsArch(target), true);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_matmul_i8")), false);
+
+  target = CanonicalizeTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr, "+i8mm"});
+  ASSERT_EQ(IsArch(target), true);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_matmul_i8")), true);
+}
+
+TEST_F(AProfileCanonicalizerTest, DefaultDotProdSupport) {
+  std::string arch_attr = "+v" + FloatToStringWithoutTrailingZeros(defaultDotProd) + "a";
+  ffi::Map<ffi::String, ffi::Any> target =
+      CanonicalizeTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr});
+  ASSERT_EQ(IsArch(target), true);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_dotprod")), true);
+}
+
+TEST_F(AProfileCanonicalizerTest, DefaultDotProdSupportDisable) {
+  std::string arch_attr = "+v" + FloatToStringWithoutTrailingZeros(defaultDotProd) + "a";
+  ffi::Map<ffi::String, ffi::Any> target =
+      CanonicalizeTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr, "-dotprod"});
+  ASSERT_EQ(IsArch(target), true);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_dotprod")), false);
+}
+
+using AProfileOptionalDotProd = AProfileCanonicalizerTestWithParam;
+TEST_P(AProfileOptionalDotProd, OptionalDotProdSupport) {
+  std::string arch_attr = "+v" + FloatToStringWithoutTrailingZeros(GetParam()) + "a";
+
+  ffi::Map<ffi::String, ffi::Any> target =
+      CanonicalizeTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr});
+  ASSERT_EQ(IsArch(target), true);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_dotprod")), false);
+
+  target = CanonicalizeTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr, "+dotprod"});
+  ASSERT_EQ(IsArch(target), true);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_dotprod")), true);
+}
+
+TEST_F(AProfileCanonicalizerTest, ArchVersionInvalidLetter) {
+  std::string arch_attr = "+v" + FloatToStringWithoutTrailingZeros(defaultDotProd) + "b";
+  ffi::Map<ffi::String, ffi::Any> target =
+      CanonicalizeTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr});
+  ASSERT_EQ(IsArch(target), true);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_dotprod")), false);
+}
+
+using AProfileOptionalSVE = AProfileCanonicalizerTestWithParam;
+TEST_P(AProfileOptionalSVE, OptionalSVESupport) {
+  const std::string arch_attr = "+v" + FloatToStringWithoutTrailingZeros(GetParam()) + "a";
+
+  ffi::Map<ffi::String, ffi::Any> target =
+      CanonicalizeTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr});
+  EXPECT_TRUE(IsArch(target));
+  EXPECT_FALSE(Downcast<Bool>(target.at("feature.has_sve")));
+
+  target = CanonicalizeTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr, "+sve"});
+  EXPECT_TRUE(IsArch(target));
+  EXPECT_TRUE(Downcast<Bool>(target.at("feature.has_sve")));
+}
+
+TEST_F(AProfileCanonicalizerTest, DefaultSVESupportSVESupport) {
+  const std::string arch_attr = "+v9a";
+
+  ffi::Map<ffi::String, ffi::Any> target =
+      CanonicalizeTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr});
+  EXPECT_TRUE(IsArch(target));
+#if TVM_LLVM_VERSION >= 190 || (TVM_LLVM_VERSION / 10) == 13
+  EXPECT_FALSE(Downcast<Bool>(target.at("feature.has_sve")));
+#else
+  EXPECT_TRUE(Downcast<Bool>(target.at("feature.has_sve")));
+#endif
+
+  target = CanonicalizeTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr, "+sve"});
+  EXPECT_TRUE(IsArch(target));
+  EXPECT_TRUE(Downcast<Bool>(target.at("feature.has_sve")));
+}
+
+using AProfileOptionalFP16 = AProfileCanonicalizerTestWithParam;
+TEST_P(AProfileOptionalFP16, OptionalFP16Support) {
+  const std::string arch_attr = "+v" + FloatToStringWithoutTrailingZeros(GetParam()) + "a";
+
+  ffi::Map<ffi::String, ffi::Any> target =
+      CanonicalizeTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr});
+  EXPECT_TRUE(IsArch(target));
+  EXPECT_FALSE(Downcast<Bool>(target.at("feature.has_fp16_simd")));
+
+  target = CanonicalizeTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr, "+fullfp16"});
+  EXPECT_TRUE(IsArch(target));
+  EXPECT_TRUE(Downcast<Bool>(target.at("feature.has_fp16_simd")));
+
+  target = CanonicalizeTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr, "+sve"});
+  EXPECT_TRUE(IsArch(target));
+  EXPECT_TRUE(Downcast<Bool>(target.at("feature.has_fp16_simd")));
+}
+
+TEST_F(AProfileCanonicalizerTest, DefaultFP16Support) {
+  const std::string arch_attr = "+v9a";
+
+  ffi::Map<ffi::String, ffi::Any> target =
+      CanonicalizeTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr});
+  EXPECT_TRUE(IsArch(target));
+#if TVM_LLVM_VERSION >= 190 || (TVM_LLVM_VERSION / 10) == 13
+  EXPECT_FALSE(Downcast<Bool>(target.at("feature.has_fp16_simd")));
+#else
+  EXPECT_TRUE(Downcast<Bool>(target.at("feature.has_fp16_simd")));
+#endif
+
+  target = CanonicalizeTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr, "+fullfp16"});
+  EXPECT_TRUE(IsArch(target));
+  EXPECT_TRUE(Downcast<Bool>(target.at("feature.has_fp16_simd")));
+
+  target = CanonicalizeTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr, "+sve"});
+  EXPECT_TRUE(IsArch(target));
+  EXPECT_TRUE(Downcast<Bool>(target.at("feature.has_fp16_simd")));
+}
+
+TEST_F(AProfileCanonicalizerTest, ImpliedFeature) {
+  ffi::Map<ffi::String, ffi::Any> target =
+      CanonicalizeTargetWithAttrs("", "aarch64-linux-gnu", {"+sve2"});
+  EXPECT_TRUE(Downcast<Bool>(target.at("feature.has_sve")));
+  EXPECT_TRUE(Downcast<Bool>(target.at("feature.has_asimd")));
+}
+
+TEST_F(AProfileCanonicalizerTest, UnexpectedTargetKind) {
+  EXPECT_THROW(
+      {
+        try {
+          Canonicalize({{"kind", ffi::String("c")}});
+        } catch (const tvm::InternalError& e) {
+          EXPECT_THAT(e.what(), HasSubstr("Expected target kind 'llvm', but got 'c'"));
+          throw;
+        }
+      },
+      tvm::InternalError);
+}
+
+TEST(AProfileCanonicalizerInvalid, LLVMUnsupportedArchitecture) {
+  if (has_aarch64_and_arm_targets) {
+    GTEST_SKIP() << "LLVM has been compiled for the correct targets.";
+  }
+  ffi::Map<ffi::String, ffi::Any> target = Canonicalize({{"kind", ffi::String("llvm")}});
+  // When LLVM doesn't support the architecture, no feature.* keys are set
+  for (const auto& kv : target) {
+    std::string key = kv.first;
+    ASSERT_FALSE(key.substr(0, 8) == "feature.") << "Unexpected feature key: " << key;
+  }
+}
+
+using AProfileOptionalSME = AProfileCanonicalizerTestWithParam;
+TEST_P(AProfileOptionalSME, OptionalSMESupport) {
+  const std::string arch_attr = "+v9a";
+
+  ffi::Map<ffi::String, ffi::Any> target =
+      CanonicalizeTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr});
+  ASSERT_TRUE(IsArch(target));
+  ASSERT_FALSE(Downcast<Bool>(target.at("feature.has_sme")));
+
+  target = CanonicalizeTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr, "+sme"});
+  ASSERT_TRUE(IsArch(target));
+  ASSERT_TRUE(Downcast<Bool>(target.at("feature.has_sme")));
+}
+
+INSTANTIATE_TEST_SUITE_P(AProfileCanonicalizer, AProfileOptionalI8MM,
+                         ::testing::ValuesIn(optionalI8MM));
+INSTANTIATE_TEST_SUITE_P(AProfileCanonicalizer, AProfileOptionalDotProd,
+                         ::testing::ValuesIn(optionalDotProd));
+INSTANTIATE_TEST_SUITE_P(AProfileCanonicalizer, AProfileOptionalSVE,
+                         ::testing::Values(8.0, 8.1, 8.2, 8.3, 8.4, 8.5, 8.6, 8.7, 8.8, 8.9));
+INSTANTIATE_TEST_SUITE_P(AProfileCanonicalizer, AProfileOptionalFP16,
+                         ::testing::Values(8.2, 8.3, 8.4, 8.5, 8.6, 8.7, 8.8, 8.9));
+INSTANTIATE_TEST_SUITE_P(AProfileCanonicalizer, AProfileOptionalSME,
+                         ::testing::ValuesIn(optionalSME));
+
+}  // namespace aprofile
+}  // namespace llvm
+}  // namespace canonicalizer
+}  // namespace target
+}  // namespace tvm
diff --git a/tests/cpp/target/canonicalizer/arm_mprofile_test.cc b/tests/cpp/target/canonicalizer/arm_mprofile_test.cc
new file mode 100644
index 000000000000..f39ef8b2538e
--- /dev/null
+++ b/tests/cpp/target/canonicalizer/arm_mprofile_test.cc
@@ -0,0 +1,206 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+#include "../src/target/canonicalizer/llvm/arm_mprofile.h"
+
+#include <gtest/gtest.h>
+
+#include <cmath>
+#include <string>
+
+namespace tvm {
+namespace target {
+namespace canonicalizer {
+namespace llvm {
+namespace mprofile {
+
+static const char* mveCPUs[] = {"cortex-m55"};
+static const char* dspCPUs[] = {"cortex-m4", "cortex-m7", "cortex-m33", "cortex-m35p"};
+static const char* noExtensions[] = {"cortex-m0", "cortex-m3"};
+
+class MProfileCanonicalizerMVECPUs : public testing::TestWithParam<const char*> {};
+class MProfileCanonicalizerDSPCPUs : public testing::TestWithParam<const char*> {};
+class MProfileCanonicalizerNoExtensions : public testing::TestWithParam<const char*> {};
+
+static ffi::Map<ffi::String, ffi::Any> CanonicalizeTargetWithAttrs(ffi::String mcpu,
+                                                                   ffi::Array<ffi::String> mattr) {
+  return Canonicalize({{"mcpu", mcpu}, {"mattr", mattr}});
+}
+
+TEST(MProfileCanonicalizer, CheckIsNotArch) {
+  ffi::String mcpu = "cake";
+  ffi::Map<ffi::String, ffi::Any> fake_target = {{"mcpu", mcpu}};
+  ASSERT_EQ(IsArch(fake_target), false);
+}
+
+TEST_P(MProfileCanonicalizerMVECPUs, CheckIsArch) {
+  ffi::String mcpu = GetParam();
+  ffi::Map<ffi::String, ffi::Any> fake_target = {{"mcpu", mcpu}};
+  ASSERT_EQ(IsArch(fake_target), true);
+}
+
+TEST_P(MProfileCanonicalizerDSPCPUs, CheckIsArch) {
+  ffi::String mcpu = GetParam();
+  ffi::Map<ffi::String, ffi::Any> fake_target = {{"mcpu", mcpu}};
+  ASSERT_EQ(IsArch(fake_target), true);
+}
+
+TEST_P(MProfileCanonicalizerNoExtensions, CheckIsArch) {
+  ffi::String mcpu = GetParam();
+  ffi::Map<ffi::String, ffi::Any> fake_target = {{"mcpu", mcpu}};
+  ASSERT_EQ(IsArch(fake_target), true);
+}
+
+TEST(MProfileCanonicalizer, CanonicalizeTarget) {
+  ffi::Map<ffi::String, ffi::Any> target = Canonicalize({});
+  ffi::Array<ffi::String> keys = Downcast<ffi::Array<ffi::String>>(target.at("keys"));
+  ASSERT_EQ(keys.size(), 2);
+  ASSERT_EQ(keys[0], "arm_cpu");
+  ASSERT_EQ(keys[1], "cpu");
+
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_mve")), false);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_dsp")), false);
+}
+
+TEST(MProfileCanonicalizer, CanonicalizeTargetWithExistingKeys) {
+  ffi::Map<ffi::String, ffi::Any> target = Canonicalize({
+      {"keys", ffi::Array<ffi::String>{"cpu"}},
+  });
+  ffi::Array<ffi::String> keys = Downcast<ffi::Array<ffi::String>>(target.at("keys"));
+  ASSERT_EQ(keys.size(), 2);
+  ASSERT_EQ(keys[0], "cpu");
+  ASSERT_EQ(keys[1], "arm_cpu");
+}
+
+TEST(MProfileCanonicalizer, CanonicalizeTargetWithDuplicateKey) {
+  ffi::Map<ffi::String, ffi::Any> target = Canonicalize({
+      {"keys", ffi::Array<ffi::String>{"cpu", "arm_cpu"}},
+  });
+  ffi::Array<ffi::String> keys = Downcast<ffi::Array<ffi::String>>(target.at("keys"));
+  ASSERT_EQ(keys.size(), 2);
+  ASSERT_EQ(keys[0], "cpu");
+  ASSERT_EQ(keys[1], "arm_cpu");
+}
+
+TEST_P(MProfileCanonicalizerMVECPUs, CheckMVESet) {
+  ffi::Map<ffi::String, ffi::Any> target = CanonicalizeTargetWithAttrs(GetParam(), {""});
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_mve")), true);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_dsp")), true);
+}
+
+TEST_P(MProfileCanonicalizerMVECPUs, CheckMVEOverrideCPU) {
+  std::string mcpu = GetParam();
+  ffi::Map<ffi::String, ffi::Any> target = CanonicalizeTargetWithAttrs(mcpu + "+nomve", {""});
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_mve")), false);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_dsp")), true);
+}
+
+TEST_P(MProfileCanonicalizerMVECPUs, CheckDSPOverrideCPU) {
+  std::string mcpu = GetParam();
+  ffi::Map<ffi::String, ffi::Any> target = CanonicalizeTargetWithAttrs(mcpu + "+nodsp", {""});
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_mve")), false);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_dsp")), false);
+}
+
+TEST_P(MProfileCanonicalizerMVECPUs, CheckCombinedOverrideCPU) {
+  std::string mcpu = GetParam();
+  ffi::Map<ffi::String, ffi::Any> target = CanonicalizeTargetWithAttrs(mcpu + "+nodsp+nomve", {""});
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_mve")), false);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_dsp")), false);
+  target = CanonicalizeTargetWithAttrs(mcpu + "+nomve+nodsp", {""});
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_mve")), false);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_dsp")), false);
+}
+
+TEST_P(MProfileCanonicalizerMVECPUs, CheckMVEOverrideMAttr) {
+  ffi::Map<ffi::String, ffi::Any> target = CanonicalizeTargetWithAttrs(GetParam(), {"+nomve"});
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_mve")), false);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_dsp")), true);
+}
+
+TEST_P(MProfileCanonicalizerMVECPUs, CheckDSPOverrideMattr) {
+  ffi::Map<ffi::String, ffi::Any> target = CanonicalizeTargetWithAttrs(GetParam(), {"+nodsp"});
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_mve")), false);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_dsp")), false);
+}
+
+TEST_P(MProfileCanonicalizerMVECPUs, CheckCombinedOverrideMattr) {
+  ffi::Map<ffi::String, ffi::Any> target =
+      CanonicalizeTargetWithAttrs(GetParam(), {"+nodsp", "+nomve"});
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_mve")), false);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_dsp")), false);
+
+  target = CanonicalizeTargetWithAttrs(GetParam(), {"+nomve+nodsp"});
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_mve")), false);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_dsp")), false);
+
+  target = CanonicalizeTargetWithAttrs(GetParam(), {"+nomve", "+nodsp"});
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_mve")), false);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_dsp")), false);
+
+  target = CanonicalizeTargetWithAttrs(GetParam(), {"+woofles", "+nomve", "+nodsp"});
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_mve")), false);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_dsp")), false);
+}
+
+TEST_P(MProfileCanonicalizerDSPCPUs, CheckDSPSet) {
+  ffi::Map<ffi::String, ffi::Any> target = CanonicalizeTargetWithAttrs(GetParam(), {""});
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_mve")), false);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_dsp")), true);
+}
+
+TEST_P(MProfileCanonicalizerDSPCPUs, CheckDSPOverrideCPU) {
+  std::string mcpu = GetParam();
+  ffi::Map<ffi::String, ffi::Any> target = CanonicalizeTargetWithAttrs(mcpu + "+nodsp", {""});
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_mve")), false);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_dsp")), false);
+
+  target = CanonicalizeTargetWithAttrs(mcpu + "+nodsp+woofles", {""});
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_mve")), false);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_dsp")), false);
+}
+
+TEST_P(MProfileCanonicalizerDSPCPUs, CheckDSPOverrideMattr) {
+  ffi::Map<ffi::String, ffi::Any> target = CanonicalizeTargetWithAttrs(GetParam(), {"+nodsp"});
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_mve")), false);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_dsp")), false);
+
+  target = CanonicalizeTargetWithAttrs(GetParam(), {"+nodsp", "+woofles"});
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_mve")), false);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_dsp")), false);
+}
+
+TEST_P(MProfileCanonicalizerNoExtensions, CheckNoFlags) {
+  ffi::Map<ffi::String, ffi::Any> target = CanonicalizeTargetWithAttrs(GetParam(), {""});
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_mve")), false);
+  ASSERT_EQ(Downcast<Bool>(target.at("feature.has_dsp")), false);
+}
+
+INSTANTIATE_TEST_CASE_P(MProfileCanonicalizer, MProfileCanonicalizerMVECPUs,
+                        ::testing::ValuesIn(mveCPUs));
+INSTANTIATE_TEST_CASE_P(MProfileCanonicalizer, MProfileCanonicalizerDSPCPUs,
+                        ::testing::ValuesIn(dspCPUs));
+INSTANTIATE_TEST_CASE_P(MProfileCanonicalizer, MProfileCanonicalizerNoExtensions,
+                        ::testing::ValuesIn(noExtensions));
+
+}  // namespace mprofile
+}  // namespace llvm
+}  // namespace canonicalizer
+}  // namespace target
+}  // namespace tvm
diff --git a/tests/cpp/target/parsers/aprofile_test.cc b/tests/cpp/target/parsers/aprofile_test.cc
deleted file mode 100644
index 1e74b3f71599..000000000000
--- a/tests/cpp/target/parsers/aprofile_test.cc
+++ /dev/null
@@ -1,447 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#include "../src/target/parsers/aprofile.h"
-
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-#include <cmath>
-#include <string>
-
-#include "../src/target/llvm/llvm_instance.h"
-
-namespace tvm {
-namespace target {
-namespace parsers {
-namespace aprofile {
-
-using ::testing::HasSubstr;
-
-static float defaultI8MM = 8.6;
-static float optionalI8MM[] = {8.2, 8.3, 8.4, 8.5};
-static float defaultDotProd = 8.4;
-static float optionalDotProd[] = {8.2, 8.3};
-static float optionalSME[] = {9.2, 9.3};
-
-static bool CheckArchitectureAvailability() {
-#if TVM_LLVM_VERSION > 120
-  auto llvm_instance = std::make_unique<codegen::LLVMInstance>();
-  codegen::LLVMTargetInfo llvm_backend(*llvm_instance, "llvm");
-  ffi::Array<ffi::String> targets = llvm_backend.GetAllLLVMTargets();
-  int expected_target_count = 0;
-  for (ffi::String target : targets) {
-    if (target == "aarch64" || target == "arm") {
-      expected_target_count += 1;
-    }
-  }
-  if (expected_target_count >= 2) {
-    return true;
-  }
-#endif
-  return false;
-}
-static bool has_aarch64_and_arm_targets = CheckArchitectureAvailability();
-
-class AProfileParser : public ::testing::Test {
- public:
-  // Check that LLVM has been compiled with the required targets, otherwise skip the test.
-  // Unfortunately, googletest doesn't let you call GTEST_SKIP in SetUpTestSuite() to skip
-  // the whole suite of tests, so a cached result is checked before each test is run instead.
-  void SetUp() override {
-    if (!has_aarch64_and_arm_targets) {
-      GTEST_SKIP() << "Skipping as LLVM has not been built for Arm(R)-based targets.";
-    }
-  }
-};
-
-class AProfileParserTestWithParam : public AProfileParser,
-                                    public testing::WithParamInterface<float> {};
-
-static TargetFeatures ParseTargetWithAttrs(ffi::String mcpu, ffi::String mtriple,
-                                           ffi::Array<ffi::String> mattr) {
-  TargetJSON target_json = {
-      {"kind", ffi::String("llvm")},
-      {"mtriple", mtriple},
-      {"mattr", mattr},
-  };
-  if (mcpu != "") {
-    target_json.Set("mcpu", mcpu);
-  }
-  return ParseTarget(target_json);
-}
-
-std::string FloatToStringWithoutTrailingZeros(float value) {
-  std::stringstream ss;
-  ss << value;
-  return ss.str();
-}
-
-TEST_F(AProfileParser, ParseTargetKeys) {
-  TargetJSON target = ParseTarget({{"kind", ffi::String("llvm")}});
-  ffi::Array<ffi::String> keys = Downcast<ffi::Array<ffi::String>>(target.at("keys"));
-  ASSERT_EQ(keys.size(), 2);
-  ASSERT_EQ(keys[0], "arm_cpu");
-  ASSERT_EQ(keys[1], "cpu");
-}
-
-TEST_F(AProfileParser, ParseTargetWithExistingKeys) {
-  TargetJSON target = ParseTarget({
-      {"kind", ffi::String("llvm")},
-      {"keys", ffi::Array<ffi::String>{"cpu"}},
-  });
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ffi::Array<ffi::String> keys = Downcast<ffi::Array<ffi::String>>(target.at("keys"));
-  ASSERT_EQ(keys.size(), 2);
-  ASSERT_EQ(keys[0], "cpu");
-  ASSERT_EQ(keys[1], "arm_cpu");
-}
-
-TEST_F(AProfileParser, ParseTargetWithDuplicateKey) {
-  TargetJSON target = ParseTarget({
-      {"kind", ffi::String("llvm")},
-      {"keys", ffi::Array<ffi::String>{"cpu", "arm_cpu"}},
-  });
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ffi::Array<ffi::String> keys = Downcast<ffi::Array<ffi::String>>(target.at("keys"));
-  ASSERT_EQ(keys.size(), 2);
-  ASSERT_EQ(keys[0], "cpu");
-  ASSERT_EQ(keys[1], "arm_cpu");
-}
-
-TEST_F(AProfileParser, ParseTargetDefaults) {
-  TargetJSON target = ParseTarget({{"kind", ffi::String("llvm")}});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-
-  ASSERT_EQ(Downcast<Bool>(features.at("is_aarch64")), false);
-}
-
-TEST_F(AProfileParser, IsAArch64Triple) {
-  TargetJSON target = ParseTargetWithAttrs("", "aarch64-arm-none-eabi", {""});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(IsArch(target), true);
-  ASSERT_EQ(Downcast<Bool>(features.at("is_aarch64")), true);
-}
-
-TEST_F(AProfileParser, IsAArch32Triple) {
-  TargetJSON target = ParseTargetWithAttrs("", "armv7a-arm-none-eabi", {""});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(IsArch(target), true);
-  ASSERT_EQ(Downcast<Bool>(features.at("is_aarch64")), false);
-
-  target = ParseTargetWithAttrs("", "armv8a-arm-none-eabi", {""});
-  features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(IsArch(target), true);
-  ASSERT_EQ(Downcast<Bool>(features.at("is_aarch64")), false);
-
-  target = ParseTargetWithAttrs("", "arm-unknown-linux-gnu", {""});
-  features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(IsArch(target), true);
-  ASSERT_EQ(Downcast<Bool>(features.at("is_aarch64")), false);
-}
-
-TEST_F(AProfileParser, IsAArch32BlankCPU) {
-  TargetJSON target = ParseTarget({
-      {"kind", ffi::String("llvm")},
-      {"mtriple", ffi::String("arm-unknown-linux-gnu")},
-  });
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(IsArch(target), true);
-}
-
-TEST_F(AProfileParser, IsAArch32TripleWithAProfile) {
-  TargetJSON target = ParseTargetWithAttrs("cortex-a53", "armv7a-arm-none-eabi", {""});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(IsArch(target), true);
-  ASSERT_EQ(Downcast<Bool>(features.at("is_aarch64")), false);
-
-  target = ParseTargetWithAttrs("cortex-a53", "armv8a-arm-none-eabi", {""});
-  features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(IsArch(target), true);
-  ASSERT_EQ(Downcast<Bool>(features.at("is_aarch64")), false);
-
-  target = ParseTargetWithAttrs("cortex-a53", "arm-unknown-linux-gnu", {""});
-  features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(IsArch(target), true);
-  ASSERT_EQ(Downcast<Bool>(features.at("is_aarch64")), false);
-}
-
-TEST_F(AProfileParser, IsAArch32TripleWithMProfile) {
-  TargetJSON target = ParseTargetWithAttrs("cortex-m33", "armv7a-arm-none-eabi", {""});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(IsArch(target), false);
-
-  target = ParseTargetWithAttrs("cortex-m33", "armv8a-arm-none-eabi", {""});
-  features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(IsArch(target), false);
-
-  target = ParseTargetWithAttrs("cortex-m33", "arm-unknown-linux-gnu", {""});
-  features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(IsArch(target), false);
-}
-
-TEST_F(AProfileParser, AArch64HasASIMD) {
-  TargetJSON target = ParseTargetWithAttrs("", "aarch64-arm-none-eabi", {""});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(IsArch(target), true);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_asimd")), true);
-}
-
-TEST_F(AProfileParser, AArch32ASIMD) {
-  TargetJSON target = ParseTargetWithAttrs("", "armv8a-arm-none-eabi", {});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(IsArch(target), true);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_asimd")), true);
-}
-
-TEST_F(AProfileParser, AArch32HasASIMDWithOption) {
-  TargetJSON target = ParseTargetWithAttrs("", "armv8a-arm-none-eabi", {"+simd"});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(IsArch(target), true);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_asimd")), true);
-}
-
-TEST_F(AProfileParser, AArch32HasASIMDWithAlternativeOption) {
-  TargetJSON target = ParseTargetWithAttrs("", "armv8a-arm-none-eabi", {"+neon"});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(IsArch(target), true);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_asimd")), true);
-}
-
-TEST_F(AProfileParser, DefaultI8MMSupport) {
-  std::string arch_attr = "+v" + FloatToStringWithoutTrailingZeros(defaultI8MM) + "a";
-  TargetJSON target = ParseTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(IsArch(target), true);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_matmul_i8")), true);
-}
-
-TEST_F(AProfileParser, DefaultI8MMSupportDisable) {
-  std::string arch_attr = "+v" + FloatToStringWithoutTrailingZeros(defaultI8MM) + "a";
-  TargetJSON target = ParseTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr, "-i8mm"});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(IsArch(target), true);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_matmul_i8")), false);
-}
-
-using AProfileOptionalI8MM = AProfileParserTestWithParam;
-TEST_P(AProfileOptionalI8MM, OptionalI8MMSupport) {
-  std::string arch_attr = "+v" + FloatToStringWithoutTrailingZeros(GetParam()) + "a";
-
-  TargetJSON target = ParseTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(IsArch(target), true);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_matmul_i8")), false);
-
-  target = ParseTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr, "+i8mm"});
-  features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(IsArch(target), true);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_matmul_i8")), true);
-}
-
-TEST_F(AProfileParser, DefaultDotProdSupport) {
-  std::string arch_attr = "+v" + FloatToStringWithoutTrailingZeros(defaultDotProd) + "a";
-  TargetJSON target = ParseTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(IsArch(target), true);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_dotprod")), true);
-}
-
-TEST_F(AProfileParser, DefaultDotProdSupportDisable) {
-  std::string arch_attr = "+v" + FloatToStringWithoutTrailingZeros(defaultDotProd) + "a";
-  TargetJSON target = ParseTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr, "-dotprod"});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(IsArch(target), true);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_dotprod")), false);
-}
-
-using AProfileOptionalDotProd = AProfileParserTestWithParam;
-TEST_P(AProfileOptionalDotProd, OptionalDotProdSupport) {
-  std::string arch_attr = "+v" + FloatToStringWithoutTrailingZeros(GetParam()) + "a";
-
-  TargetJSON target = ParseTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(IsArch(target), true);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_dotprod")), false);
-
-  target = ParseTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr, "+dotprod"});
-  features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(IsArch(target), true);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_dotprod")), true);
-}
-
-TEST_F(AProfileParser, ArchVersionInvalidLetter) {
-  std::string arch_attr = "+v" + FloatToStringWithoutTrailingZeros(defaultDotProd) + "b";
-  TargetJSON target = ParseTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(IsArch(target), true);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_dotprod")), false);
-}
-
-using AProfileOptionalSVE = AProfileParserTestWithParam;
-TEST_P(AProfileOptionalSVE, OptionalSVESupport) {
-  const std::string arch_attr = "+v" + FloatToStringWithoutTrailingZeros(GetParam()) + "a";
-
-  // Check that the "has_sve" feature is not set by default when "+sve" isn't set as an attribute.
-  TargetJSON target = ParseTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  EXPECT_TRUE(IsArch(target));
-  EXPECT_FALSE(Downcast<Bool>(features.at("has_sve")));
-
-  // Check that the "has_sve" feature is set when "+sve" is explicitly set as an attribute.
-  target = ParseTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr, "+sve"});
-  features = Downcast<TargetFeatures>(target.at("features"));
-  EXPECT_TRUE(IsArch(target));
-  EXPECT_TRUE(Downcast<Bool>(features.at("has_sve")));
-}
-
-TEST_F(AProfileParser, DefaultSVESupportSVESupport) {
-  const std::string arch_attr = "+v9a";
-
-  // Check that the "has_sve" feature is not set by default when "+sve" isn't set as an attribute.
-  TargetJSON target = ParseTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  EXPECT_TRUE(IsArch(target));
-#if TVM_LLVM_VERSION >= 190 || (TVM_LLVM_VERSION / 10) == 13
-  // The generic aarch64 should not have SVE enabled
-  EXPECT_FALSE(Downcast<Bool>(features.at("has_sve")));
-#else
-  EXPECT_TRUE(Downcast<Bool>(features.at("has_sve")));
-#endif
-
-  // Check that the "has_sve" feature is set when "+sve" is explicitly set as an attribute.
-  target = ParseTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr, "+sve"});
-  features = Downcast<TargetFeatures>(target.at("features"));
-  EXPECT_TRUE(IsArch(target));
-  EXPECT_TRUE(Downcast<Bool>(features.at("has_sve")));
-}
-
-using AProfileOptionalFP16 = AProfileParserTestWithParam;
-TEST_P(AProfileOptionalFP16, OptionalFP16Support) {
-  const std::string arch_attr = "+v" + FloatToStringWithoutTrailingZeros(GetParam()) + "a";
-
-  // Check that the "has_fp16_simd" feature is not set by default when "+fullfp16" isn't set as an
-  // attribute.
-  TargetJSON target = ParseTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  EXPECT_TRUE(IsArch(target));
-  EXPECT_FALSE(Downcast<Bool>(features.at("has_fp16_simd")));
-
-  // Check that the "has_fp16_simd" feature is set when "+fullfp16" is explicitly set as an
-  // attribute.
-  target = ParseTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr, "+fullfp16"});
-  features = Downcast<TargetFeatures>(target.at("features"));
-  EXPECT_TRUE(IsArch(target));
-  EXPECT_TRUE(Downcast<Bool>(features.at("has_fp16_simd")));
-
-  // Check that the "has_fp16_simd" feature is set when "+sve" is explicitly set as an attribute.
-  target = ParseTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr, "+sve"});
-  features = Downcast<TargetFeatures>(target.at("features"));
-  EXPECT_TRUE(IsArch(target));
-  EXPECT_TRUE(Downcast<Bool>(features.at("has_fp16_simd")));
-}
-
-TEST_F(AProfileParser, DefaultFP16Support) {
-  const std::string arch_attr = "+v9a";
-
-  // Check that the "has_fp16_simd" feature is not set by default when "+fullfp16" isn't set as an
-  // attribute.
-  TargetJSON target = ParseTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  EXPECT_TRUE(IsArch(target));
-#if TVM_LLVM_VERSION >= 190 || (TVM_LLVM_VERSION / 10) == 13
-  // The generic aarch64 should not have FP16 enabled
-  EXPECT_FALSE(Downcast<Bool>(features.at("has_fp16_simd")));
-#else
-  EXPECT_TRUE(Downcast<Bool>(features.at("has_fp16_simd")));
-#endif
-
-  // Check that the "has_fp16_simd" feature is set when "+fullfp16" is explicitly set as an
-  // attribute.
-  target = ParseTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr, "+fullfp16"});
-  features = Downcast<TargetFeatures>(target.at("features"));
-  EXPECT_TRUE(IsArch(target));
-  EXPECT_TRUE(Downcast<Bool>(features.at("has_fp16_simd")));
-
-  // Check that the "has_fp16_simd" feature is set when "+sve" is explicitly set as an attribute.
-  target = ParseTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr, "+sve"});
-  features = Downcast<TargetFeatures>(target.at("features"));
-  EXPECT_TRUE(IsArch(target));
-  EXPECT_TRUE(Downcast<Bool>(features.at("has_fp16_simd")));
-}
-
-TEST_F(AProfileParser, ImpliedFeature) {
-  TargetJSON target = ParseTargetWithAttrs("", "aarch64-linux-gnu", {"+sve2"});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  EXPECT_TRUE(Downcast<Bool>(features.at("has_sve")));
-  EXPECT_TRUE(Downcast<Bool>(features.at("has_asimd")));
-}
-
-TEST_F(AProfileParser, UnexpectedTargetKind) {
-  EXPECT_THROW(
-      {
-        try {
-          ParseTarget({{"kind", ffi::String("c")}});
-        } catch (const tvm::InternalError& e) {
-          EXPECT_THAT(e.what(), HasSubstr("Expected target kind 'llvm', but got 'c'"));
-          throw;
-        }
-      },
-      tvm::InternalError);
-}
-
-TEST(AProfileParserInvalid, LLVMUnsupportedArchitecture) {
-  if (has_aarch64_and_arm_targets) {
-    GTEST_SKIP() << "LLVM has been compiled for the correct targets.";
-  }
-  TargetJSON target = ParseTarget({{"kind", ffi::String("llvm")}});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  for (auto feature : features) {
-    ASSERT_EQ(Downcast<Bool>(feature.second), false);
-  }
-}
-
-using AProfileOptionalSME = AProfileParserTestWithParam;
-TEST_P(AProfileOptionalSME, OptionalSMESupport) {
-  const std::string arch_attr = "+v9a";
-
-  TargetJSON target = ParseTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_TRUE(IsArch(target));
-  ASSERT_FALSE(Downcast<Bool>(features.at("has_sme")));
-
-  target = ParseTargetWithAttrs("", "aarch64-arm-none-eabi", {arch_attr, "+sme"});
-  features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_TRUE(IsArch(target));
-  ASSERT_TRUE(Downcast<Bool>(features.at("has_sme")));
-}
-
-INSTANTIATE_TEST_SUITE_P(AProfileParser, AProfileOptionalI8MM, ::testing::ValuesIn(optionalI8MM));
-INSTANTIATE_TEST_SUITE_P(AProfileParser, AProfileOptionalDotProd,
-                         ::testing::ValuesIn(optionalDotProd));
-INSTANTIATE_TEST_SUITE_P(AProfileParser, AProfileOptionalSVE,
-                         ::testing::Values(8.0, 8.1, 8.2, 8.3, 8.4, 8.5, 8.6, 8.7, 8.8, 8.9));
-INSTANTIATE_TEST_SUITE_P(AProfileParser, AProfileOptionalFP16,
-                         ::testing::Values(8.2, 8.3, 8.4, 8.5, 8.6, 8.7, 8.8, 8.9));
-INSTANTIATE_TEST_SUITE_P(AProfileParser, AProfileOptionalSME, ::testing::ValuesIn(optionalSME));
-
-}  // namespace aprofile
-}  // namespace parsers
-}  // namespace target
-}  // namespace tvm
diff --git a/tests/cpp/target/parsers/mprofile_test.cc b/tests/cpp/target/parsers/mprofile_test.cc
deleted file mode 100644
index 19baf006d895..000000000000
--- a/tests/cpp/target/parsers/mprofile_test.cc
+++ /dev/null
@@ -1,219 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements.  See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership.  The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License.  You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied.  See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#include "../src/target/parsers/mprofile.h"
-
-#include <gtest/gtest.h>
-
-#include <cmath>
-#include <string>
-
-namespace tvm {
-namespace target {
-namespace parsers {
-namespace mprofile {
-
-static const char* mveCPUs[] = {"cortex-m55"};
-static const char* dspCPUs[] = {"cortex-m4", "cortex-m7", "cortex-m33", "cortex-m35p"};
-static const char* noExtensions[] = {"cortex-m0", "cortex-m3"};
-
-class MProfileParserMVECPUs : public testing::TestWithParam<const char*> {};
-class MProfileParserDSPCPUs : public testing::TestWithParam<const char*> {};
-class MProfileParserNoExtensions : public testing::TestWithParam<const char*> {};
-
-static TargetFeatures ParseTargetWithAttrs(ffi::String mcpu, ffi::Array<ffi::String> mattr) {
-  return ParseTarget({{"mcpu", mcpu}, {"mattr", mattr}});
-}
-
-TEST(MProfileParser, CheckIsNotArch) {
-  ffi::String mcpu = "cake";
-  TargetJSON fake_target = {{"mcpu", mcpu}};
-  ASSERT_EQ(IsArch(fake_target), false);
-}
-
-TEST_P(MProfileParserMVECPUs, CheckIsArch) {
-  ffi::String mcpu = GetParam();
-  TargetJSON fake_target = {{"mcpu", mcpu}};
-  ASSERT_EQ(IsArch(fake_target), true);
-}
-
-TEST_P(MProfileParserDSPCPUs, CheckIsArch) {
-  ffi::String mcpu = GetParam();
-  TargetJSON fake_target = {{"mcpu", mcpu}};
-  ASSERT_EQ(IsArch(fake_target), true);
-}
-
-TEST_P(MProfileParserNoExtensions, CheckIsArch) {
-  ffi::String mcpu = GetParam();
-  TargetJSON fake_target = {{"mcpu", mcpu}};
-  ASSERT_EQ(IsArch(fake_target), true);
-}
-
-TEST(MProfileParser, ParseTarget) {
-  TargetJSON target = ParseTarget({});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ffi::Array<ffi::String> keys = Downcast<ffi::Array<ffi::String>>(target.at("keys"));
-  ASSERT_EQ(keys.size(), 2);
-  ASSERT_EQ(keys[0], "arm_cpu");
-  ASSERT_EQ(keys[1], "cpu");
-
-  ASSERT_EQ(Downcast<Bool>(features.at("has_mve")), false);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_dsp")), false);
-}
-
-TEST(MProfileParser, ParseTargetWithExistingKeys) {
-  TargetJSON target = ParseTarget({
-      {"keys", ffi::Array<ffi::String>{"cpu"}},
-  });
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ffi::Array<ffi::String> keys = Downcast<ffi::Array<ffi::String>>(target.at("keys"));
-  ASSERT_EQ(keys.size(), 2);
-  ASSERT_EQ(keys[0], "cpu");
-  ASSERT_EQ(keys[1], "arm_cpu");
-}
-
-TEST(MProfileParser, ParseTargetWithDuplicateKey) {
-  TargetJSON target = ParseTarget({
-      {"keys", ffi::Array<ffi::String>{"cpu", "arm_cpu"}},
-  });
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ffi::Array<ffi::String> keys = Downcast<ffi::Array<ffi::String>>(target.at("keys"));
-  ASSERT_EQ(keys.size(), 2);
-  ASSERT_EQ(keys[0], "cpu");
-  ASSERT_EQ(keys[1], "arm_cpu");
-}
-
-TEST_P(MProfileParserMVECPUs, CheckMVESet) {
-  TargetJSON target = ParseTargetWithAttrs(GetParam(), {""});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(Downcast<Bool>(features.at("has_mve")), true);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_dsp")), true);
-}
-
-TEST_P(MProfileParserMVECPUs, CheckMVEOverrideCPU) {
-  std::string mcpu = GetParam();
-  TargetJSON target = ParseTargetWithAttrs(mcpu + "+nomve", {""});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(Downcast<Bool>(features.at("has_mve")), false);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_dsp")), true);
-}
-
-TEST_P(MProfileParserMVECPUs, CheckDSPOverrideCPU) {
-  std::string mcpu = GetParam();
-  TargetJSON target = ParseTargetWithAttrs(mcpu + "+nodsp", {""});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(Downcast<Bool>(features.at("has_mve")), false);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_dsp")), false);
-}
-
-TEST_P(MProfileParserMVECPUs, CheckCombinedOverrideCPU) {
-  std::string mcpu = GetParam();
-  TargetJSON target = ParseTargetWithAttrs(mcpu + "+nodsp+nomve", {""});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(Downcast<Bool>(features.at("has_mve")), false);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_dsp")), false);
-  target = ParseTargetWithAttrs(mcpu + "+nomve+nodsp", {""});
-  ASSERT_EQ(Downcast<Bool>(features.at("has_mve")), false);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_dsp")), false);
-}
-
-TEST_P(MProfileParserMVECPUs, CheckMVEOverrideMAttr) {
-  TargetJSON target = ParseTargetWithAttrs(GetParam(), {"+nomve"});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(Downcast<Bool>(features.at("has_mve")), false);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_dsp")), true);
-}
-
-TEST_P(MProfileParserMVECPUs, CheckDSPOverrideMattr) {
-  TargetJSON target = ParseTargetWithAttrs(GetParam(), {"+nodsp"});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(Downcast<Bool>(features.at("has_mve")), false);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_dsp")), false);
-}
-
-TEST_P(MProfileParserMVECPUs, CheckCombinedOverrideMattr) {
-  TargetJSON target = ParseTargetWithAttrs(GetParam(), {"+nodsp", "+nomve"});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(Downcast<Bool>(features.at("has_mve")), false);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_dsp")), false);
-
-  target = ParseTargetWithAttrs(GetParam(), {"+nomve+nodsp"});
-  features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(Downcast<Bool>(features.at("has_mve")), false);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_dsp")), false);
-
-  target = ParseTargetWithAttrs(GetParam(), {"+nomve", "+nodsp"});
-  features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(Downcast<Bool>(features.at("has_mve")), false);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_dsp")), false);
-
-  target = ParseTargetWithAttrs(GetParam(), {"+woofles", "+nomve", "+nodsp"});
-  features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(Downcast<Bool>(features.at("has_mve")), false);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_dsp")), false);
-}
-
-TEST_P(MProfileParserDSPCPUs, CheckDSPSet) {
-  TargetJSON target = ParseTargetWithAttrs(GetParam(), {""});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(Downcast<Bool>(features.at("has_mve")), false);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_dsp")), true);
-}
-
-TEST_P(MProfileParserDSPCPUs, CheckDSPOverrideCPU) {
-  std::string mcpu = GetParam();
-  TargetJSON target = ParseTargetWithAttrs(mcpu + "+nodsp", {""});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(Downcast<Bool>(features.at("has_mve")), false);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_dsp")), false);
-
-  target = ParseTargetWithAttrs(mcpu + "+nodsp+woofles", {""});
-  features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(Downcast<Bool>(features.at("has_mve")), false);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_dsp")), false);
-}
-
-TEST_P(MProfileParserDSPCPUs, CheckDSPOverrideMattr) {
-  TargetJSON target = ParseTargetWithAttrs(GetParam(), {"+nodsp"});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(Downcast<Bool>(features.at("has_mve")), false);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_dsp")), false);
-
-  target = ParseTargetWithAttrs(GetParam(), {"+nodsp", "+woofles"});
-  features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(Downcast<Bool>(features.at("has_mve")), false);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_dsp")), false);
-}
-
-TEST_P(MProfileParserNoExtensions, CheckNoFlags) {
-  TargetJSON target = ParseTargetWithAttrs(GetParam(), {""});
-  TargetFeatures features = Downcast<TargetFeatures>(target.at("features"));
-  ASSERT_EQ(Downcast<Bool>(features.at("has_mve")), false);
-  ASSERT_EQ(Downcast<Bool>(features.at("has_dsp")), false);
-}
-
-INSTANTIATE_TEST_CASE_P(MProfileParser, MProfileParserMVECPUs, ::testing::ValuesIn(mveCPUs));
-INSTANTIATE_TEST_CASE_P(MProfileParser, MProfileParserDSPCPUs, ::testing::ValuesIn(dspCPUs));
-INSTANTIATE_TEST_CASE_P(MProfileParser, MProfileParserNoExtensions,
-                        ::testing::ValuesIn(noExtensions));
-
-}  // namespace mprofile
-}  // namespace parsers
-}  // namespace target
-}  // namespace tvm
diff --git a/tests/cpp/target_test.cc b/tests/cpp/target_test.cc
index 0e9c46ceb3b2..fd1301c79442 100644
--- a/tests/cpp/target_test.cc
+++ b/tests/cpp/target_test.cc
@@ -35,11 +35,11 @@ TVM_REGISTER_TARGET_KIND("TestTargetKind", kDLCPU)
     .add_attr_option<ffi::Array<ffi::String>>("your_names")
     .add_attr_option<ffi::Map<ffi::String, int64_t>>("her_maps");
 
-TargetJSON TestTargetParser(TargetJSON target) {
+ffi::Map<ffi::String, ffi::Any> TestTargetParser(ffi::Map<ffi::String, ffi::Any> target) {
   ffi::String mcpu = Downcast<ffi::String>(target.at("mcpu"));
   target.Set("mcpu", ffi::String("super_") + mcpu);
   target.Set("keys", ffi::Array<ffi::String>({"super"}));
-  target.Set("features", ffi::Map<ffi::String, ffi::Any>{{"test", true}});
+  target.Set("feature.test", true);
   return target;
 }
 
@@ -52,18 +52,18 @@ TVM_REGISTER_TARGET_KIND("TestTargetParser", kDLCPU)
     .add_attr_option<ffi::String>("mattr")
     .add_attr_option<ffi::String>("mcpu")
     .set_default_keys({"cpu"})
-    .set_target_parser(TestTargetParser);
+    .set_target_canonicalizer(TestTargetParser);
 
 TVM_REGISTER_TARGET_KIND("TestAttrsPreprocessor", kDLCPU)
     .add_attr_option<ffi::String>("mattr")
     .set_default_keys({"cpu"})
-    .set_target_parser(TestAttrsPreProcessor);
+    .set_target_canonicalizer(TestAttrsPreProcessor);
 
 TVM_REGISTER_TARGET_KIND("TestClashingPreprocessor", kDLCPU)
     .add_attr_option<ffi::String>("mattr")
     .add_attr_option<ffi::String>("mcpu")
     .set_default_keys({"cpu"})
-    .set_target_parser(TestTargetParser);
+    .set_target_canonicalizer(TestTargetParser);
 
 TEST(TargetKind, GetAttrMap) {
   auto map = tvm::TargetKind::GetAttrMap<std::string>("Attr1");
@@ -184,21 +184,24 @@ TEST(TargetCreation, TargetFeatures) {
       {"kind", ffi::String("TestTargetParser")},
       {"mcpu", ffi::String("woof")},
   });
-  ASSERT_EQ(test_target_with_parser->GetFeature<bool>("test").value(), true);
+  // Features are stored as "feature.xxx" keys in attrs
+  ASSERT_EQ(test_target_with_parser->GetAttr<bool>("feature.test").value(), true);
 
   Target test_target_no_parser("TestTargetKind");
-  ASSERT_EQ(test_target_no_parser->GetFeature<bool>("test"), std::nullopt);
-  ASSERT_EQ(test_target_no_parser->GetFeature<bool>("test", true).value(), true);
+  ASSERT_EQ(test_target_no_parser->GetAttr<bool>("feature.test"), std::nullopt);
+  ASSERT_EQ(test_target_no_parser->GetAttr<bool>("feature.test", true).value(), true);
 }
 
-TEST(TargetCreation, TargetFeaturesBeforeParser) {
-  ffi::Map<ffi::String, ffi::Any> features = {{"test", true}};
-  ffi::Map<ffi::String, ffi::Any> config = {
+TEST(TargetCreation, TargetFeaturesSetByCanonicalizer) {
+  // feature.* keys are set by the canonicalizer, not by user input.
+  Target test_target(ffi::Map<ffi::String, ffi::Any>{
       {"kind", ffi::String("TestTargetParser")},
       {"mcpu", ffi::String("woof")},
-      {"features", features},
-  };
-  EXPECT_THROW(Target test(config), ffi::Error);
+  });
+  // TestTargetParser sets "feature.test" = true
+  ASSERT_EQ(test_target->GetAttr<bool>("feature.test").value(), true);
+  // Non-existent features return nullopt
+  ASSERT_EQ(test_target->GetAttr<bool>("feature.nonexistent"), std::nullopt);
 }
 
 TEST(TargetCreation, TargetAttrsPreProcessor) {
diff --git a/tests/python/codegen/test_target_codegen_vulkan.py b/tests/python/codegen/test_target_codegen_vulkan.py
index a9f1cd7ca3cb..dde8b5dca126 100644
--- a/tests/python/codegen/test_target_codegen_vulkan.py
+++ b/tests/python/codegen/test_target_codegen_vulkan.py
@@ -482,7 +482,7 @@ def main(X: T.Buffer((16, 32), "float16"), W: T.Buffer((32, 16), "float16"), com
     if tgt_attrs.get("supports_cooperative_matrix"):
         f = tvm.compile(Module, target=target)
 
-        dev = tvm.device(target, 0)
+        dev = tvm.device("vulkan", 0)
 
         A = tvm.runtime.tensor(np.random.randn(M, K).astype("float16"), dev)
         B = tvm.runtime.tensor(np.random.randn(K, N).astype("float16"), dev)