diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c
index f958b16..8f0111a 100644
--- a/gcc/config/i386/i386.c
+++ b/gcc/config/i386/i386.c
@@ -4260,6 +4260,12 @@
 
   if (TARGET_64BIT)
     {
+      /* Usually x86-64 does not have attributes so they warn here, but
+         we have added an attribute pnaclcall so allow that.  */
+      if (is_attribute_p ("pnaclcall", name))
+        /* Ignore the other i386 attributes and return.  */
+        return NULL_TREE;
+
       /* Do not warn when emulating the MS ABI.  */
       if (TREE_CODE (*node) != FUNCTION_TYPE || ix86_function_type_abi (*node)!=MS_ABI)
 	warning (OPT_Wattributes, "%qs attribute ignored",
@@ -4343,6 +4349,11 @@
       != !lookup_attribute ("sseregparm", TYPE_ATTRIBUTES (type2)))
     return 0;
 
+  /* Check for mismatched pnaclcall types.  */
+  if (!lookup_attribute ("pnaclcall", TYPE_ATTRIBUTES (type1))
+      != !lookup_attribute ("pnaclcall", TYPE_ATTRIBUTES (type2)))
+    return 0;
+
   /* Check for mismatched return types (cdecl vs stdcall).  */
   if (!lookup_attribute (rtdstr, TYPE_ATTRIBUTES (type1))
       != !lookup_attribute (rtdstr, TYPE_ATTRIBUTES (type2)))
@@ -4685,6 +4696,19 @@
 /* regclass.c  */
 extern void init_regs (void);
 
+/* Return true if the function is decorated with a pnaclcall attribute.  */
+static bool is_pnaclcall(const_tree fntype)
+{
+  return (fntype && lookup_attribute ("pnaclcall", TYPE_ATTRIBUTES (fntype)));
+}
+
+static bool ix86_cfun_pnaclcall (void)
+{
+  if (! cfun )
+    return 0;
+  return cfun->machine->pnaclcall;
+}
+
 /* Implementation of call abi switching target hook. Specific to FNDECL
    the specific call register sets are set. See also CONDITIONAL_REGISTER_USAGE
    for more details.  */
@@ -4692,9 +4716,15 @@
 ix86_call_abi_override (const_tree fndecl)
 {
   if (fndecl == NULL_TREE)
-    cfun->machine->call_abi = DEFAULT_ABI;
+    {
+      cfun->machine->call_abi = DEFAULT_ABI;
+      cfun->machine->pnaclcall = 0;
+    }
   else
-    cfun->machine->call_abi = ix86_function_type_abi (TREE_TYPE (fndecl));
+    {
+      cfun->machine->call_abi = ix86_function_type_abi (TREE_TYPE (fndecl));
+      cfun->machine->pnaclcall = is_pnaclcall (TREE_TYPE (fndecl));
+    }
 }
 
 /* MS and SYSV ABI have different set of call used registers.  Avoid expensive
@@ -4765,6 +4795,9 @@
 		      ? (!prototype_p (fntype) || stdarg_p (fntype))
 		      : !libname);
 
+  if (TARGET_64BIT)
+    cum->pnaclcall = is_pnaclcall (fntype);
+
   if (!TARGET_64BIT)
     {
       /* If there are variable arguments, then we won't pass anything
@@ -4946,7 +4979,8 @@
 
 static int
 classify_argument (enum machine_mode mode, const_tree type,
-		   enum x86_64_reg_class classes[MAX_CLASSES], int bit_offset)
+		   enum x86_64_reg_class classes[MAX_CLASSES], int bit_offset,
+		   bool is_pnacl_cconv)
 {
   HOST_WIDE_INT bytes =
     (mode == BLKmode) ? int_size_in_bytes (type) : (int) GET_MODE_SIZE (mode);
@@ -4966,6 +5000,10 @@
       tree field;
       enum x86_64_reg_class subclasses[MAX_CLASSES];
 
+      /* Pass aggregates on the stack for PNaCl. */
+      if (TARGET_PNACL_CCONV || is_pnacl_cconv)
+	return 0;
+
       /* On x86-64 we pass structures larger than 32 bytes on the stack.  */
       if (bytes > 32)
 	return 0;
@@ -5035,7 +5073,8 @@
 		      num = classify_argument (TYPE_MODE (type), type,
 					       subclasses,
 					       (int_bit_position (field)
-						+ bit_offset) % 256);
+						+ bit_offset) % 256,
+						is_pnacl_cconv);
 		      if (!num)
 			return 0;
 		      for (i = 0; i < num; i++)
@@ -5055,7 +5094,8 @@
 	  {
 	    int num;
 	    num = classify_argument (TYPE_MODE (TREE_TYPE (type)),
-				     TREE_TYPE (type), subclasses, bit_offset);
+				     TREE_TYPE (type), subclasses, bit_offset,
+				     is_pnacl_cconv);
 	    if (!num)
 	      return 0;
 
@@ -5086,7 +5126,8 @@
 
 		  num = classify_argument (TYPE_MODE (TREE_TYPE (field)),
 					   TREE_TYPE (field), subclasses,
-					   bit_offset);
+					   bit_offset,
+					   is_pnacl_cconv);
 		  if (!num)
 		    return 0;
 		  for (i = 0; i < num; i++)
@@ -5327,10 +5368,10 @@
    class.  Return 0 iff parameter should be passed in memory.  */
 static int
 examine_argument (enum machine_mode mode, const_tree type, int in_return,
-		  int *int_nregs, int *sse_nregs)
+		     int *int_nregs, int *sse_nregs, bool is_pnacl_cconv)
 {
   enum x86_64_reg_class regclass[MAX_CLASSES];
-  int n = classify_argument (mode, type, regclass, 0);
+  int n = classify_argument (mode, type, regclass, 0, is_pnacl_cconv);
 
   *int_nregs = 0;
   *sse_nregs = 0;
@@ -5370,7 +5411,7 @@
 static rtx
 construct_container (enum machine_mode mode, enum machine_mode orig_mode,
 		     const_tree type, int in_return, int nintregs, int nsseregs,
-		     const int *intreg, int sse_regno)
+		     const int *intreg, int sse_regno, bool is_pnacl_cconv)
 {
   /* The following variables hold the static issued_error state.  */
   static bool issued_sse_arg_error;
@@ -5388,11 +5429,11 @@
   rtx exp[MAX_CLASSES];
   rtx ret;
 
-  n = classify_argument (mode, type, regclass, 0);
+  n = classify_argument (mode, type, regclass, 0, is_pnacl_cconv);
   if (!n)
     return NULL;
   if (!examine_argument (mode, type, in_return, &needed_intregs,
-			 &needed_sseregs))
+			 &needed_sseregs, is_pnacl_cconv))
     return NULL;
   if (needed_intregs > nintregs || needed_sseregs > nsseregs)
     return NULL;
@@ -5666,7 +5707,7 @@
   if (!named && VALID_AVX256_REG_MODE (mode))
     return;
 
-  if (!examine_argument (mode, type, 0, &int_nregs, &sse_nregs))
+  if (!examine_argument (mode, type, 0, &int_nregs, &sse_nregs, cum->pnaclcall))
     cum->words += words;
   else if (sse_nregs <= cum->sse_nregs && int_nregs <= cum->nregs)
     {
@@ -5882,7 +5923,7 @@
   return construct_container (mode, orig_mode, type, 0, cum->nregs,
 			      cum->sse_nregs,
 			      &x86_64_int_parameter_registers [cum->regno],
-			      cum->sse_regno);
+			      cum->sse_regno, cum->pnaclcall);
 }
 
 static rtx
@@ -6180,7 +6221,7 @@
 
 static rtx
 function_value_64 (enum machine_mode orig_mode, enum machine_mode mode,
-		   const_tree valtype)
+		   const_tree valtype, bool is_pnacl_cconv)
 {
   rtx ret;
 
@@ -6210,7 +6251,7 @@
 
   ret = construct_container (mode, orig_mode, valtype, 1,
 			     X86_64_REGPARM_MAX, X86_64_SSE_REGPARM_MAX,
-			     x86_64_int_return_registers, 0);
+			     x86_64_int_return_registers, 0, is_pnacl_cconv);
 
   /* For zero sized structures, construct_container returns NULL, but we
      need to keep rest of compiler happy by returning meaningful value.  */
@@ -6260,7 +6301,7 @@
   if (TARGET_64BIT && ix86_function_type_abi (fntype) == MS_ABI)
     return function_value_ms_64 (orig_mode, mode);
   else if (TARGET_64BIT)
-    return function_value_64 (orig_mode, mode, valtype);
+    return function_value_64 (orig_mode, mode, valtype, is_pnaclcall (fntype));
   else
     return function_value_32 (orig_mode, mode, fntype, fn);
 }
@@ -6330,10 +6371,12 @@
 }
 
 static int ATTRIBUTE_UNUSED
-return_in_memory_64 (const_tree type, enum machine_mode mode)
+return_in_memory_64 (const_tree type, enum machine_mode mode,
+		   bool is_pnacl_cconv)
 {
   int needed_intregs, needed_sseregs;
-  return !examine_argument (mode, type, 1, &needed_intregs, &needed_sseregs);
+  return !examine_argument (mode, type, 1, &needed_intregs, &needed_sseregs,
+		   is_pnacl_cconv);
 }
 
 static int ATTRIBUTE_UNUSED
@@ -6363,7 +6406,9 @@
       if (ix86_function_type_abi (fntype) == MS_ABI)
 	return return_in_memory_ms_64 (type, mode);
       else
-	return return_in_memory_64 (type, mode);
+	/* NOTE: fntype was meant to be unused, but we need to know
+	   if a call was a pnaclcall.  */
+	return return_in_memory_64 (type, mode, is_pnaclcall (fntype));
     }
   else
     return return_in_memory_32 (type, mode);
@@ -6382,7 +6427,7 @@
   enum machine_mode mode = type_natural_mode (type, NULL);
 
   if (TARGET_64BIT)
-    return return_in_memory_64 (type, mode);
+    return return_in_memory_64 (type, mode, is_pnaclcall (fntype));
 
   if (mode == BLKmode)
     return 1;
@@ -6927,7 +6972,7 @@
       container = construct_container (nat_mode, TYPE_MODE (type),
 				       type, 0, X86_64_REGPARM_MAX,
 				       X86_64_SSE_REGPARM_MAX, intreg,
-				       0);
+				       0, ix86_cfun_pnaclcall());
       break;
     }
 
@@ -6945,7 +6990,8 @@
       lab_false = create_artificial_label ();
       lab_over = create_artificial_label ();
 
-      examine_argument (nat_mode, type, 0, &needed_intregs, &needed_sseregs);
+      examine_argument (nat_mode, type, 0, &needed_intregs, &needed_sseregs,
+				       ix86_cfun_pnaclcall());
 
       need_temp = (!REG_P (container)
 		   && ((needed_intregs && TYPE_ALIGN (type) > 64)
@@ -30159,6 +30205,8 @@
   { "fastcall",  0, 0, false, true,  true,  ix86_handle_cconv_attribute },
   /* Cdecl attribute says the callee is a normal C declaration */
   { "cdecl",     0, 0, false, true,  true,  ix86_handle_cconv_attribute },
+  /* pnaclcall attribute says we are using the PNaCl x86_64 calling conv. */
+  { "pnaclcall", 0, 0, false, true, true, ix86_handle_cconv_attribute },
   /* Regparm attribute specifies how many integer arguments are to be
      passed in registers.  */
   { "regparm",   1, 1, false, true,  true,  ix86_handle_cconv_attribute },
diff --git a/gcc/config/i386/i386.h b/gcc/config/i386/i386.h
index 23c0d18..debcc27 100644
--- a/gcc/config/i386/i386.h
+++ b/gcc/config/i386/i386.h
@@ -1572,6 +1572,7 @@
   int nregs;			/* # registers available for passing */
   int regno;			/* next available register number */
   int fastcall;			/* fastcall calling convention is used */
+  int pnaclcall;		/* pnaclcall calling convention is used */
   int sse_words;		/* # sse words passed so far */
   int sse_nregs;		/* # sse registers available for passing */
   int warn_avx;			/* True when we want to warn about AVX ABI.  */
@@ -2404,6 +2405,8 @@
   /* This value is used for amd64 targets and specifies the current abi
      to be used. MS_ABI means ms abi. Otherwise SYSV_ABI means sysv abi.  */
   int call_abi;
+  /* Indicates whether or not the function was declared as pnaclcall.  */
+  int pnaclcall;
 };
 
 #define ix86_stack_locals (cfun->machine->stack_locals)
diff --git a/gcc/config/i386/nacl.opt b/gcc/config/i386/nacl.opt
index 2b91522..e0622f9 100644
--- a/gcc/config/i386/nacl.opt
+++ b/gcc/config/i386/nacl.opt
@@ -22,3 +22,8 @@
 mtls-use-call
 Target Var(TARGET_TLS_USE_CALL) Init(0)
 Use a function call rather than direct segment register access for TLS
+
+mpnacl-cconv
+Target Var(TARGET_PNACL_CCONV) Init(0)
+Use the PNaCl calling convention on x86-64 and pass by-value structures
+and unions on the stack instead of registers.
diff --git a/gcc/function.c b/gcc/function.c
index d582fea..329e75a 100644
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -1826,6 +1826,27 @@
  }
 };
 
+/* HACK: If |maybe_call| is a call expression, grab additional type attributes
+   from the expression (e.g., from a function pointer type) which may not
+   have been present in a function decl.  This must NOT affect the original
+   function type/decl, so make a copy if it really changed.  We may be able
+   to narrow this hack to just propagate the "pnaclcall" attribute.  */
+static tree copy_attributes_if_call (const_tree maybe_call, const_tree fntype) {
+  if (TREE_CODE (maybe_call) == CALL_EXPR)
+    {
+      tree new_attributes = merge_type_attributes(fntype,
+		  TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (maybe_call))));
+      if (!attribute_list_equal (TYPE_ATTRIBUTES (fntype), new_attributes))
+		{
+          tree new_fntype = copy_node (fntype);
+          TYPE_ATTRIBUTES (new_fntype) = new_attributes;
+          return new_fntype;
+	    }
+      return fntype;
+    }
+  return fntype;
+}
+
 
 /* Return 1 if EXP is an aggregate type (or a value with aggregate type).
    This means a type for which function calls must pass an address to the
@@ -1853,10 +1874,14 @@
 	fntype = (fndecl
 		  ? TREE_TYPE (fndecl)
 		  : TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (fntype))));
+	/* HACK to grab attributes from the callexp type as well as the decl.  */
+	fntype = copy_attributes_if_call (exp, fntype);
 	break;
       case FUNCTION_DECL:
 	fndecl = fntype;
 	fntype = TREE_TYPE (fndecl);
+	/* HACK to grab attributes from the callexp type as well as the decl.  */
+	fntype = copy_attributes_if_call (exp, fntype);
 	break;
       case FUNCTION_TYPE:
       case METHOD_TYPE: