commit 60281b40f9b28b1b1b912f3157547d6b4f50669c

Author: root <root@lenovo-x3950-01.khw.lab.eng.bos.redhat.com>

Date:   Thu Jan 18 17:50:46 2018 -0500

    HJ patch #1

diff --git a/gcc/config/i386/i386-opts.h b/gcc/config/i386/i386-opts.h

index 11c0845..139d23c 100644

--- a/gcc/config/i386/i386-opts.h

+++ b/gcc/config/i386/i386-opts.h

@@ -85,4 +85,16 @@ enum ix86_veclibabi {

   ix86_veclibabi_type_acml

 };

+/* This is used to mitigate variant #2 of the speculative execution

+   vulnerabilities on x86 processors identified by CVE-2017-5715, aka

+   Spectre.  They convert indirect branches and function returns to

+   call and return thunks to avoid speculative execution via indirect

+   call, jmp and ret.  */

+enum indirect_branch {

+  indirect_branch_unset = 0,

+  indirect_branch_keep,

+  indirect_branch_thunk,

+  indirect_branch_thunk_inline,

+  indirect_branch_thunk_extern

+};

 #endif

diff --git a/gcc/config/i386/i386-protos.h b/gcc/config/i386/i386-protos.h

index 96e7c5c..ecdf108 100644

--- a/gcc/config/i386/i386-protos.h

+++ b/gcc/config/i386/i386-protos.h

@@ -306,6 +306,7 @@ extern enum attr_cpu ix86_schedule;

 #endif

 extern const char * ix86_output_call_insn (rtx insn, rtx call_op);

+extern const char * ix86_output_indirect_jmp (rtx call_op, bool ret_p);

 #ifdef RTX_CODE

 /* Target data for multipass lookahead scheduling.

diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c

index b91a456..ebc9a90 100644

--- a/gcc/config/i386/i386.c

+++ b/gcc/config/i386/i386.c

@@ -2572,12 +2572,23 @@ struct rtl_opt_pass pass_insert_vzeroupper =

  }

 };

-/* Return true if a red-zone is in use.  */

+/* Return true if a red-zone is in use.  We can't use red-zone when

+   there are local indirect jumps, like "indirect_jump" or "tablejump",

+   which jumps to another place in the function, since "call" in the

+   indirect thunk pushes the return address onto stack, destroying

+   red-zone.

+

+   TODO: If we can reserve the first 2 WORDs, for PUSH and, another

+   for CALL, in red-zone, we can allow local indirect jumps with

+   indirect thunk.  */

 static inline bool

 ix86_using_red_zone (void)

 {

-  return TARGET_RED_ZONE && !TARGET_64BIT_MS_ABI;

+  return (TARGET_RED_ZONE

+	  && !TARGET_64BIT_MS_ABI

+	  && (!cfun->machine->has_local_indirect_jump

+	      || cfun->machine->indirect_branch_type == indirect_branch_keep));

 }

 /* Return a string that documents the current -m options.  The caller is

@@ -4595,6 +4606,37 @@ ix86_can_inline_p (tree caller, tree callee)

 }

+/* Set the indirect_branch_type field from the function FNDECL.  */

+

+static void

+ix86_set_indirect_branch_type (tree fndecl)

+{

+  if (cfun->machine->indirect_branch_type == indirect_branch_unset)

+    {

+      tree attr = lookup_attribute ("indirect_branch",

+				    DECL_ATTRIBUTES (fndecl));

+      if (attr != NULL)

+	{

+	  tree args = TREE_VALUE (attr);

+	  if (args == NULL)

+	    gcc_unreachable ();

+	  tree cst = TREE_VALUE (args);

+	  if (strcmp (TREE_STRING_POINTER (cst), "keep") == 0)

+	    cfun->machine->indirect_branch_type = indirect_branch_keep;

+	  else if (strcmp (TREE_STRING_POINTER (cst), "thunk") == 0)

+	    cfun->machine->indirect_branch_type = indirect_branch_thunk;

+	  else if (strcmp (TREE_STRING_POINTER (cst), "thunk-inline") == 0)

+	    cfun->machine->indirect_branch_type = indirect_branch_thunk_inline;

+	  else if (strcmp (TREE_STRING_POINTER (cst), "thunk-extern") == 0)

+	    cfun->machine->indirect_branch_type = indirect_branch_thunk_extern;

+	  else

+	    gcc_unreachable ();

+	}

+      else

+	cfun->machine->indirect_branch_type = ix86_indirect_branch;

+    }

+}

+

 /* Remember the last target of ix86_set_current_function.  */

 static GTY(()) tree ix86_previous_fndecl;

@@ -4609,6 +4651,9 @@ ix86_set_current_function (tree fndecl)

      slow things down too much or call target_reinit when it isn't safe.  */

   if (fndecl && fndecl != ix86_previous_fndecl)

     {

+      if (cfun && cfun->machine && fndecl)

+	ix86_set_indirect_branch_type (fndecl);

+

       tree old_tree = (ix86_previous_fndecl

 		       ? DECL_FUNCTION_SPECIFIC_TARGET (ix86_previous_fndecl)

 		       : NULL_TREE);

@@ -4637,6 +4682,8 @@ ix86_set_current_function (tree fndecl)

 	  target_reinit ();

 	}

     }

+  if (cfun && cfun->machine && fndecl)

+    ix86_set_indirect_branch_type (fndecl);

 }

@@ -8668,6 +8715,196 @@ ix86_setup_frame_addresses (void)

 # endif

 #endif

+/* Label count for call and return thunks.  It is used to make unique

+   labels in call and return thunks.  */

+static int indirectlabelno;

+

+/* True if call and return thunk functions are needed.  */

+static bool indirect_thunk_needed = false;

+

+/* Bit masks of integer registers, which contain branch target, used

+   by call and return thunks functions.  */

+static int indirect_thunks_used;

+

+#ifndef INDIRECT_LABEL

+# define INDIRECT_LABEL "LIND"

+#endif

+

+/* Fills in the label name that should be used for the indirect thunk.  */

+

+static void

+indirect_thunk_name (char name[32], int regno)

+{

+  if (USE_HIDDEN_LINKONCE)

+    {

+      if (regno >= 0)

+	{

+	  const char *reg_prefix;

+	  if (LEGACY_INT_REGNO_P (regno))

+	    reg_prefix = TARGET_64BIT ? "r" : "e";

+	  else

+	    reg_prefix = "";

+	  sprintf (name, "__x86_indirect_thunk_%s%s",

+		   reg_prefix, reg_names[regno]);

+	}

+      else

+	sprintf (name, "__x86_indirect_thunk");

+    }

+  else

+    {

+      if (regno >= 0)

+	ASM_GENERATE_INTERNAL_LABEL (name, "LITR", regno);

+      else

+	ASM_GENERATE_INTERNAL_LABEL (name, "LIT", 0);

+    }

+}

+

+/* Output a call and return thunk for indirect branch.  If REGNO != -1,

+   the function address is in REGNO and the call and return thunk looks like:

+

+	call	L2

+   L1:

+	pause

+	jmp	L1

+   L2:

+	mov	%REG, (%sp)

+	ret

+

+   Otherwise, the function address is on the top of stack and the

+   call and return thunk looks like:

+

+	call L2

+  L1:

+	pause

+	jmp L1

+  L2:

+	lea WORD_SIZE(%sp), %sp

+	ret

+ */

+

+static void

+output_indirect_thunk (int regno)

+{

+  char indirectlabel1[32];

+  char indirectlabel2[32];

+

+  ASM_GENERATE_INTERNAL_LABEL (indirectlabel1, INDIRECT_LABEL,

+			       indirectlabelno++);

+  ASM_GENERATE_INTERNAL_LABEL (indirectlabel2, INDIRECT_LABEL,

+			       indirectlabelno++);

+

+  /* Call */

+  fputs ("\tcall\t", asm_out_file);

+  assemble_name_raw (asm_out_file, indirectlabel2);

+  fputc ('\n', asm_out_file);

+

+  ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, indirectlabel1);

+

+  /* Pause + lfence.  */

+  fprintf (asm_out_file, "\tpause\n\tlfence\n");

+

+  /* Jump.  */

+  fputs ("\tjmp\t", asm_out_file);

+  assemble_name_raw (asm_out_file, indirectlabel1);

+  fputc ('\n', asm_out_file);

+

+  ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, indirectlabel2);

+

+  if (regno >= 0)

+    {

+      /* MOV.  */

+      rtx xops[2];

+      xops[0] = gen_rtx_MEM (word_mode, stack_pointer_rtx);

+      xops[1] = gen_rtx_REG (word_mode, regno);

+      output_asm_insn ("mov\t{%1, %0|%0, %1}", xops);

+    }

+  else

+    {

+      /* LEA.  */

+      rtx xops[2];

+      xops[0] = stack_pointer_rtx;

+      xops[1] = plus_constant (Pmode, stack_pointer_rtx, UNITS_PER_WORD);

+      output_asm_insn ("lea\t{%E1, %0|%0, %E1}", xops);

+    }

+

+  fputs ("\tret\n", asm_out_file);

+}

+

+/* Output a funtion with a call and return thunk for indirect branch.

+   If REGNO != -1, the function address is in REGNO.  Otherwise, the

+   function address is on the top of stack.  */

+

+static void

+output_indirect_thunk_function (int regno)

+{

+  char name[32];

+  tree decl;

+

+  /* Create __x86_indirect_thunk.  */

+  indirect_thunk_name (name, regno);

+  decl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL,

+		     get_identifier (name),

+		     build_function_type_list (void_type_node, NULL_TREE));

+  DECL_RESULT (decl) = build_decl (BUILTINS_LOCATION, RESULT_DECL,

+				   NULL_TREE, void_type_node);

+  TREE_PUBLIC (decl) = 1;

+  TREE_STATIC (decl) = 1;

+  DECL_IGNORED_P (decl) = 1;

+

+#if TARGET_MACHO

+  if (TARGET_MACHO)

+    {

+      switch_to_section (darwin_sections[picbase_thunk_section]);

+      fputs ("\t.weak_definition\t", asm_out_file);

+      assemble_name (asm_out_file, name);

+      fputs ("\n\t.private_extern\t", asm_out_file);

+      assemble_name (asm_out_file, name);

+      putc ('\n', asm_out_file);

+      ASM_OUTPUT_LABEL (asm_out_file, name);

+      DECL_WEAK (decl) = 1;

+    }

+  else

+#endif

+    if (USE_HIDDEN_LINKONCE)

+      {

+	DECL_COMDAT (decl) = 1;

+	make_decl_one_only (decl, DECL_ASSEMBLER_NAME (decl));

+

+	targetm.asm_out.unique_section (decl, 0);

+	switch_to_section (get_named_section (decl, NULL, 0));

+

+	targetm.asm_out.globalize_label (asm_out_file, name);

+	fputs ("\t.hidden\t", asm_out_file);

+	assemble_name (asm_out_file, name);

+	putc ('\n', asm_out_file);

+	ASM_DECLARE_FUNCTION_NAME (asm_out_file, name, decl);

+      }

+    else

+      {

+	switch_to_section (text_section);

+	ASM_OUTPUT_LABEL (asm_out_file, name);

+      }

+

+  DECL_INITIAL (decl) = make_node (BLOCK);

+  current_function_decl = decl;

+  allocate_struct_function (decl, false);

+  init_function_start (decl);

+  /* We're about to hide the function body from callees of final_* by

+     emitting it directly; tell them we're a thunk, if they care.  */

+  cfun->is_thunk = true;

+  first_function_block_is_cold = false;

+  /* Make sure unwind info is emitted for the thunk if needed.  */

+  final_start_function (emit_barrier (), asm_out_file, 1);

+

+  output_indirect_thunk (regno);

+

+  final_end_function ();

+  init_insn_lengths ();

+  free_after_compilation (cfun);

+  set_cfun (NULL);

+  current_function_decl = NULL;

+}

+

 static int pic_labels_used;

 /* Fills in the label name that should be used for a pc thunk for

@@ -8694,11 +8931,24 @@ ix86_code_end (void)

   rtx xops[2];

   int regno;

+  if (indirect_thunk_needed)

+    output_indirect_thunk_function (-1);

+

+  for (regno = FIRST_REX_INT_REG; regno <= LAST_REX_INT_REG; regno++)

+    {

+      int i = regno - FIRST_REX_INT_REG + LAST_INT_REG + 1;

+      if ((indirect_thunks_used & (1 << i)))

+	output_indirect_thunk_function (regno);

+    }

+

   for (regno = AX_REG; regno <= SP_REG; regno++)

     {

       char name[32];

       tree decl;

+      if ((indirect_thunks_used & (1 << regno)))

+	output_indirect_thunk_function (regno);

+

       if (!(pic_labels_used & (1 << regno)))

 	continue;

@@ -24074,12 +24324,250 @@ ix86_expand_call (rtx retval, rtx fnaddr, rtx callarg1,

   return call;

 }

+/* Output indirect branch via a call and return thunk.  CALL_OP is a

+   register which contains the branch target.  XASM is the assembly

+   template for CALL_OP.  Branch is a tail call if SIBCALL_P is true.

+   A normal call is converted to:

+

+	call __x86_indirect_thunk_reg

+

+   and a tail call is converted to:

+

+	jmp __x86_indirect_thunk_reg

+ */

+

+static void

+ix86_output_indirect_branch_via_reg (rtx call_op, bool sibcall_p)

+{

+  char thunk_name_buf[32];

+  char *thunk_name;

+  int regno = REGNO (call_op);

+

+  if (cfun->machine->indirect_branch_type

+      != indirect_branch_thunk_inline)

+    {

+      if (cfun->machine->indirect_branch_type == indirect_branch_thunk)

+	{

+	  int i = regno;

+	  if (i >= FIRST_REX_INT_REG)

+	    i -= (FIRST_REX_INT_REG - LAST_INT_REG - 1);

+	  indirect_thunks_used |= 1 << i;

+	}

+      indirect_thunk_name (thunk_name_buf, regno);

+      thunk_name = thunk_name_buf;

+    }

+  else

+    thunk_name = NULL;

+

+  if (sibcall_p)

+    {

+      if (thunk_name != NULL)

+	fprintf (asm_out_file, "\tjmp\t%s\n", thunk_name);

+      else

+	output_indirect_thunk (regno);

+    }

+  else

+    {

+      if (thunk_name != NULL)

+	{

+	  fprintf (asm_out_file, "\tcall\t%s\n", thunk_name);

+	  return;

+	}

+

+      char indirectlabel1[32];

+      char indirectlabel2[32];

+

+      ASM_GENERATE_INTERNAL_LABEL (indirectlabel1,

+				   INDIRECT_LABEL,

+				   indirectlabelno++);

+      ASM_GENERATE_INTERNAL_LABEL (indirectlabel2,

+				   INDIRECT_LABEL,

+				   indirectlabelno++);

+

+      /* Jump.  */

+      fputs ("\tjmp\t", asm_out_file);

+      assemble_name_raw (asm_out_file, indirectlabel2);

+      fputc ('\n', asm_out_file);

+

+      ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, indirectlabel1);

+

+      if (thunk_name != NULL)

+	fprintf (asm_out_file, "\tjmp\t%s\n", thunk_name);

+      else

+	output_indirect_thunk (regno);

+

+      ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, indirectlabel2);

+

+      /* Call.  */

+      fputs ("\tcall\t", asm_out_file);

+      assemble_name_raw (asm_out_file, indirectlabel1);

+      fputc ('\n', asm_out_file);

+    }

+}

+

+/* Output indirect branch via a call and return thunk.  CALL_OP is

+   the branch target.  XASM is the assembly template for CALL_OP.

+   Branch is a tail call if SIBCALL_P is true.  A normal call is

+   converted to:

+

+	jmp L2

+   L1:

+	push CALL_OP

+	jmp __x86_indirect_thunk

+   L2:

+	call L1

+

+   and a tail call is converted to:

+

+	push CALL_OP

+	jmp __x86_indirect_thunk

+ */

+

+static void

+ix86_output_indirect_branch_via_push (rtx call_op, const char *xasm,

+				      bool sibcall_p)

+{

+  char thunk_name_buf[32];

+  char *thunk_name;

+  char push_buf[64];

+  int regno = -1;

+

+  if (cfun->machine->indirect_branch_type

+      != indirect_branch_thunk_inline)

+    {

+      if (cfun->machine->indirect_branch_type == indirect_branch_thunk)

+	indirect_thunk_needed = true;

+      indirect_thunk_name (thunk_name_buf, regno);

+      thunk_name = thunk_name_buf;

+    }

+  else

+    thunk_name = NULL;

+

+  snprintf (push_buf, sizeof (push_buf), "push{%c}\t%s",

+	    TARGET_64BIT ? 'q' : 'l', xasm);

+

+  if (sibcall_p)

+    {

+      output_asm_insn (push_buf, &call_op);

+      if (thunk_name != NULL)

+	fprintf (asm_out_file, "\tjmp\t%s\n", thunk_name);

+      else

+	output_indirect_thunk (regno);

+    }

+  else

+    {

+      char indirectlabel1[32];

+      char indirectlabel2[32];

+

+      ASM_GENERATE_INTERNAL_LABEL (indirectlabel1,

+				   INDIRECT_LABEL,

+				   indirectlabelno++);

+      ASM_GENERATE_INTERNAL_LABEL (indirectlabel2,

+				   INDIRECT_LABEL,

+				   indirectlabelno++);

+

+      /* Jump.  */

+      fputs ("\tjmp\t", asm_out_file);

+      assemble_name_raw (asm_out_file, indirectlabel2);

+      fputc ('\n', asm_out_file);

+

+      ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, indirectlabel1);

+

+      /* An external function may be called via GOT, instead of PLT.  */

+      if (MEM_P (call_op))

+	{

+	  struct ix86_address parts;

+	  rtx addr = XEXP (call_op, 0);

+	  if (ix86_decompose_address (addr, &parts)

+	      && parts.base == stack_pointer_rtx)

+	    {

+	      /* Since call will adjust stack by -UNITS_PER_WORD,

+		 we must convert "disp(stack, index, scale)" to

+		 "disp+UNITS_PER_WORD(stack, index, scale)".  */

+	      if (parts.index)

+		{

+		  addr = gen_rtx_MULT (Pmode, parts.index,

+				       GEN_INT (parts.scale));

+		  addr = gen_rtx_PLUS (Pmode, stack_pointer_rtx,

+				       addr);

+		}

+	      else

+		addr = stack_pointer_rtx;

+

+	      rtx disp;

+	      if (parts.disp != NULL_RTX)

+		disp = plus_constant (Pmode, parts.disp,

+				      UNITS_PER_WORD);

+	      else

+		disp = GEN_INT (UNITS_PER_WORD);

+

+	      addr = gen_rtx_PLUS (Pmode, addr, disp);

+	      call_op = gen_rtx_MEM (GET_MODE (call_op), addr);

+	    }

+	}

+

+      output_asm_insn (push_buf, &call_op);

+

+      if (thunk_name != NULL)

+	fprintf (asm_out_file, "\tjmp\t%s\n", thunk_name);

+      else

+	output_indirect_thunk (regno);

+

+      ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, indirectlabel2);

+

+      /* Call.  */

+      fputs ("\tcall\t", asm_out_file);

+      assemble_name_raw (asm_out_file, indirectlabel1);

+      fputc ('\n', asm_out_file);

+    }

+}

+

+/* Output indirect branch via a call and return thunk.  CALL_OP is

+   the branch target.  XASM is the assembly template for CALL_OP.

+   Branch is a tail call if SIBCALL_P is true.   */

+

+static void

+ix86_output_indirect_branch (rtx call_op, const char *xasm,

+			     bool sibcall_p)

+{

+  if (REG_P (call_op))

+    ix86_output_indirect_branch_via_reg (call_op, sibcall_p);

+  else

+    ix86_output_indirect_branch_via_push (call_op, xasm, sibcall_p);

+}

+/* Output indirect jump.  CALL_OP is the jump target.  Jump is a

+   function return if RET_P is true.  */

+

+const char *

+ix86_output_indirect_jmp (rtx call_op, bool ret_p)

+{

+  if (cfun->machine->indirect_branch_type != indirect_branch_keep)

+    {

+      struct ix86_frame frame;

+      ix86_compute_frame_layout (&frame);

+

+      /* We can't have red-zone if this isn't a function return since

+	 "call" in the indirect thunk pushes the return address onto

+	 stack, destroying red-zone.  */

+      if (!ret_p && frame.red_zone_size != 0)

+	gcc_unreachable ();

+

+      ix86_output_indirect_branch (call_op, "%0", true);

+      return "";

+    }

+  else

+    return "jmp\t%A0";

+}

+

 /* Output the assembly for a call instruction.  */

 const char *

 ix86_output_call_insn (rtx insn, rtx call_op)

 {

   bool direct_p = constant_call_address_operand (call_op, VOIDmode);

+  bool output_indirect_p

+    = (!TARGET_SEH

+       && cfun->machine->indirect_branch_type != indirect_branch_keep);

   bool seh_nop_p = false;

   const char *xasm;

@@ -24092,9 +24580,17 @@ ix86_output_call_insn (rtx insn, rtx call_op)

       else if (TARGET_SEH)

 	xasm = "rex.W jmp %A0";

       else

-	xasm = "jmp\t%A0";

+	{

+	  if (output_indirect_p)

+	    xasm = "%0";

+	  else

+	    xasm = "jmp\t%A0";

+	}

-      output_asm_insn (xasm, &call_op);

+      if (output_indirect_p && !direct_p)

+	ix86_output_indirect_branch (call_op, xasm, true);

+      else

+	output_asm_insn (xasm, &call_op);

       return "";

     }

@@ -24131,9 +24627,17 @@ ix86_output_call_insn (rtx insn, rtx call_op)

   if (direct_p)

     xasm = "call\t%P0";

   else

-    xasm = "call\t%A0";

+    {

+      if (output_indirect_p)

+	xasm = "%0";

+      else

+	xasm = "call\t%A0";

+    }

-  output_asm_insn (xasm, &call_op);

+  if (output_indirect_p && !direct_p)

+    ix86_output_indirect_branch (call_op, xasm, false);

+  else

+    output_asm_insn (xasm, &call_op);

   if (seh_nop_p)

     return "nop";

@@ -35436,7 +35940,7 @@ ix86_handle_struct_attribute (tree *node, tree name,

 static tree

 ix86_handle_fndecl_attribute (tree *node, tree name,

-                              tree args ATTRIBUTE_UNUSED,

+                              tree args,

                               int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)

 {

   if (TREE_CODE (*node) != FUNCTION_DECL)

@@ -35445,6 +35949,29 @@ ix86_handle_fndecl_attribute (tree *node, tree name,

                name);

       *no_add_attrs = true;

     }

+

+  if (is_attribute_p ("indirect_branch", name))

+    {

+      tree cst = TREE_VALUE (args);

+      if (TREE_CODE (cst) != STRING_CST)

+	{

+	  warning (OPT_Wattributes,

+		   "%qE attribute requires a string constant argument",

+		   name);

+	  *no_add_attrs = true;

+	}

+      else if (strcmp (TREE_STRING_POINTER (cst), "keep") != 0

+	       && strcmp (TREE_STRING_POINTER (cst), "thunk") != 0

+	       && strcmp (TREE_STRING_POINTER (cst), "thunk-inline") != 0

+	       && strcmp (TREE_STRING_POINTER (cst), "thunk-extern") != 0)

+	{

+	  warning (OPT_Wattributes,

+		   "argument to %qE attribute is not "

+		   "(keep|thunk|thunk-inline|thunk-extern)", name);

+	  *no_add_attrs = true;

+	}

+    }

+

   return NULL_TREE;

 }

@@ -38963,6 +39490,8 @@ static const struct attribute_spec ix86_attribute_table[] =

     false },

   { "callee_pop_aggregate_return", 1, 1, false, true, true,

     ix86_handle_callee_pop_aggregate_return, true },

+  { "indirect_branch", 1, 1, true, false, false,

+    ix86_handle_fndecl_attribute, false },

   /* End element.  */

   { NULL,        0, 0, false, false, false, NULL, false }

 };

diff --git a/gcc/config/i386/i386.h b/gcc/config/i386/i386.h

index 87fd381..8183cee7 100644

--- a/gcc/config/i386/i386.h

+++ b/gcc/config/i386/i386.h

@@ -2322,6 +2322,13 @@ struct GTY(()) machine_function {

      stack below the return address.  */

   BOOL_BITFIELD static_chain_on_stack : 1;

+  /* How to generate indirec branch.  */

+  ENUM_BITFIELD(indirect_branch) indirect_branch_type : 3;

+

+  /* If true, the current function has local indirect jumps, like

+     "indirect_jump" or "tablejump".  */

+  BOOL_BITFIELD has_local_indirect_jump : 1;

+

   /* During prologue/epilogue generation, the current frame state.

      Otherwise, the frame state at the end of the prologue.  */

   struct machine_frame_state fs;

diff --git a/gcc/config/i386/i386.md b/gcc/config/i386/i386.md

index e09e961..b943849 100644

--- a/gcc/config/i386/i386.md

+++ b/gcc/config/i386/i386.md

@@ -11276,13 +11276,18 @@

 {

   if (TARGET_X32)

     operands[0] = convert_memory_address (word_mode, operands[0]);

+  cfun->machine->has_local_indirect_jump = true;

 })

 (define_insn "*indirect_jump"

   [(set (pc) (match_operand:W 0 "indirect_branch_operand" "rw"))]

   ""

-  "jmp\t%A0"