path: root/0017-mcmodel-Enable-mcmodel-medium-on-kunpeng.patch

From 4d76b521d9bb539556011304b8a76dea1e2657a1 Mon Sep 17 00:00:00 2001
From: bule <bule1@huawei.com>
Date: Fri, 6 Aug 2021 10:20:54 +0800
Subject: [PATCH 17/22] [mcmodel] Enable mcmodel=medium on kunpeng

Enable mcmodel=medium on kunpeng

diff --git a/gcc/combine.c b/gcc/combine.c
index 35505cc5311..497e53289ca 100644
--- a/gcc/combine.c
+++ b/gcc/combine.c
@@ -1923,6 +1923,12 @@ can_combine_p (rtx_insn *insn, rtx_insn *i3, rtx_insn *pred ATTRIBUTE_UNUSED,
 	      break;
 
 	    case SET:
+	      /* If the set is a symbol loaded by medium code model unspec
+		 escape this combine.  */
+	      if (GET_CODE (SET_SRC (elt)) == UNSPEC
+		  && XVECLEN (SET_SRC (elt), 0) != 0
+		  && targetm.medium_symbol_p (SET_SRC (elt)))
+		return 0;
 	      /* Ignore SETs whose result isn't used but not those that
 		 have side-effects.  */
 	      if (find_reg_note (insn, REG_UNUSED, SET_DEST (elt))
diff --git a/gcc/config/aarch64/aarch64-opts.h b/gcc/config/aarch64/aarch64-opts.h
index ee7bed34924..21828803480 100644
--- a/gcc/config/aarch64/aarch64-opts.h
+++ b/gcc/config/aarch64/aarch64-opts.h
@@ -66,6 +66,10 @@ enum aarch64_code_model {
   /* -fpic for small memory model.
      GOT size to 28KiB (4K*8-4K) or 3580 entries.  */
   AARCH64_CMODEL_SMALL_SPIC,
+  /* Using movk insn sequence to do 64bit PC relative relocation.  */
+  AARCH64_CMODEL_MEDIUM,
+  /* Using movk insn sequence to do 64bit PC relative got relocation.  */
+  AARCH64_CMODEL_MEDIUM_PIC,
   /* No assumptions about addresses of code and data.
      The PIC variant is not yet implemented.  */
   AARCH64_CMODEL_LARGE
diff --git a/gcc/config/aarch64/aarch64-protos.h b/gcc/config/aarch64/aarch64-protos.h
index bebd1b36228..226f3a8ff01 100644
--- a/gcc/config/aarch64/aarch64-protos.h
+++ b/gcc/config/aarch64/aarch64-protos.h
@@ -95,9 +95,11 @@
  */
 enum aarch64_symbol_type
 {
+  SYMBOL_MEDIUM_ABSOLUTE,
   SYMBOL_SMALL_ABSOLUTE,
   SYMBOL_SMALL_GOT_28K,
   SYMBOL_SMALL_GOT_4G,
+  SYMBOL_MEDIUM_GOT_4G,
   SYMBOL_SMALL_TLSGD,
   SYMBOL_SMALL_TLSDESC,
   SYMBOL_SMALL_TLSIE,
diff --git a/gcc/config/aarch64/aarch64.c b/gcc/config/aarch64/aarch64.c
index 79dc8f186f4..f78942b04c6 100644
--- a/gcc/config/aarch64/aarch64.c
+++ b/gcc/config/aarch64/aarch64.c
@@ -3127,6 +3127,29 @@ aarch64_load_symref_appropriately (rtx dest, rtx imm,
 	emit_insn (gen_add_losym (dest, tmp_reg, imm));
 	return;
       }
+    case SYMBOL_MEDIUM_ABSOLUTE:
+      {
+	rtx tmp_reg = dest;
+	machine_mode mode = GET_MODE (dest);
+
+	gcc_assert (mode == Pmode || mode == ptr_mode);
+	if (can_create_pseudo_p ())
+	  tmp_reg = gen_reg_rtx (mode);
+
+	if (mode == DImode)
+	  {
+	    emit_insn (gen_load_symbol_medium_di (dest, tmp_reg, imm));
+	  }
+	else
+	  {
+	    emit_insn (gen_load_symbol_medium_si (dest, tmp_reg, imm));
+	  }
+	if (REG_P (dest))
+	  {
+	    set_unique_reg_note (get_last_insn (), REG_EQUAL, copy_rtx (imm));
+	  }
+	return;
+      }
 
     case SYMBOL_TINY_ABSOLUTE:
       emit_insn (gen_rtx_SET (dest, imm));
@@ -3249,6 +3272,60 @@ aarch64_load_symref_appropriately (rtx dest, rtx imm,
 	return;
       }
 
+    case SYMBOL_MEDIUM_GOT_4G:
+      {
+	rtx tmp_reg = dest;
+	machine_mode mode = GET_MODE (dest);
+	if (can_create_pseudo_p ())
+	  {
+	    tmp_reg = gen_reg_rtx (mode);
+	  }
+	rtx insn;
+	rtx mem;
+	rtx s = gen_rtx_SYMBOL_REF (Pmode, "_GLOBAL_OFFSET_TABLE_");
+
+	if (mode == DImode)
+	  {
+	    emit_insn (gen_load_symbol_medium_di (tmp_reg, dest, s));
+	  }
+	else
+	  {
+	    emit_insn (gen_load_symbol_medium_si (tmp_reg, dest, s));
+	  }
+	if (REG_P (dest))
+	  {
+	    set_unique_reg_note (get_last_insn (), REG_EQUAL, copy_rtx (s));
+	  }
+
+	if (mode == ptr_mode)
+	  {
+	    if (mode == DImode)
+	      {
+		emit_insn (gen_get_gotoff_di (dest, imm));
+		insn = gen_ldr_got_medium_di (dest, tmp_reg, dest);
+	      }
+	    else
+	      {
+		emit_insn (gen_get_gotoff_si (dest, imm));
+		insn = gen_ldr_got_medium_si (dest, tmp_reg, dest);
+	      }
+	    mem = XVECEXP (SET_SRC (insn), 0, 0);
+	  }
+	else
+	  {
+	    gcc_assert (mode == Pmode);
+	    emit_insn (gen_get_gotoff_di (dest, imm));
+	    insn = gen_ldr_got_medium_sidi (dest, tmp_reg, dest);
+	    mem = XVECEXP (XEXP (SET_SRC (insn), 0), 0, 0);
+	  }
+
+	gcc_assert (GET_CODE (mem) == MEM);
+	MEM_READONLY_P (mem) = 1;
+	MEM_NOTRAP_P (mem) = 1;
+	emit_insn (insn);
+	return;
+      }
+
     case SYMBOL_SMALL_TLSGD:
       {
 	rtx_insn *insns;
@@ -5256,11 +5333,12 @@ aarch64_expand_mov_immediate (rtx dest, rtx imm)
 
 	  return;
 
-        case SYMBOL_SMALL_TLSGD:
-        case SYMBOL_SMALL_TLSDESC:
+	case SYMBOL_SMALL_TLSGD:
+	case SYMBOL_SMALL_TLSDESC:
 	case SYMBOL_SMALL_TLSIE:
 	case SYMBOL_SMALL_GOT_28K:
 	case SYMBOL_SMALL_GOT_4G:
+	case SYMBOL_MEDIUM_GOT_4G:
 	case SYMBOL_TINY_GOT:
 	case SYMBOL_TINY_TLSIE:
 	  if (const_offset != 0)
@@ -5279,6 +5357,7 @@ aarch64_expand_mov_immediate (rtx dest, rtx imm)
 	case SYMBOL_TLSLE24:
 	case SYMBOL_TLSLE32:
 	case SYMBOL_TLSLE48:
+	case SYMBOL_MEDIUM_ABSOLUTE:
 	  aarch64_load_symref_appropriately (dest, imm, sty);
 	  return;
 
@@ -9389,7 +9468,14 @@ aarch64_classify_address (struct aarch64_address_info *info,
 	  if (GET_CODE (sym) == SYMBOL_REF
 	      && offset.is_constant (&const_offset)
 	      && (aarch64_classify_symbol (sym, const_offset)
-		  == SYMBOL_SMALL_ABSOLUTE))
+		  == SYMBOL_SMALL_ABSOLUTE
+		  /* Fix fail on dbl_mov_immediate_1.c.  If end up here with
+		     MEDIUM_ABSOLUTE, the symbol is a constant number that is
+		     forced to memory in reload pass, which is ok to go on with
+		     the original design that subtitude the mov to
+		     'adrp and ldr :losum'.  */
+		  || aarch64_classify_symbol (sym, const_offset)
+		     == SYMBOL_MEDIUM_ABSOLUTE))
 	    {
 	      /* The symbol and offset must be aligned to the access size.  */
 	      unsigned int align;
@@ -11346,7 +11432,13 @@ static inline bool
 aarch64_can_use_per_function_literal_pools_p (void)
 {
   return (aarch64_pcrelative_literal_loads
-	  || aarch64_cmodel == AARCH64_CMODEL_LARGE);
+	  || aarch64_cmodel == AARCH64_CMODEL_LARGE
+	  /* Fix const9.C so that constants goes to function_literal_pools.
+	     According to the orignal design of aarch64 mcmodel=medium, we
+	     don't care where this symbol is put.  For the benefit of code size
+	     and behaviour consistent with other mcmodel, put it into
+	     function_literal_pools.  */
+	  || aarch64_cmodel == AARCH64_CMODEL_MEDIUM);
 }
 
 static bool
@@ -13003,6 +13095,13 @@ cost_plus:
 	  if (speed)
 	    *cost += extra_cost->alu.arith;
 	}
+      else if (aarch64_cmodel == AARCH64_CMODEL_MEDIUM
+	       || aarch64_cmodel == AARCH64_CMODEL_MEDIUM_PIC)
+	{
+	  /* 4 movs  adr  sub  add  2movs  ldr.  */
+	  if (speed)
+	    *cost += 7*extra_cost->alu.arith;
+	}
 
       if (flag_pic)
 	{
@@ -13010,6 +13109,8 @@ cost_plus:
 	  *cost += COSTS_N_INSNS (1);
 	  if (speed)
 	    *cost += extra_cost->ldst.load;
+	  if (aarch64_cmodel == AARCH64_CMODEL_MEDIUM_PIC)
+	    *cost += 2*extra_cost->alu.arith;
 	}
       return true;
 
@@ -14373,6 +14474,7 @@ initialize_aarch64_tls_size (struct gcc_options *opts)
       if (aarch64_tls_size > 32)
 	aarch64_tls_size = 32;
       break;
+    case AARCH64_CMODEL_MEDIUM:
     case AARCH64_CMODEL_LARGE:
       /* The maximum TLS size allowed under large is 16E.
 	 FIXME: 16E should be 64bit, we only support 48bit offset now.  */
@@ -15266,6 +15368,12 @@ initialize_aarch64_code_model (struct gcc_options *opts)
 #endif
 	}
       break;
+    case AARCH64_CMODEL_MEDIUM:
+      if (opts->x_flag_pic)
+      {
+	aarch64_cmodel = AARCH64_CMODEL_MEDIUM_PIC;
+      }
+      break;
     case AARCH64_CMODEL_LARGE:
       if (opts->x_flag_pic)
 	sorry ("code model %qs with %<-f%s%>", "large",
@@ -15276,6 +15384,7 @@ initialize_aarch64_code_model (struct gcc_options *opts)
     case AARCH64_CMODEL_TINY_PIC:
     case AARCH64_CMODEL_SMALL_PIC:
     case AARCH64_CMODEL_SMALL_SPIC:
+    case AARCH64_CMODEL_MEDIUM_PIC:
       gcc_unreachable ();
     }
 }
@@ -15286,6 +15395,7 @@ static void
 aarch64_option_save (struct cl_target_option *ptr, struct gcc_options *opts)
 {
   ptr->x_aarch64_override_tune_string = opts->x_aarch64_override_tune_string;
+  ptr->x_aarch64_data_threshold = opts->x_aarch64_data_threshold;
   ptr->x_aarch64_branch_protection_string
     = opts->x_aarch64_branch_protection_string;
 }
@@ -15301,6 +15411,7 @@ aarch64_option_restore (struct gcc_options *opts, struct cl_target_option *ptr)
   opts->x_explicit_arch = ptr->x_explicit_arch;
   selected_arch = aarch64_get_arch (ptr->x_explicit_arch);
   opts->x_aarch64_override_tune_string = ptr->x_aarch64_override_tune_string;
+  opts->x_aarch64_data_threshold = ptr->x_aarch64_data_threshold;
   opts->x_aarch64_branch_protection_string
     = ptr->x_aarch64_branch_protection_string;
   if (opts->x_aarch64_branch_protection_string)
@@ -16169,6 +16280,8 @@ aarch64_classify_symbol (rtx x, HOST_WIDE_INT offset)
 
 	case AARCH64_CMODEL_SMALL_SPIC:
 	case AARCH64_CMODEL_SMALL_PIC:
+	case AARCH64_CMODEL_MEDIUM_PIC:
+	case AARCH64_CMODEL_MEDIUM:
 	case AARCH64_CMODEL_SMALL:
 	  return SYMBOL_SMALL_ABSOLUTE;
 
@@ -16205,6 +16318,7 @@ aarch64_classify_symbol (rtx x, HOST_WIDE_INT offset)
 	  return SYMBOL_TINY_ABSOLUTE;
 
 	case AARCH64_CMODEL_SMALL:
+	AARCH64_SMALL_ROUTINE:
 	  /* Same reasoning as the tiny code model, but the offset cap here is
 	     1MB, allowing +/-3.9GB for the offset to the symbol.  */
 
@@ -16228,7 +16342,50 @@ aarch64_classify_symbol (rtx x, HOST_WIDE_INT offset)
 		    ?  SYMBOL_SMALL_GOT_28K : SYMBOL_SMALL_GOT_4G);
 	  return SYMBOL_SMALL_ABSOLUTE;
 
+	case AARCH64_CMODEL_MEDIUM:
+	  {
+	    tree decl_local = SYMBOL_REF_DECL (x);
+	    if (decl_local != NULL
+		&& tree_fits_uhwi_p (DECL_SIZE_UNIT (decl_local)))
+	      {
+		HOST_WIDE_INT size = tree_to_uhwi (DECL_SIZE_UNIT (decl_local));
+		/* If the data is smaller than the threshold, goto
+		   the small code model.  Else goto the large code
+		   model.  */
+		if (size >= HOST_WIDE_INT (aarch64_data_threshold))
+		  goto AARCH64_LARGE_ROUTINE;
+	      }
+	    goto AARCH64_SMALL_ROUTINE;
+	  }
+
+	case AARCH64_CMODEL_MEDIUM_PIC:
+	  {
+	    tree decl_local = SYMBOL_REF_DECL (x);
+	    if (decl_local != NULL
+		&& tree_fits_uhwi_p (DECL_SIZE_UNIT (decl_local)))
+	      {
+		HOST_WIDE_INT size = tree_to_uhwi (DECL_SIZE_UNIT (decl_local));
+		if (size < HOST_WIDE_INT (aarch64_data_threshold))
+		  {
+		    if (!aarch64_symbol_binds_local_p (x))
+		      {
+			/* flag_pic is 2 only when -fPIC is on, when we should
+			   use 4G GOT.  */
+			return flag_pic == 2 ? SYMBOL_SMALL_GOT_4G
+					     : SYMBOL_SMALL_GOT_28K ;
+		      }
+		    return SYMBOL_SMALL_ABSOLUTE;
+		  }
+	      }
+	    if (!aarch64_symbol_binds_local_p (x))
+	      {
+		return SYMBOL_MEDIUM_GOT_4G;
+	      }
+	    return SYMBOL_MEDIUM_ABSOLUTE;
+	  }
+
 	case AARCH64_CMODEL_LARGE:
+	AARCH64_LARGE_ROUTINE:
 	  /* This is alright even in PIC code as the constant
 	     pool reference is always PC relative and within
 	     the same translation unit.  */
@@ -19352,6 +19509,8 @@ aarch64_asm_preferred_eh_data_format (int code ATTRIBUTE_UNUSED, int global)
      case AARCH64_CMODEL_SMALL:
      case AARCH64_CMODEL_SMALL_PIC:
      case AARCH64_CMODEL_SMALL_SPIC:
+     case AARCH64_CMODEL_MEDIUM:
+     case AARCH64_CMODEL_MEDIUM_PIC:
        /* text+got+data < 4Gb.  4-byte signed relocs are sufficient
 	  for everything.  */
        type = DW_EH_PE_sdata4;
@@ -22605,7 +22764,14 @@ aarch64_empty_mask_is_expensive (unsigned)
 bool
 aarch64_use_pseudo_pic_reg (void)
 {
-  return aarch64_cmodel == AARCH64_CMODEL_SMALL_SPIC;
+  /* flag_pic is 2 when -fPIC is on, where we do not need the pseudo
+     pic reg.  In medium code mode, when combine with -fpie/-fpic, there are
+     possibility that some symbol size smaller than the -mlarge-data-threshold
+     will still use SMALL_SPIC relocation, which need the pseudo pic reg.
+     Fix spill_1.c fail.  */
+  return aarch64_cmodel == AARCH64_CMODEL_SMALL_SPIC
+	 || (aarch64_cmodel == AARCH64_CMODEL_MEDIUM_PIC
+	     && flag_pic != 2);
 }
 
 /* Implement TARGET_UNSPEC_MAY_TRAP_P.  */
@@ -22615,6 +22781,7 @@ aarch64_unspec_may_trap_p (const_rtx x, unsigned flags)
 {
   switch (XINT (x, 1))
     {
+    case UNSPEC_GOTMEDIUMPIC4G:
     case UNSPEC_GOTSMALLPIC:
     case UNSPEC_GOTSMALLPIC28K:
     case UNSPEC_GOTTINYPIC:
@@ -22976,6 +23143,18 @@ aarch64_estimated_poly_value (poly_int64 val)
   return val.coeffs[0] + val.coeffs[1] * over_128 / 128;
 }
 
+/* Implement TARGET_MEDIUM_SYMBOL_P.
+   Return true if x is a symbol loaded by UNSPEC_LOAD_SYMBOL_MEDIUM.  */
+bool
+aarch64_medium_symbol_p (rtx x)
+{
+  if (GET_CODE (x) != UNSPEC)
+    {
+      return false;
+    }
+  return XINT (x, 1) == UNSPEC_LOAD_SYMBOL_MEDIUM;
+}
+
 
 /* Return true for types that could be supported as SIMD return or
    argument types.  */
@@ -24015,6 +24194,9 @@ aarch64_libgcc_floating_mode_supported_p
 #undef TARGET_ESTIMATED_POLY_VALUE
 #define TARGET_ESTIMATED_POLY_VALUE aarch64_estimated_poly_value
 
+#undef TARGET_MEDIUM_SYMBOL_P
+#define TARGET_MEDIUM_SYMBOL_P aarch64_medium_symbol_p
+
 #undef TARGET_ATTRIBUTE_TABLE
 #define TARGET_ATTRIBUTE_TABLE aarch64_attribute_table
 
diff --git a/gcc/config/aarch64/aarch64.h b/gcc/config/aarch64/aarch64.h
index 51148846345..8fc92d13dcb 100644
--- a/gcc/config/aarch64/aarch64.h
+++ b/gcc/config/aarch64/aarch64.h
@@ -33,6 +33,10 @@
 
 #define REGISTER_TARGET_PRAGMAS() aarch64_register_pragmas ()
 
+/* Default threshold 64-bit relocation data
+    with aarch64 medium memory model.  */
+#define AARCH64_DEFAULT_LARGE_DATA_THRESHOLD 65536
+
 /* Target machine storage layout.  */
 
 #define PROMOTE_MODE(MODE, UNSIGNEDP, TYPE)	\
diff --git a/gcc/config/aarch64/aarch64.md b/gcc/config/aarch64/aarch64.md
index 58445dea941..ee80261f1ac 100644
--- a/gcc/config/aarch64/aarch64.md
+++ b/gcc/config/aarch64/aarch64.md
@@ -224,6 +224,9 @@
     UNSPEC_RSQRTS
     UNSPEC_NZCV
     UNSPEC_XPACLRI
+    UNSPEC_GOTMEDIUMPIC4G
+    UNSPEC_GET_GOTOFF
+    UNSPEC_LOAD_SYMBOL_MEDIUM
     UNSPEC_LD1_SVE
     UNSPEC_ST1_SVE
     UNSPEC_LDNT1_SVE
@@ -6792,6 +6795,39 @@
   [(set_attr "type" "load_4")]
 )
 
+(define_insn "get_gotoff_<mode>"
+  [(set (match_operand:GPI 0 "register_operand" "=r")
+	(unspec:GPI [(match_operand 1 "aarch64_valid_symref" "S")]
+		  UNSPEC_GET_GOTOFF))]
+  ""
+  "movz\\t%x0, :gotoff_g1:%A1\;movk\\t%x0, :gotoff_g0_nc:%A1"
+  [(set_attr "type" "multiple")
+   (set_attr "length" "8")]
+)
+
+(define_insn "ldr_got_medium_<mode>"
+  [(set (match_operand:PTR 0 "register_operand" "=r")
+	(unspec:PTR [(mem:PTR (lo_sum:PTR
+			      (match_operand:PTR 1 "register_operand" "r")
+			      (match_operand:PTR 2 "register_operand" "r")))]
+		    UNSPEC_GOTMEDIUMPIC4G))]
+  ""
+  "ldr\\t%0, [%1, %2]"
+  [(set_attr "type" "load_4")]
+)
+
+(define_insn "ldr_got_medium_sidi"
+  [(set (match_operand:DI 0 "register_operand" "=r")
+	(zero_extend:DI
+	 (unspec:SI [(mem:SI (lo_sum:DI
+			     (match_operand:DI 1 "register_operand" "r")
+			     (match_operand:DI 2 "register_operand" "r")))]
+		    UNSPEC_GOTMEDIUMPIC4G)))]
+  "TARGET_ILP32"
+  "ldr\\t%0, [%1, %2]"
+  [(set_attr "type" "load_4")]
+)
+
 (define_insn "ldr_got_small_28k_<mode>"
   [(set (match_operand:PTR 0 "register_operand" "=r")
 	(unspec:PTR [(mem:PTR (lo_sum:PTR
@@ -6955,6 +6991,23 @@
    (set_attr "length" "12")]
 )
 
+(define_insn "load_symbol_medium_<mode>"
+   [(set (match_operand:GPI 0 "register_operand" "=r")
+		(unspec:GPI [(match_operand 2 "aarch64_valid_symref" "S")]
+		  UNSPEC_LOAD_SYMBOL_MEDIUM))
+	(clobber (match_operand:GPI 1 "register_operand" "=r"))]
+  ""
+  "movz\\t%x0, :prel_g3:%A2\;\\
+movk\\t%x0, :prel_g2_nc:%A2\;\\
+movk\\t%x0, :prel_g1_nc:%A2\;\\
+movk\\t%x0, :prel_g0_nc:%A2\;\\
+adr\\t%x1, .\;\\
+sub\\t%x1, %x1, 0x4\;\\
+add\\t%x0, %x0, %x1"
+  [(set_attr "type" "multiple")
+   (set_attr "length" "28")]
+)
+
 (define_expand "tlsdesc_small_<mode>"
   [(unspec:PTR [(match_operand 0 "aarch64_valid_symref")] UNSPEC_TLSDESC)]
   "TARGET_TLS_DESC"
diff --git a/gcc/config/aarch64/aarch64.opt b/gcc/config/aarch64/aarch64.opt
index 4539156d6f4..bb888461ab0 100644
--- a/gcc/config/aarch64/aarch64.opt
+++ b/gcc/config/aarch64/aarch64.opt
@@ -27,6 +27,10 @@ enum aarch64_processor explicit_tune_core = aarch64_none
 TargetVariable
 enum aarch64_arch explicit_arch = aarch64_no_arch
 
+;; -mlarge-data-threshold=
+TargetSave
+int x_aarch64_data_threshold
+
 TargetSave
 const char *x_aarch64_override_tune_string
 
@@ -60,9 +64,16 @@ Enum(cmodel) String(tiny) Value(AARCH64_CMODEL_TINY)
 EnumValue
 Enum(cmodel) String(small) Value(AARCH64_CMODEL_SMALL)
 
+EnumValue
+Enum(cmodel) String(medium) Value(AARCH64_CMODEL_MEDIUM)
+
 EnumValue
 Enum(cmodel) String(large) Value(AARCH64_CMODEL_LARGE)
 
+mlarge-data-threshold=
+Target RejectNegative Joined UInteger Var(aarch64_data_threshold) Init(AARCH64_DEFAULT_LARGE_DATA_THRESHOLD)
+-mlarge-data-threshold=<number> Data greater than given threshold will be assume that it should be relocated using 64-bit relocation.
+
 mbig-endian
 Target Report RejectNegative Mask(BIG_END)
 Assume target CPU is configured as big endian.
diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi
index fcb7245e95c..0508fce57a7 100644
--- a/gcc/doc/tm.texi
+++ b/gcc/doc/tm.texi
@@ -6983,6 +6983,11 @@ things like cost calculations or profiling frequencies.  The default
 implementation returns the lowest possible value of @var{val}.
 @end deftypefn
 
+@deftypefn {Target Hook} bool TARGET_MEDIUM_SYMBOL_P (rtx @var{x})
+Return true if the input rtx is a symbol loaded by kunpeng medium code
+model.
+@end deftypefn
+
 @node Scheduling
 @section Adjusting the Instruction Scheduler
 
diff --git a/gcc/doc/tm.texi.in b/gcc/doc/tm.texi.in
index c17209daa51..3b70ea4841a 100644
--- a/gcc/doc/tm.texi.in
+++ b/gcc/doc/tm.texi.in
@@ -4701,6 +4701,8 @@ Define this macro if a non-short-circuit operation produced by
 
 @hook TARGET_ESTIMATED_POLY_VALUE
 
+@hook TARGET_MEDIUM_SYMBOL_P
+
 @node Scheduling
 @section Adjusting the Instruction Scheduler
 
diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index d61cadb5208..bad8208cd22 100644
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -14501,14 +14501,17 @@ const_ok_for_output_1 (rtx rtl)
       /* If delegitimize_address couldn't do anything with the UNSPEC, and
 	 the target hook doesn't explicitly allow it in debug info, assume
 	 we can't express it in the debug info.  */
-      /* Don't complain about TLS UNSPECs, those are just too hard to
-	 delegitimize.  Note this could be a non-decl SYMBOL_REF such as
-	 one in a constant pool entry, so testing SYMBOL_REF_TLS_MODEL
-	 rather than DECL_THREAD_LOCAL_P is not just an optimization.  */
+      /* Don't complain about TLS UNSPECs and aarch64 medium code model
+	 related UNSPECs, those are just too hard to delegitimize.  Note
+	 this could be a non-decl SYMBOL_REF such as one in a constant
+	 pool entry, so testing SYMBOL_REF_TLS_MODEL rather than
+	 DECL_THREAD_LOCAL_P is not just an optimization.  */
       if (flag_checking
 	  && (XVECLEN (rtl, 0) == 0
 	      || GET_CODE (XVECEXP (rtl, 0, 0)) != SYMBOL_REF
-	      || SYMBOL_REF_TLS_MODEL (XVECEXP (rtl, 0, 0)) == TLS_MODEL_NONE))
+	      || (!targetm.medium_symbol_p (rtl)
+		  && SYMBOL_REF_TLS_MODEL (XVECEXP (rtl, 0, 0))
+		     == TLS_MODEL_NONE)))
 	inform (current_function_decl
 		? DECL_SOURCE_LOCATION (current_function_decl)
 		: UNKNOWN_LOCATION,
diff --git a/gcc/target.def b/gcc/target.def
index f5a6d507e91..2020564118b 100644
--- a/gcc/target.def
+++ b/gcc/target.def
@@ -3869,6 +3869,13 @@ implementation returns the lowest possible value of @var{val}.",
  HOST_WIDE_INT, (poly_int64 val),
  default_estimated_poly_value)
 
+DEFHOOK
+(medium_symbol_p,
+ "Return true if the input rtx is a symbol loaded by kunpeng medium code\n\
+model.",
+ bool, (rtx x),
+ default_medium_symbol_p)
+
 /* Permit speculative instructions in delay slots during delayed-branch 
    scheduling.  */
 DEFHOOK
diff --git a/gcc/targhooks.c b/gcc/targhooks.c
index 7cb04f30bdb..43a9f0cdf5b 100644
--- a/gcc/targhooks.c
+++ b/gcc/targhooks.c
@@ -1708,6 +1708,13 @@ default_estimated_poly_value (poly_int64 x)
   return x.coeffs[0];
 }
 
+/* The default implementation of TARGET_MEDIUM_SYMBOL_P.  */
+bool
+default_medium_symbol_p (rtx x ATTRIBUTE_UNUSED)
+{
+  return false;
+}
+
 /* For hooks which use the MOVE_RATIO macro, this gives the legacy default
    behavior.  SPEED_P is true if we are compiling for speed.  */
 
-- 
2.21.0.windows.1