lib.systems.elaborate.canExecute: handle different gcc.arch (#403549)

lib/systems/architectures.nix

@@ -494,6 +494,70 @@ rec {
       loongson2f = [ ];
     };
 
+  /**
+    Check whether one GCC architecture has the the other inferior architecture.
+
+    # Inputs
+
+    `arch1`
+    : GCC architecture in string
+
+    `arch2`
+    : GCC architecture in string
+
+    # Type
+
+    ```
+    hasInferior :: string -> string -> bool
+    ```
+
+    # Examples
+    ::: {.example}
+    ## `lib.systems.architectures.hasInferior` usage example
+
+    ```nix
+    hasInferior "x86-64-v3" "x86-64"
+    => true
+    hasInferior "x86-64" "x86-64-v3"
+    => false
+    hasInferior "x86-64" "x86-64"
+    => false
+    ```
+  */
+  hasInferior = arch1: arch2: inferiors ? ${arch1} && lib.elem arch2 inferiors.${arch1};
+
+  /**
+    Check whether one GCC architecture can execute the other.
+
+    # Inputs
+
+    `arch1`
+    : GCC architecture in string
+
+    `arch2`
+    : GCC architecture in string
+
+    # Type
+
+    ```
+    canExecute :: string -> string -> bool
+    ```
+
+    # Examples
+    ::: {.example}
+    ## `lib.systems.architectures.canExecute` usage example
+
+    ```nix
+    canExecute "x86-64" "x86-64-v3"
+    => false
+    canExecute "x86-64-v3" "x86-64"
+    => true
+    canExecute "x86-64" "x86-64"
+    => true
+    ```
+  */
+  canExecute = arch1: arch2: arch1 == arch2 || hasInferior arch1 arch2;
+
   predicates =
     let
       featureSupport = feature: x: builtins.elem feature features.${x} or [ ];

lib/systems/default.nix

@@ -97,7 +97,21 @@ let
             platform:
             final.isAndroid == platform.isAndroid
             && parse.isCompatible final.parsed.cpu platform.parsed.cpu
-            && final.parsed.kernel == platform.parsed.kernel;
+            && final.parsed.kernel == platform.parsed.kernel
+            && (
+              # Only perform this check when cpus have the same type;
+              # assume compatible cpu have all the instructions included
+              final.parsed.cpu == platform.parsed.cpu
+              ->
+                # if both have gcc.arch defined, check whether final can execute the given platform
+                (
+                  (final ? gcc.arch && platform ? gcc.arch)
+                  -> architectures.canExecute final.gcc.arch platform.gcc.arch
+                )
+                # if platform has gcc.arch defined but final doesn't, don't assume it can be executed
+                || (platform ? gcc.arch -> !(final ? gcc.arch))
+            );
+
           isCompatible =
             _:
             throw "2022-05-23: isCompatible has been removed in favor of canExecute, refer to the 22.11 changelog for details";