This is the mail archive of the gcc-patches@gcc.gnu.org mailing list for the GCC project.


Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]
Other format: [Raw text]

[gomp4, 18/23] Implicit address spaces


This adds two hooks to determine address spaces for local and global
variables, and changes various places in the compiler to ensure stuff
goes to the right place.

If a type is given an address space in this way, the
TYPE_QUAL_AS_IMPLICIT is set. Such a flag is needed to properly handle
such types in situations like passing them to varargs and old-style
functions, and to make typeof behave as expected.

	gcc/c-family/
	* c-common.c (c_common_nodes_and_builtins): If globals need to go into
	a specific address space, rebuild the char array type nodes
	accordingly.

	gcc/c/
	* c-decl.c (start_function): Make the result live in the for_frame
	address space.
	(build_compound_literal): Choose an appropriate address
	space.
	(grokdeclarator): If no address space is specified, use the frame or
	global address space implicitly.
	* c-parser.c (c_parser_typeof_specifier): If it is set, drop the
	address space from the returned type.
	* c-typeck.c (convert_arguments): If we have no type, and a pointer arg
	which points to a type with implicit address space, convert the pointer
	so as to point to the generic address space.

	gcc/
	* target.def (for_frame, for_global): New hooks in addr_space.
	* cfgexpand.c (expand_one_stack_var_at): Use the frame address space.
	* emit-rtl.c (gen_frame_mem): Likewise.
	* function.c (assign_stack_local_1, assign_stack_temp_for_type):
	Likewise.
	(assign_parms_augmented_arg_list, assign_parms_find_data_types):
	Use build_pointer_type_in_frame.
	* calls.c (initialize_argument_information): When we make a copy,
	ensure the decl for it has the for_frame address space.
	* targhooks.c (std_gimplify_va_arg_expr): If an arg is passed by
	reference, assume it lives in the for_frame address space if that
	isn't the generic one.
	* tree-core.h (struct tree_base): Take a new as_implicit_flag out of
	spare0.
	(enum cv_qualifier): Add TYPE_QUAL_AS_IMPLICIT.
	* tree.h (build_pointer_type_in_frame): Declare.
	(TYPE_AS_IMPLICIT): New macro.
	(TYPE_QUALS): Take TYPE_QUAL_AS_IMPLICIT into account.
	* tree.c (set_type_quals): Likewise.
	(build_pointer_type_in_frame): New function.
	* targhooks.c (hook_return_generic_addr_space): New function.
	(hook_return_generic_addr_space_bool): New function.
	* targhooks.h (hook_return_generic_addr_space,
	(hook_return_generic_addr_space_bool): Declare.
	* tree-switch-conversion.c: Include "target.h".
	(build_one_array): Use the for_global hook to determine address space.
	* varasm.c (build_constant_desc): Likewise.
	* doc/tm.texi.in (TARGET_ADDR_SPACE_FOR_FRAME,
	TARGET_ADDR_SPACE_FOR_GLOBAL): Add hooks.
	* doc/tm.texi: Regenerate.

------------------------------------------------------------------------
Index: gcc/doc/tm.texi
===================================================================
--- gcc/doc/tm.texi.orig
+++ gcc/doc/tm.texi
@@ -10330,6 +10330,17 @@ guaranteed that one of the two address s
 as determined by the @code{TARGET_ADDR_SPACE_SUBSET_P} target hook.
 @end deftypefn
 
+@deftypefn {Target Hook} addr_space_t TARGET_ADDR_SPACE_FOR_FRAME (void)
+Define this if memory locations in the stack frame should use a different
+address space than the default. It returns the address space to use.
+@end deftypefn
+
+@deftypefn {Target Hook} addr_space_t TARGET_ADDR_SPACE_FOR_GLOBAL (bool @var{constp})
+Define this if global memory locations should use a different
+address space than the default. It returns the address space to use.
+If @var{constp} is nonzero, the variable will be constant.
+@end deftypefn
+
 @node Misc
 @section Miscellaneous Parameters
 @cindex parameters, miscellaneous
Index: gcc/doc/tm.texi.in
===================================================================
--- gcc/doc/tm.texi.in.orig
+++ gcc/doc/tm.texi.in
@@ -7669,6 +7669,10 @@ c_register_addr_space ("__ea", ADDR_SPAC
 
 @hook TARGET_ADDR_SPACE_CONVERT
 
+@hook TARGET_ADDR_SPACE_FOR_FRAME
+
+@hook TARGET_ADDR_SPACE_FOR_GLOBAL
+
 @node Misc
 @section Miscellaneous Parameters
 @cindex parameters, miscellaneous
Index: gcc/targhooks.c
===================================================================
--- gcc/targhooks.c.orig
+++ gcc/targhooks.c
@@ -1642,7 +1642,17 @@ std_gimplify_va_arg_expr (tree valist, t
 
   indirect = pass_by_reference (NULL, TYPE_MODE (type), type, false);
   if (indirect)
-    type = build_pointer_type (type);
+    {
+      /* We assume that if there is a frame address space, the caller makes
+	 a copy.  */
+      addr_space_t as = targetm.addr_space.for_frame ();
+      if (!ADDR_SPACE_GENERIC_P (as))
+	type
+	  = build_qualified_type (type,
+				  TYPE_QUALS_NO_ADDR_SPACE (type)
+				  | ENCODE_QUAL_ADDR_SPACE (as));
+      type = build_pointer_type (type);
+    }
 
   align = PARM_BOUNDARY / BITS_PER_UNIT;
   boundary = targetm.calls.function_arg_boundary (TYPE_MODE (type), type);
@@ -1750,4 +1760,16 @@ can_use_doloop_if_innermost (double_int,
   return loop_depth == 1;
 }
 
+addr_space_t
+hook_return_generic_addr_space (void)
+{
+  return ADDR_SPACE_GENERIC;
+}
+
+addr_space_t
+hook_return_generic_addr_space_bool (bool)
+{
+  return ADDR_SPACE_GENERIC;
+}
+
 #include "gt-targhooks.h"
Index: gcc/targhooks.h
===================================================================
--- gcc/targhooks.h.orig
+++ gcc/targhooks.h
@@ -164,6 +164,9 @@ extern rtx default_addr_space_legitimize
 						  addr_space_t);
 extern bool default_addr_space_subset_p (addr_space_t, addr_space_t);
 extern rtx default_addr_space_convert (rtx, tree, tree);
+extern addr_space_t hook_return_generic_addr_space (void);
+extern addr_space_t hook_return_generic_addr_space_bool (bool);
+
 extern unsigned int default_case_values_threshold (void);
 extern bool default_have_conditional_execution (void);
 
Index: gcc/c-family/c-common.c
===================================================================
--- gcc/c-family/c-common.c.orig
+++ gcc/c-family/c-common.c
@@ -5560,6 +5560,23 @@ c_common_nodes_and_builtins (void)
   char32_array_type_node
     = build_array_type (char32_type_node, array_domain_type);
 
+  addr_space_t as = targetm.addr_space.for_global (true);
+  if (!ADDR_SPACE_GENERIC_P (as))
+    {
+      int quals = ENCODE_QUAL_ADDR_SPACE (as) | TYPE_QUAL_AS_IMPLICIT;
+      char_array_type_node
+	= build_array_type (build_qualified_type (char_type_node, quals),
+			    array_domain_type);
+      char16_array_type_node
+	= build_array_type (build_qualified_type (char16_type_node, quals),
+			    array_domain_type);
+      char32_array_type_node
+	= build_array_type (build_qualified_type (char32_type_node, quals),
+			    array_domain_type);
+      wchar_array_type_node
+	= build_array_type (build_qualified_type (wchar_type_node, quals),
+			    array_domain_type);
+    }
   wint_type_node =
     TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
 
Index: gcc/c/c-parser.c
===================================================================
--- gcc/c/c-parser.c.orig
+++ gcc/c/c-parser.c
@@ -2994,6 +2994,9 @@ c_parser_typeof_specifier (c_parser *par
 	error_at (here, "%<typeof%> applied to a bit-field");
       mark_exp_read (expr.value);
       ret.spec = TREE_TYPE (expr.value);
+      if (ret.spec != error_mark_node && TYPE_AS_IMPLICIT (ret.spec))
+	ret.spec = build_qualified_type (ret.spec,
+					 TYPE_QUALS_NO_ADDR_SPACE (ret.spec));
       was_vm = variably_modified_type_p (ret.spec, NULL_TREE);
       /* This is returned with the type so that when the type is
 	 evaluated, this can be evaluated.  */
Index: gcc/c/c-typeck.c
===================================================================
--- gcc/c/c-typeck.c.orig
+++ gcc/c/c-typeck.c
@@ -3312,8 +3312,19 @@ convert_arguments (tree typelist, vec<tr
 	  return -1;
 	}
       else
-	/* Convert `short' and `char' to full-size `int'.  */
-	parmval = default_conversion (val);
+	{
+	  if (POINTER_TYPE_P (valtype)
+	      && TYPE_AS_IMPLICIT (TREE_TYPE (valtype)))
+	    {
+	      tree basetype = TREE_TYPE (valtype);
+	      int quals = TYPE_QUALS_NO_ADDR_SPACE (basetype);
+	      basetype = build_qualified_type (basetype, quals);
+	      basetype = build_pointer_type (basetype);
+	      val = convert (basetype, val);
+	    }
+	  /* Convert `short' and `char' to full-size `int'.  */
+	  parmval = default_conversion (val);
+	}
 
       (*values)[parmnum] = parmval;
       if (parmval == error_mark_node)
Index: gcc/c/c-decl.c
===================================================================
--- gcc/c/c-decl.c.orig
+++ gcc/c/c-decl.c
@@ -4665,6 +4665,17 @@ build_compound_literal (location_t loc,
       || init == error_mark_node)
     return error_mark_node;
 
+  addr_space_t as;
+  if (current_function_decl)
+    as = targetm.addr_space.for_frame ();
+  else
+    as = targetm.addr_space.for_global (!non_const);
+  if (!ADDR_SPACE_GENERIC_P (as)
+      && ADDR_SPACE_GENERIC_P (TYPE_ADDR_SPACE (type)))
+    type = build_qualified_type (type,
+				 (TYPE_QUALS_NO_ADDR_SPACE (type)
+				  | ENCODE_QUAL_ADDR_SPACE (as)));
+
   decl = build_decl (loc, VAR_DECL, NULL_TREE, type);
   DECL_EXTERNAL (decl) = 0;
   TREE_PUBLIC (decl) = 0;
@@ -5850,6 +5861,33 @@ grokdeclarator (const struct c_declarato
 		   c_addr_space_name (address_space));
 	}
     }
+  else if ((current_function_scope
+	    || (decl_context == PARM
+		&& TREE_CODE (type) != ARRAY_TYPE
+		&& TREE_CODE (type) != VOID_TYPE))
+	   && (storage_class == csc_auto || storage_class == csc_none)
+	   && decl_context != TYPENAME)
+    {
+      addr_space_t new_as = targetm.addr_space.for_frame ();
+      if (!ADDR_SPACE_GENERIC_P (new_as))
+	type_quals = (CLEAR_QUAL_ADDR_SPACE (type_quals)
+		      | TYPE_QUAL_AS_IMPLICIT
+		      | ENCODE_QUAL_ADDR_SPACE (new_as));
+    }
+  else if ((!current_function_scope
+	    || storage_class == csc_static
+	    || storage_class == csc_extern)
+	   && decl_context == NORMAL
+	   && declarator->kind != cdk_function
+	   && storage_class != csc_typedef)
+    {
+      bool is_const = (type_quals & TYPE_QUAL_CONST) != 0;
+      addr_space_t new_as = targetm.addr_space.for_global (is_const);
+      if (!ADDR_SPACE_GENERIC_P (new_as))
+	type_quals = (CLEAR_QUAL_ADDR_SPACE (type_quals)
+		      | TYPE_QUAL_AS_IMPLICIT
+		      | ENCODE_QUAL_ADDR_SPACE (new_as));
+    }
 
   /* Check the type and width of a bit-field.  */
   if (bitfield)
@@ -8024,6 +8062,12 @@ start_function (struct c_declspecs *decl
   declare_parm_level ();
 
   restype = TREE_TYPE (TREE_TYPE (current_function_decl));
+  addr_space_t as = targetm.addr_space.for_frame ();
+  if (!ADDR_SPACE_GENERIC_P (as))
+    restype
+      = build_qualified_type (restype,
+			      TYPE_QUALS_NO_ADDR_SPACE (restype)
+			      | ENCODE_QUAL_ADDR_SPACE (as));
   resdecl = build_decl (loc, RESULT_DECL, NULL_TREE, restype);
   DECL_ARTIFICIAL (resdecl) = 1;
   DECL_IGNORED_P (resdecl) = 1;
Index: gcc/target.def
===================================================================
--- gcc/target.def.orig
+++ gcc/target.def
@@ -3017,6 +3017,21 @@ as determined by the @code{TARGET_ADDR_S
  rtx, (rtx op, tree from_type, tree to_type),
  default_addr_space_convert)
 
+DEFHOOK
+(for_frame,
+ "Define this if memory locations in the stack frame should use a different\n\
+address space than the default. It returns the address space to use.",
+ addr_space_t, (void),
+ hook_return_generic_addr_space)
+
+DEFHOOK
+(for_global,
+ "Define this if global memory locations should use a different\n\
+address space than the default. It returns the address space to use.\n\
+If @var{constp} is nonzero, the variable will be constant.",
+ addr_space_t, (bool constp),
+ hook_return_generic_addr_space_bool)
+
 HOOK_VECTOR_END (addr_space)
 
 #undef HOOK_PREFIX
Index: gcc/tree.c
===================================================================
--- gcc/tree.c.orig
+++ gcc/tree.c
@@ -6078,6 +6078,7 @@ set_type_quals (tree type, int type_qual
   TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
   TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
   TYPE_ATOMIC (type) = (type_quals & TYPE_QUAL_ATOMIC) != 0;
+  TYPE_AS_IMPLICIT (type) = (type_quals & TYPE_QUAL_AS_IMPLICIT) != 0;
   TYPE_ADDR_SPACE (type) = DECODE_QUAL_ADDR_SPACE (type_quals);
 }
 
@@ -7581,6 +7582,22 @@ build_pointer_type (tree to_type)
   return build_pointer_type_for_mode (to_type, pointer_mode, false);
 }
 
+/* Like build_pointer_type, but adjust the address space of the resulting
+   pointer type as appropriate for an object living in the stack frame.  */
+
+tree
+build_pointer_type_in_frame (tree to_type)
+{
+  tree type = build_pointer_type (to_type);
+  addr_space_t as = targetm.addr_space.for_frame ();
+  if (!ADDR_SPACE_GENERIC_P (as))
+    type
+      = build_qualified_type (type,
+			      TYPE_QUALS_NO_ADDR_SPACE (type)
+			      | ENCODE_QUAL_ADDR_SPACE (as));
+  return type;
+}
+
 /* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE.  */
 
 tree
Index: gcc/tree.h
===================================================================
--- gcc/tree.h.orig
+++ gcc/tree.h
@@ -1628,6 +1628,11 @@ extern void protected_set_expr_location
 /* If nonzero, type's name shouldn't be emitted into debug info.  */
 #define TYPE_NAMELESS(NODE) (TYPE_CHECK (NODE)->base.u.bits.nameless_flag)
 
+/* If nonzero, the address space was chosen implicitly due to target
+   requirements.  */
+#define TYPE_AS_IMPLICIT(NODE) \
+  (TYPE_CHECK (NODE)->base.u.bits.as_implicit_flag)
+
 /* The address space the type is in.  */
 #define TYPE_ADDR_SPACE(NODE) (TYPE_CHECK (NODE)->base.u.bits.address_space)
 
@@ -1649,6 +1654,7 @@ extern void protected_set_expr_location
 	  | (TYPE_VOLATILE (NODE) * TYPE_QUAL_VOLATILE)		\
 	  | (TYPE_ATOMIC (NODE) * TYPE_QUAL_ATOMIC)		\
 	  | (TYPE_RESTRICT (NODE) * TYPE_QUAL_RESTRICT)		\
+	  | (TYPE_AS_IMPLICIT (NODE) * TYPE_QUAL_AS_IMPLICIT)	\
 	  | (ENCODE_QUAL_ADDR_SPACE (TYPE_ADDR_SPACE (NODE)))))
 
 /* The same as TYPE_QUALS without the address space qualifications.  */
@@ -3604,6 +3610,7 @@ extern tree unsigned_type_for (tree);
 extern tree truth_type_for (tree);
 extern tree build_pointer_type_for_mode (tree, enum machine_mode, bool);
 extern tree build_pointer_type (tree);
+extern tree build_pointer_type_in_frame (tree);
 extern tree build_reference_type_for_mode (tree, enum machine_mode, bool);
 extern tree build_reference_type (tree);
 extern tree build_vector_type_for_mode (tree, enum machine_mode);
Index: gcc/function.c
===================================================================
--- gcc/function.c.orig
+++ gcc/function.c
@@ -478,6 +478,7 @@ assign_stack_local_1 (enum machine_mode
 
   x = gen_rtx_MEM (mode, addr);
   set_mem_align (x, alignment_in_bits);
+  set_mem_addr_space (x, targetm.addr_space.for_frame ());
   MEM_NOTRAP_P (x) = 1;
 
   stack_slot_list
@@ -886,6 +887,7 @@ assign_stack_temp_for_type (enum machine
 
   /* Create a new MEM rtx to avoid clobbering MEM flags of old slots.  */
   slot = gen_rtx_MEM (mode, XEXP (p->slot, 0));
+  set_mem_addr_space (slot, targetm.addr_space.for_frame ());
   stack_slot_list = gen_rtx_EXPR_LIST (VOIDmode, slot, stack_slot_list);
 
   /* If we know the alias set for the memory that will be used, use
@@ -2299,7 +2301,7 @@ assign_parms_augmented_arg_list (struct
       && ! cfun->returns_pcc_struct
       && targetm.calls.struct_value_rtx (TREE_TYPE (fndecl), 1) == 0)
     {
-      tree type = build_pointer_type (TREE_TYPE (fntype));
+      tree type = build_pointer_type_in_frame (TREE_TYPE (fntype));
       tree decl;
 
       decl = build_decl (DECL_SOURCE_LOCATION (fndecl),
@@ -2381,7 +2383,7 @@ assign_parm_find_data_types (struct assi
   if (pass_by_reference (&all->args_so_far_v, passed_mode,
 			 passed_type, data->named_arg))
     {
-      passed_type = nominal_type = build_pointer_type (passed_type);
+      passed_type = nominal_type = build_pointer_type_in_frame (passed_type);
       data->passed_pointer = true;
       passed_mode = nominal_mode = TYPE_MODE (nominal_type);
     }
Index: gcc/calls.c
===================================================================
--- gcc/calls.c.orig
+++ gcc/calls.c
@@ -1270,6 +1270,13 @@ initialize_argument_information (int num
 	      if (!callee_copies && *ecf_flags & ECF_PURE)
 		*ecf_flags &= ~(ECF_PURE | ECF_LOOPING_CONST_OR_PURE);
 
+	      addr_space_t as = MEM_ADDR_SPACE (copy);
+	      if (!ADDR_SPACE_GENERIC_P (as))
+		type
+		  = build_qualified_type (type,
+					  TYPE_QUALS_NO_ADDR_SPACE (type)
+					  | ENCODE_QUAL_ADDR_SPACE (as));
+
 	      args[i].tree_value
 		= build_fold_addr_expr_loc (loc, make_tree (type, copy));
 	      type = TREE_TYPE (args[i].tree_value);
Index: gcc/emit-rtl.c
===================================================================
--- gcc/emit-rtl.c.orig
+++ gcc/emit-rtl.c
@@ -662,12 +662,13 @@ gen_frame_mem (enum machine_mode mode, r
   rtx mem = gen_rtx_MEM (mode, addr);
   MEM_NOTRAP_P (mem) = 1;
   set_mem_alias_set (mem, get_frame_alias_set ());
+  set_mem_addr_space (mem, targetm.addr_space.for_frame ());
   return mem;
 }
 
 /* Generate a MEM referring to a temporary use of the stack, not part
-    of the fixed stack frame.  For example, something which is pushed
-    by a target splitter.  */
+   of the fixed stack frame.  For example, something which is pushed
+   by a target splitter.  */
 rtx
 gen_tmp_stack_mem (enum machine_mode mode, rtx addr)
 {
Index: gcc/cfgexpand.c
===================================================================
--- gcc/cfgexpand.c.orig
+++ gcc/cfgexpand.c
@@ -850,6 +850,7 @@ expand_one_stack_var_at (tree decl, rtx
 
   x = plus_constant (Pmode, base, offset);
   x = gen_rtx_MEM (DECL_MODE (SSAVAR (decl)), x);
+  set_mem_addr_space (x, targetm.addr_space.for_frame ());
 
   if (TREE_CODE (decl) != SSA_NAME)
     {
Index: gcc/varasm.c
===================================================================
--- gcc/varasm.c.orig
+++ gcc/varasm.c
@@ -3205,9 +3205,14 @@ build_constant_desc (tree exp)
   labelno = const_labelno++;
   ASM_GENERATE_INTERNAL_LABEL (label, "LC", labelno);
 
+  tree type = TREE_TYPE (exp);
+  addr_space_t as = targetm.addr_space.for_global (true);
+  if (!ADDR_SPACE_GENERIC_P (as))
+    type = build_qualified_type (type, (TYPE_QUALS_NO_ADDR_SPACE (type)
+					| ENCODE_QUAL_ADDR_SPACE (as)));
+
   /* Construct the VAR_DECL associated with the constant.  */
-  decl = build_decl (UNKNOWN_LOCATION, VAR_DECL, get_identifier (label),
-		     TREE_TYPE (exp));
+  decl = build_decl (UNKNOWN_LOCATION, VAR_DECL, get_identifier (label), type);
   DECL_ARTIFICIAL (decl) = 1;
   DECL_IGNORED_P (decl) = 1;
   TREE_READONLY (decl) = 1;
@@ -3244,6 +3249,7 @@ build_constant_desc (tree exp)
 
   rtl = gen_const_mem (TYPE_MODE (TREE_TYPE (exp)), symbol);
   set_mem_attributes (rtl, exp, 1);
+  set_mem_addr_space (rtl, as);
   set_mem_alias_set (rtl, 0);
   set_mem_alias_set (rtl, const_alias_set);
 
Index: gcc/tree-switch-conversion.c
===================================================================
--- gcc/tree-switch-conversion.c.orig
+++ gcc/tree-switch-conversion.c
@@ -46,6 +46,7 @@ Software Foundation, 51 Franklin Street,
 #include "tree-pass.h"
 #include "gimple-pretty-print.h"
 #include "cfgloop.h"
+#include "target.h"
 
 /* ??? For lang_hooks.types.type_for_mode, but is there a word_mode
    type in the GIMPLE type system that is language-independent?  */
@@ -1043,6 +1044,14 @@ build_one_array (gimple swtch, int num,
 
       default_type = TREE_TYPE (info->default_values[num]);
       value_type = array_value_type (swtch, default_type, num, info);
+      addr_space_t as = targetm.addr_space.for_global (true);
+      if (!ADDR_SPACE_GENERIC_P (as))
+	{
+	  value_type
+	    = build_qualified_type (value_type,
+				    TYPE_QUALS_NO_ADDR_SPACE (value_type)
+				    | ENCODE_QUAL_ADDR_SPACE (as));
+	}
       array_type = build_array_type (value_type, arr_index_type);
       if (default_type != value_type)
 	{
Index: gcc/tree-core.h
===================================================================
--- gcc/tree-core.h.orig
+++ gcc/tree-core.h
@@ -369,7 +369,8 @@ enum cv_qualifier {
   TYPE_QUAL_CONST    = 0x1,
   TYPE_QUAL_VOLATILE = 0x2,
   TYPE_QUAL_RESTRICT = 0x4,
-  TYPE_QUAL_ATOMIC   = 0x8
+  TYPE_QUAL_ATOMIC   = 0x8,
+  TYPE_QUAL_AS_IMPLICIT = 0x10
 };
 
 /* Enumerate visibility settings.  */
@@ -746,7 +747,8 @@ struct GTY(()) tree_base {
       unsigned user_align : 1;
       unsigned nameless_flag : 1;
       unsigned atomic_flag : 1;
-      unsigned spare0 : 3;
+      unsigned as_implicit_flag : 1;
+      unsigned spare0 : 2;
 
       unsigned spare1 : 8;
 

Index Nav: [Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav: [Date Prev] [Date Next] [Thread Prev] [Thread Next]