Experiment with adding new ABI

Author: Blackhex

gcc/config/aarch64/aarch64.cc

@@ -736,6 +736,7 @@ handle_aarch64_vector_pcs_attribute (tree *node, tree name, tree,
     {
     case ARM_PCS_AAPCS64:
     case ARM_PCS_SIMD:
+    case ARM_PCS_MS_VARIADIC:
       return NULL_TREE;
 
     case ARM_PCS_SVE:
@@ -1238,6 +1239,21 @@ aarch64_some_values_include_pst_objects_p (const_tree type)
   return false;
 }
 
+/* Return the descriptor of the Windows Arm64 variadic function ABI.  */
+
+static const predefined_function_abi &
+aarch64_ms_variadic_abi (void)
+{
+  predefined_function_abi &ms_variadic_abi = function_abis[ARM_PCS_MS_VARIADIC];
+  if (!ms_variadic_abi.initialized_p ())
+    {
+      HARD_REG_SET full_reg_clobbers
+	= default_function_abi.full_reg_clobbers ();
+      ms_variadic_abi.initialize (ARM_PCS_MS_VARIADIC, full_reg_clobbers);
+    }
+  return ms_variadic_abi;
+}
+
 /* Return the descriptor of the SIMD ABI.  */
 
 static const predefined_function_abi &
@@ -2235,9 +2251,24 @@ aarch64_takes_arguments_in_sve_regs_p (const_tree fntype)
 
 /* Implement TARGET_FNTYPE_ABI.  */
 
+static bool is_variadic_function_type (const_tree fntype) {
+  tree arg_types = TYPE_ARG_TYPES (fntype);
+  for (tree arg = arg_types; arg; arg = TREE_CHAIN (arg)) {
+    if (TREE_VALUE (arg) == void_type_node) {
+      return false;
+    }
+  }
+  return true;
+}
+
 static const predefined_function_abi &
 aarch64_fntype_abi (const_tree fntype)
 {
+#if TARGET_AARCH64_MS_ABI
+  if (is_variadic_function_type (fntype))
+    return aarch64_ms_variadic_abi ();
+#endif
+
   if (lookup_attribute ("aarch64_vector_pcs", TYPE_ATTRIBUTES (fntype)))
     return aarch64_simd_abi ();
 
@@ -2449,6 +2480,7 @@ aarch64_reg_save_mode (unsigned int regno)
     switch (crtl->abi->id ())
       {
       case ARM_PCS_AAPCS64:
+      case ARM_PCS_MS_VARIADIC:
 	/* Only the low 64 bits are saved by the base PCS.  */
 	return DFmode;
 
@@ -5241,6 +5273,7 @@ aarch64_sme_mode_switch_regs::add_call_preserved_reg (unsigned int regno)
 	add_reg (V16QImode, regno);
 	break;
       case ARM_PCS_AAPCS64:
+      case ARM_PCS_MS_VARIADIC:
 	add_reg (DImode, regno);
 	break;
       default:
@@ -6906,6 +6939,55 @@ bitint_or_aggr_of_bitint_p (tree type)
   return false;
 }
 
+static void
+aarch64_ms_variadic_abi_layout_arg (cumulative_args_t pcum_v, const function_arg_info &arg)
+{
+  CUMULATIVE_ARGS *pcum = get_cumulative_args (pcum_v);
+  tree type = arg.type;
+  machine_mode mode = arg.mode;
+  HOST_WIDE_INT size;
+  unsigned int abi_break_gcc_9;
+  unsigned int abi_break_gcc_13;
+  unsigned int abi_break_gcc_14;
+
+  /* We need to do this once per argument.  */
+  if (pcum->aapcs_arg_processed)
+    return;
+
+  pcum->aapcs_arg_processed = true;
+
+  /* Size in bytes, rounded to the nearest multiple of 8 bytes.  */
+  if (type)
+    size = int_size_in_bytes (type);
+  else
+    /* No frontends can create types with variable-sized modes, so we
+       shouldn't be asked to pass or return them.  */
+    size = GET_MODE_SIZE (mode).to_constant ();
+  size = ROUND_UP (size, UNITS_PER_WORD);
+
+  unsigned int alignment
+    = aarch64_function_arg_alignment (mode, type, &abi_break_gcc_9,
+				      &abi_break_gcc_13, &abi_break_gcc_14);
+
+  gcc_assert ((alignment <= 16 * BITS_PER_UNIT)
+	      && (!alignment || abi_break_gcc_9 < alignment)
+	      && (!abi_break_gcc_13 || alignment < abi_break_gcc_13));
+
+  /* The argument is passed on stack; record the needed number of words for
+     this argument and align the total size if necessary.  */
+  pcum->aapcs_stack_words = size / UNITS_PER_WORD;
+
+  if (alignment == 16 * BITS_PER_UNIT)
+    {
+      int new_size = ROUND_UP (pcum->aapcs_stack_size, 16 / UNITS_PER_WORD);
+      if (pcum->aapcs_stack_size != new_size)
+	{
+	  pcum->aapcs_stack_size = new_size;
+	}
+    }
+  return;
+}
+
 /* Layout a function argument according to the AAPCS64 rules.  The rule
    numbers refer to the rule numbers in the AAPCS64.  ORIG_MODE is the
    mode that was originally given to us by the target hook, whereas the
@@ -6929,6 +7011,11 @@ aarch64_layout_arg (cumulative_args_t pcum_v, const function_arg_info &arg)
   if (pcum->aapcs_arg_processed)
     return;
 
+  if (pcum->pcs_variant == ARM_PCS_MS_VARIADIC) {
+    aarch64_ms_variadic_abi_layout_arg (pcum_v, arg);
+    return;
+  }
+
   bool warn_pcs_change
     = (warn_psabi
        && !pcum->silent_p
@@ -7294,7 +7381,8 @@ aarch64_function_arg (cumulative_args_t pcum_v, const function_arg_info &arg)
   CUMULATIVE_ARGS *pcum = get_cumulative_args (pcum_v);
   gcc_assert (pcum->pcs_variant == ARM_PCS_AAPCS64
 	      || pcum->pcs_variant == ARM_PCS_SIMD
-	      || pcum->pcs_variant == ARM_PCS_SVE);
+	      || pcum->pcs_variant == ARM_PCS_SVE
+              || pcum->pcs_variant == ARM_PCS_MS_VARIADIC);
 
   if (arg.end_marker_p ())
     {
@@ -7382,7 +7470,8 @@ aarch64_function_arg_advance (cumulative_args_t pcum_v,
   CUMULATIVE_ARGS *pcum = get_cumulative_args (pcum_v);
   if (pcum->pcs_variant == ARM_PCS_AAPCS64
       || pcum->pcs_variant == ARM_PCS_SIMD
-      || pcum->pcs_variant == ARM_PCS_SVE)
+      || pcum->pcs_variant == ARM_PCS_SVE
+      || pcum->pcs_variant == ARM_PCS_MS_VARIADIC)
     {
       aarch64_layout_arg (pcum_v, arg);
       gcc_assert ((pcum->aapcs_reg != NULL_RTX)
@@ -11265,6 +11354,31 @@ aarch64_restore_zt0 (bool from_lazy_save_p)
 	     : gen_aarch64_sme_ldr_zt0 (mem));
 }
 
+static void
+aarch64_ms_variadic_abi_call_args (cumulative_args_t, rtx arg, tree fntype)
+{
+  // TODO: Load first 64 bytes of stack to x0-x7 registers.
+  if (fntype && is_variadic_function_type (fntype)) 
+    {
+      machine_mode mode = aarch64_reg_save_mode (R0_REGNUM);
+
+      /*rtx cfi_ops = NULL;
+      aarch64_pop_regs (R0_REGNUM, R1_REGNUM, 0, &cfi_ops);*/
+
+      /*move_block_to_reg (R0_REGNUM, mem, NUM_ARG_REGS, mode);*/
+ 
+      // TODO: Load only registers that are used in the function.
+      for (int i = 0; i < 8; i++)
+	{
+	  HOST_WIDE_INT offset = i * UNITS_PER_WORD;
+	  rtx sp = stack_pointer_rtx;
+	  rtx reg = gen_rtx_REG (mode, R0_REGNUM + i);
+	  rtx mem = gen_rtx_MEM (mode, plus_constant (Pmode, sp, offset));
+	  emit_move_insn (reg, mem);
+      }
+    }
+}
+
 /* Implement TARGET_START_CALL_ARGS.  */
 
 static void
@@ -21487,7 +21601,7 @@ aarch64_expand_builtin_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED)
 #ifdef TARGET_AARCH64_MS_ABI
 
 static void
-aarch64_ms_abi_expand_builtin_va_start (tree valist, rtx nextarg)
+aarch64_ms_variadic_abi_expand_builtin_va_start (tree valist, rtx nextarg)
 {
   nextarg = plus_constant (Pmode, nextarg, cfun->machine->frame.first_vararg_offset, true);
   std_expand_builtin_va_start (valist, nextarg);
@@ -31080,7 +31194,7 @@ aarch64_run_selftests (void)
 
 #undef TARGET_EXPAND_BUILTIN_VA_START
 #ifdef TARGET_AARCH64_MS_ABI
-#define TARGET_EXPAND_BUILTIN_VA_START aarch64_ms_abi_expand_builtin_va_start
+#define TARGET_EXPAND_BUILTIN_VA_START aarch64_ms_variadic_abi_expand_builtin_va_start
 #else
 #define TARGET_EXPAND_BUILTIN_VA_START aarch64_expand_builtin_va_start
 #endif
@@ -31114,6 +31228,11 @@ aarch64_run_selftests (void)
 #undef TARGET_FUNCTION_VALUE_REGNO_P
 #define TARGET_FUNCTION_VALUE_REGNO_P aarch64_function_value_regno_p
 
+#ifdef TARGET_AARCH64_MS_ABI
+#undef TARGET_CALL_ARGS
+#define TARGET_CALL_ARGS aarch64_ms_variadic_abi_call_args
+#endif
+
 #undef TARGET_START_CALL_ARGS
 #define TARGET_START_CALL_ARGS aarch64_start_call_args
 

gcc/config/aarch64/aarch64.h

@@ -1114,6 +1114,7 @@ enum arm_pcs
   ARM_PCS_SVE,			/* For functions that pass or return
 				   values in SVE registers.  */
   ARM_PCS_TLSDESC,		/* For targets of tlsdesc calls.  */
+  ARM_PCS_MS_VARIADIC,		/* For Windows Arm64 variadic functions.  */
   ARM_PCS_UNKNOWN
 };