自学教程：C++ IDENTIFIER_LENGTH函数代码示例

intnothrow_libfn_p (const_tree fn){  tree id;  if (TREE_PUBLIC (fn)      && DECL_EXTERNAL (fn)      && DECL_NAMESPACE_SCOPE_P (fn)      && DECL_EXTERN_C_P (fn))    /* OK */;  else    /* Can't be a C library function.  */    return 0;  /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME     unless the system headers are playing rename tricks, and if     they are, we don't want to be confused by them.  */  id = DECL_NAME (fn);  const struct libc_name_struct *s    = libc_name::libc_name_p (IDENTIFIER_POINTER (id), IDENTIFIER_LENGTH (id));  if (s == NULL)    return 0;  switch (s->c_ver)    {    case 89: return 1;    case 99: return !flag_iso || flag_isoc99;    case 11: return !flag_iso || flag_isoc11;    default: gcc_unreachable ();    }}

static voidwrite_identifier (struct output_block *ob,		   struct lto_output_stream *index_stream,		   tree id){  streamer_write_string_with_length (ob, index_stream,				     IDENTIFIER_POINTER (id),				     IDENTIFIER_LENGTH (id),				     true);}

/* This emits all the meta-data string tables (and finalizes each var   as it goes).  */voidgenerate_strings (void){  tree chain, string_expr;  tree string, decl; /* , type;*/  for (chain = class_names_chain; chain; chain = TREE_CHAIN (chain))    {      string = TREE_VALUE (chain);      decl = TREE_PURPOSE (chain);      string_expr = my_build_string (IDENTIFIER_LENGTH (string) + 1,				     IDENTIFIER_POINTER (string));      finish_var_decl (decl, string_expr);    }  for (chain = meth_var_names_chain; chain; chain = TREE_CHAIN (chain))    {      string = TREE_VALUE (chain);      decl = TREE_PURPOSE (chain);      string_expr = my_build_string (IDENTIFIER_LENGTH (string) + 1,				     IDENTIFIER_POINTER (string));      finish_var_decl (decl, string_expr);    }  for (chain = meth_var_types_chain; chain; chain = TREE_CHAIN (chain))    {      string = TREE_VALUE (chain);      decl = TREE_PURPOSE (chain);      string_expr = my_build_string (IDENTIFIER_LENGTH (string) + 1,				     IDENTIFIER_POINTER (string));      finish_var_decl (decl, string_expr);    }  for (chain = prop_names_attr_chain; chain; chain = TREE_CHAIN (chain))    {      string = TREE_VALUE (chain);      decl = TREE_PURPOSE (chain);      string_expr = my_build_string (IDENTIFIER_LENGTH (string) + 1,				     IDENTIFIER_POINTER (string));      finish_var_decl (decl, string_expr);    }}

static voidmangle_array_type (tree p_type){  tree type, elt_type;  int match;  type = TREE_TYPE (p_type);  gcc_assert (type);  elt_type = TYPE_ARRAY_ELEMENT (type);  /* We cache a bit of the Jarray <> mangle. */  if (!atms)    {      atms = get_identifier ("6JArray");    }  /* Maybe we have what we're looking for in the compression table. */  if ((match = find_compression_array_match (p_type)) >= 0)    {      emit_compression_string (match);      return;    }  /* We know for a fact that all arrays are pointers */  obstack_1grow (mangle_obstack, 'P');  /* Maybe we already have a Jarray<t> somewhere. PSx_ will be enough. */  if ((match = find_compression_record_match (type, NULL)) > 0)    {      emit_compression_string (match);      return;    }  /* Maybe we already have just JArray somewhere */  if ((match = find_compression_array_template_match (atms)) > 0)    emit_compression_string (match);  else    {      /* Start the template mangled name */      obstack_grow (mangle_obstack, 		    IDENTIFIER_POINTER (atms), IDENTIFIER_LENGTH (atms));      /* Insert in the compression table */      compression_table_add (atms);    }   /* Mangle Jarray <elt_type> */  obstack_1grow (mangle_obstack, 'I');  mangle_type (elt_type);  obstack_1grow (mangle_obstack, 'E');  /* Add `Jarray <elt_type>' and `Jarray <elt_type> *' to the table */  compression_table_add (type);  compression_table_add (p_type);}

const struct attribute_spec *lookup_attribute_spec (tree name){  struct substring attr;  attr.str = IDENTIFIER_POINTER (name);  attr.length = IDENTIFIER_LENGTH (name);  extract_attribute_substring (&attr);  return (const struct attribute_spec *)    htab_find_with_hash (attribute_hash, &attr,			 substring_hash (attr.str, attr.length));}

treeadd_objc_string (tree ident, string_section section){  tree *chain, decl, type;  char buf[BUFSIZE];  switch (section)    {    case class_names:      chain = &class_names_chain;      snprintf (buf, BUFSIZE, "_OBJC_ClassName_%s", IDENTIFIER_POINTER (ident));      break;    case meth_var_names:      chain = &meth_var_names_chain;      snprintf (buf, BUFSIZE, "_OBJC_METH_VAR_NAME_%d", meth_var_names_idx++);      break;    case meth_var_types:      chain = &meth_var_types_chain;      snprintf (buf, BUFSIZE, "_OBJC_METH_VAR_TYPE_%d", meth_var_types_idx++);      break;    case prop_names_attr:      chain = &prop_names_attr_chain;      snprintf (buf, BUFSIZE, "_OBJC_PropertyAttributeOrName_%d", property_name_attr_idx++);      break;    default:      gcc_unreachable ();    }  while (*chain)    {      if (TREE_VALUE (*chain) == ident)	return convert (string_type_node,			build_unary_op (input_location,					ADDR_EXPR, TREE_PURPOSE (*chain), 1));      chain = &TREE_CHAIN (*chain);    }  type = build_sized_array_type (char_type_node, IDENTIFIER_LENGTH (ident) + 1);  /* Get a runtime-specific string decl which will be finish_var()'ed in     generate_strings ().  */  decl = (*runtime.string_decl) (type, buf, section);  TREE_CONSTANT (decl) = 1;  *chain = tree_cons (decl, ident, NULL_TREE);  return convert (string_type_node,		  build_unary_op (input_location, ADDR_EXPR, decl, 1));}

voidwrite_constant_pool (CPool *cpool, unsigned char *buffer, int length){  unsigned char *ptr = buffer;  int i = 1;  union cpool_entry *datap = &cpool->data[1];  PUT2 (cpool->count);  for ( ;  i < cpool->count;  i++, datap++)    {      int tag = cpool->tags[i];      PUT1 (tag);      switch (tag)	{	case CONSTANT_NameAndType:	case CONSTANT_Fieldref:	case CONSTANT_Methodref:	case CONSTANT_InterfaceMethodref:	case CONSTANT_Float:	case CONSTANT_Integer:	  PUT4 (datap->w);	  break;	case CONSTANT_Class:	case CONSTANT_String:	  PUT2 (datap->w);	  break;	  break;	case CONSTANT_Long:	case CONSTANT_Double:	  PUT4(datap->w);	  i++;	  datap++;	  PUT4 (datap->w);	  break;	case CONSTANT_Utf8:	  {	    tree t = datap->t;	    int len = IDENTIFIER_LENGTH (t);	    PUT2 (len);	    PUTN (IDENTIFIER_POINTER (t), len);	  }	  break;	}    }  if (ptr != buffer + length)    abort ();}

treeget_type_from_signature (tree signature){  const unsigned char *sig = (const unsigned char *) IDENTIFIER_POINTER (signature);  int len = IDENTIFIER_LENGTH (signature);  tree type;  /* Primitive types aren't cached. */  if (len <= 1)    return parse_signature_string (sig, len);  type = IDENTIFIER_SIGNATURE_TYPE (signature);  if (type == NULL_TREE)    {      type = parse_signature_string (sig, len);      IDENTIFIER_SIGNATURE_TYPE (signature) = type;    }  return type;}

static intmangle_record_type (tree type, int for_pointer){  tree current;  int match;  int nadded_p = 0;  int qualified;    /* Does this name have a package qualifier? */  qualified = QUALIFIED_P (DECL_NAME (TYPE_NAME (type)));#define ADD_N() /  do { obstack_1grow (mangle_obstack, 'N'); nadded_p = 1; } while (0)  gcc_assert (TREE_CODE (type) == RECORD_TYPE);  if (!TYPE_PACKAGE_LIST (type))    set_type_package_list (type);  match = find_compression_record_match (type, &current);  if (match >= 0)    {      /* If we had a pointer, and there's more, we need to emit	 'N' after 'P' (for_pointer tells us we already emitted it.) */      if (for_pointer && current)	ADD_N();      emit_compression_string (match);    }  while (current)    {      /* Add the new type to the table */      compression_table_add (TREE_PURPOSE (current));      /* Add 'N' if we never got a chance to, but only if we have a qualified         name.  For non-pointer elements, the name is always qualified. */      if ((qualified || !for_pointer) && !nadded_p)	ADD_N();      /* Use the bare type name for the mangle. */      append_gpp_mangled_name (IDENTIFIER_POINTER (TREE_VALUE (current)),			       IDENTIFIER_LENGTH (TREE_VALUE (current)));      current = TREE_CHAIN (current);    }  return nadded_p;#undef ADD_N}

intnothrow_libfn_p (const_tree fn){  tree id;  if (TREE_PUBLIC (fn)      && DECL_EXTERNAL (fn)      && DECL_NAMESPACE_SCOPE_P (fn)      && DECL_EXTERN_C_P (fn))    /* OK */;  else    /* Can't be a C library function.  */    return 0;  /* Being a C library function, DECL_ASSEMBLER_NAME == DECL_NAME     unless the system headers are playing rename tricks, and if     they are, we don't want to be confused by them.  */  id = DECL_NAME (fn);  return !!libc_name_p (IDENTIFIER_POINTER (id), IDENTIFIER_LENGTH (id));}

static const struct attribute_spec *lookup_scoped_attribute_spec (const_tree ns, const_tree name){  struct substring attr;  scoped_attributes *attrs;  const char *ns_str = (ns != NULL_TREE) ? IDENTIFIER_POINTER (ns): NULL;  attrs = find_attribute_namespace (ns_str);  if (attrs == NULL)    return NULL;  attr.str = IDENTIFIER_POINTER (name);  attr.length = IDENTIFIER_LENGTH (name);  extract_attribute_substring (&attr);  return attrs->attribute_hash->find_with_hash (&attr,						substring_hash (attr.str,							       	attr.length));}

intcount_constant_pool_bytes (CPool *cpool){    int size = 2;    int i = 1;    for ( ;  i < cpool->count;  i++)    {        size++;        switch (cpool->tags[i])        {        case CONSTANT_NameAndType:        case CONSTANT_Fieldref:        case CONSTANT_Methodref:        case CONSTANT_InterfaceMethodref:        case CONSTANT_Float:        case CONSTANT_Integer:            size += 4;            break;        case CONSTANT_Class:        case CONSTANT_String:            size += 2;            break;        case CONSTANT_Long:        case CONSTANT_Double:            size += 8;            i++;            break;        case CONSTANT_Utf8:        {            tree t = cpool->data[i].t;            int len = IDENTIFIER_LENGTH (t);            size += len + 2;        }        break;        default:            /* Second word of CONSTANT_Long and  CONSTANT_Double. */            size--;        }    }    return size;}

treebuild_java_argument_signature (tree type){  extern struct obstack temporary_obstack;  tree sig = TYPE_ARGUMENT_SIGNATURE (type);  if (sig == NULL_TREE)    {      tree args = TYPE_ARG_TYPES (type);      if (TREE_CODE (type) == METHOD_TYPE)	args = TREE_CHAIN (args);  /* Skip "this" argument. */      for (; args != end_params_node; args = TREE_CHAIN (args))	{	  tree t = build_java_signature (TREE_VALUE (args));	  obstack_grow (&temporary_obstack,			IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t));	}      obstack_1grow (&temporary_obstack, '/0');      sig = get_identifier ((char *) obstack_base (&temporary_obstack));      TYPE_ARGUMENT_SIGNATURE (type) = sig;      obstack_free (&temporary_obstack, obstack_base (&temporary_obstack));    }  return sig;}

static voidmangle_member_name (tree name){  append_gpp_mangled_name (IDENTIFIER_POINTER (name),			   IDENTIFIER_LENGTH (name));}

treeadd_capture (tree lambda, tree id, tree orig_init, bool by_reference_p,	     bool explicit_init_p){  char *buf;  tree type, member, name;  bool vla = false;  bool variadic = false;  tree initializer = orig_init;  if (PACK_EXPANSION_P (initializer))    {      initializer = PACK_EXPANSION_PATTERN (initializer);      variadic = true;    }  if (TREE_CODE (initializer) == TREE_LIST)    initializer = build_x_compound_expr_from_list (initializer, ELK_INIT,						   tf_warning_or_error);  type = TREE_TYPE (initializer);  if (type == error_mark_node)    return error_mark_node;  if (array_of_runtime_bound_p (type))    {      vla = true;      if (!by_reference_p)	error ("array of runtime bound cannot be captured by copy, "	       "only by reference");      /* For a VLA, we capture the address of the first element and the	 maximum index, and then reconstruct the VLA for the proxy.  */      tree elt = cp_build_array_ref (input_location, initializer,				     integer_zero_node, tf_warning_or_error);      initializer = build_constructor_va (init_list_type_node, 2,					  NULL_TREE, build_address (elt),					  NULL_TREE, array_type_nelts (type));      type = vla_capture_type (type);    }  else if (!dependent_type_p (type)	   && variably_modified_type_p (type, NULL_TREE))    {      error ("capture of variable-size type %qT that is not an N3639 array "	     "of runtime bound", type);      if (TREE_CODE (type) == ARRAY_TYPE	  && variably_modified_type_p (TREE_TYPE (type), NULL_TREE))	inform (input_location, "because the array element type %qT has "		"variable size", TREE_TYPE (type));      type = error_mark_node;    }  else    {      type = lambda_capture_field_type (initializer, explicit_init_p);      if (by_reference_p)	{	  type = build_reference_type (type);	  if (!dependent_type_p (type) && !real_lvalue_p (initializer))	    error ("cannot capture %qE by reference", initializer);	}      else	{	  /* Capture by copy requires a complete type.  */	  type = complete_type (type);	  if (!dependent_type_p (type) && !COMPLETE_TYPE_P (type))	    {	      error ("capture by copy of incomplete type %qT", type);	      cxx_incomplete_type_inform (type);	      return error_mark_node;	    }	}    }  /* Add __ to the beginning of the field name so that user code     won't find the field with name lookup.  We can't just leave the name     unset because template instantiation uses the name to find     instantiated fields.  */  buf = (char *) alloca (IDENTIFIER_LENGTH (id) + 3);  buf[1] = buf[0] = '_';  memcpy (buf + 2, IDENTIFIER_POINTER (id),	  IDENTIFIER_LENGTH (id) + 1);  name = get_identifier (buf);  /* If TREE_TYPE isn't set, we're still in the introducer, so check     for duplicates.  */  if (!LAMBDA_EXPR_CLOSURE (lambda))    {      if (IDENTIFIER_MARKED (name))	{	  pedwarn (input_location, 0,		   "already captured %qD in lambda expression", id);	  return NULL_TREE;	}      IDENTIFIER_MARKED (name) = true;    }  if (variadic)    type = make_pack_expansion (type);  /* Make member variable.  */  member = build_decl (input_location, FIELD_DECL, name, type);//.........这里部分代码省略.........

//.........这里部分代码省略.........	  di->column += 14;	}      /* All types have associated declarations.  */      dump_child ("name", TYPE_NAME (t));      /* All types have a main variant.  */      if (TYPE_MAIN_VARIANT (t) != t)	dump_child ("unql", TYPE_MAIN_VARIANT (t));      /* And sizes.  */      dump_child ("size", TYPE_SIZE (t));      /* All types have alignments.  */      dump_int (di, "algn", TYPE_ALIGN (t));    }  else if (code_class == tcc_constant)    /* All constants can have types.  */    queue_and_dump_type (di, t);  /* Give the language-specific code a chance to print something.  If     it's completely taken care of things, don't bother printing     anything more ourselves.  */  if (lang_hooks.tree_dump.dump_tree (di, t))    goto done;  /* Now handle the various kinds of nodes.  */  switch (code)    {      int i;    case IDENTIFIER_NODE:      dump_string_field (di, "strg", IDENTIFIER_POINTER (t));      dump_int (di, "lngt", IDENTIFIER_LENGTH (t));      break;    case TREE_LIST:      dump_child ("purp", TREE_PURPOSE (t));      dump_child ("valu", TREE_VALUE (t));      dump_child ("chan", TREE_CHAIN (t));      break;    case STATEMENT_LIST:      {	tree_stmt_iterator it;	for (i = 0, it = tsi_start (t); !tsi_end_p (it); tsi_next (&it), i++)	  {	    char buffer[32];	    sprintf (buffer, "%u", i);	    dump_child (buffer, tsi_stmt (it));	  }      }      break;    case TREE_VEC:      dump_int (di, "lngt", TREE_VEC_LENGTH (t));      for (i = 0; i < TREE_VEC_LENGTH (t); ++i)	{	  char buffer[32];	  sprintf (buffer, "%u", i);	  dump_child (buffer, TREE_VEC_ELT (t, i));	}      break;    case INTEGER_TYPE:    case ENUMERAL_TYPE:

//.........这里部分代码省略.........	    index = IMMEDIATE_u2;	    if (index <= 0 || index >= JPOOL_SIZE (current_jcf))	      VERIFICATION_ERROR_WITH_INDEX		("bad constant pool index %d for invoke");	    tag = JPOOL_TAG (current_jcf, index);	    if (op_code == OPCODE_invokeinterface)	      {		if (tag != CONSTANT_InterfaceMethodref)		  VERIFICATION_ERROR		    ("invokeinterface does not reference an InterfaceMethodref");	      }	    else	      {		if (tag != CONSTANT_Methodref)		  VERIFICATION_ERROR ("invoke does not reference a Methodref");	      }	    sig = COMPONENT_REF_SIGNATURE (&current_jcf->cpool, index);	    self_type              = get_class_constant (current_jcf,                                    COMPONENT_REF_CLASS_INDEX                                      (&current_jcf->cpool, index));	    if (! CLASS_LOADED_P (self_type))	      load_class (self_type, 1);	    self_is_interface = CLASS_INTERFACE (TYPE_NAME (self_type));	    method_name = COMPONENT_REF_NAME (&current_jcf->cpool, index);	    method_type = parse_signature_string ((const unsigned char *) IDENTIFIER_POINTER (sig),						  IDENTIFIER_LENGTH (sig));	    if (TREE_CODE (method_type) != FUNCTION_TYPE)	      VERIFICATION_ERROR ("bad method signature");	    pmessage = pop_argument_types (TYPE_ARG_TYPES (method_type));	    if (pmessage != NULL)	      {		message = "invalid argument type";		goto pop_type_error;	      }	    /* Can't invoke <clinit>.  */	    if (ID_CLINIT_P (method_name))	      VERIFICATION_ERROR ("invoke opcode can't invoke <clinit>");	    /* Apart from invokespecial, can't invoke <init>.  */	    if (op_code != OPCODE_invokespecial && ID_INIT_P (method_name))	      VERIFICATION_ERROR ("invoke opcode can't invoke <init>");	    if (op_code != OPCODE_invokestatic)	      POP_TYPE (self_type,			"stack type not subclass of invoked method's class");	    switch (op_code)	      {	      case OPCODE_invokeinterface:	        {		  int nargs    = IMMEDIATE_u1;		  int notZero  = IMMEDIATE_u1;				  if (!nargs || notZero)		      VERIFICATION_ERROR 

intvfy_string_length (vfy_string str){  return IDENTIFIER_LENGTH (str);}

treebuild_java_array_type (tree element_type, HOST_WIDE_INT length){  tree sig, t, fld, atype, arfld;  char buf[23];  tree elsig = build_java_signature (element_type);  tree el_name = element_type;  buf[0] = '[';  if (length >= 0)    sprintf (buf+1, HOST_WIDE_INT_PRINT_DEC, length);  else    buf[1] = '/0';  sig = ident_subst (IDENTIFIER_POINTER (elsig), IDENTIFIER_LENGTH (elsig),		     buf, 0, 0, "");  t = IDENTIFIER_SIGNATURE_TYPE (sig);  if (t != NULL_TREE)    return TREE_TYPE (t);  t = make_class ();  IDENTIFIER_SIGNATURE_TYPE (sig) = build_pointer_type (t);  TYPE_ARRAY_P (t) = 1;  if (TREE_CODE (el_name) == POINTER_TYPE)    el_name = TREE_TYPE (el_name);  el_name = TYPE_NAME (el_name);  if (TREE_CODE (el_name) == TYPE_DECL)    el_name = DECL_NAME (el_name);  {    char suffix[23];    if (length >= 0)      sprintf (suffix, "[%d]", (int)length);     else      strcpy (suffix, "[]");    TYPE_NAME (t)       = TYPE_STUB_DECL (t)      = build_decl (input_location, TYPE_DECL,		    identifier_subst (el_name, "", '.', '.', suffix),                             t);    TYPE_DECL_SUPPRESS_DEBUG (TYPE_STUB_DECL (t)) = true;  }  set_java_signature (t, sig);  set_super_info (0, t, object_type_node, 0);  if (TREE_CODE (element_type) == RECORD_TYPE)    element_type = promote_type (element_type);  TYPE_ARRAY_ELEMENT (t) = element_type;  /* Add length pseudo-field. */  fld = build_decl (input_location,		    FIELD_DECL, get_identifier ("length"), int_type_node);  TYPE_FIELDS (t) = fld;  DECL_CONTEXT (fld) = t;  FIELD_PUBLIC (fld) = 1;  FIELD_FINAL (fld) = 1;  TREE_READONLY (fld) = 1;  atype = build_prim_array_type (element_type, length);  arfld = build_decl (input_location,		      FIELD_DECL, get_identifier ("data"), atype);  DECL_CONTEXT (arfld) = t;  DECL_CHAIN (fld) = arfld;  DECL_ALIGN (arfld) = TYPE_ALIGN (element_type);  /* We could layout_class, but that loads java.lang.Object prematurely.   * This is called by the parser, and it is a bad idea to do load_class   * in the middle of parsing, because of possible circularity problems. */  push_super_field (t, object_type_node);  layout_type (t);  return t;}

treebuild_java_signature (tree type){  tree sig, t;  while (TREE_CODE (type) == POINTER_TYPE)    type = TREE_TYPE (type);  MAYBE_CREATE_TYPE_TYPE_LANG_SPECIFIC (type);  sig = TYPE_SIGNATURE (type);  if (sig == NULL_TREE)    {      char sg[2];      switch (TREE_CODE (type))	{	case BOOLEAN_TYPE: sg[0] = 'Z';  goto native;	case VOID_TYPE:    sg[0] = 'V';  goto native;	case INTEGER_TYPE:          if (type == char_type_node || type == promoted_char_type_node)	    {	      sg[0] = 'C';	      goto native;	    }	  switch (TYPE_PRECISION (type))	    {	    case  8:       sg[0] = 'B';  goto native;	    case 16:       sg[0] = 'S';  goto native;	    case 32:       sg[0] = 'I';  goto native;	    case 64:       sg[0] = 'J';  goto native;	    default:  goto bad_type;	    }	case REAL_TYPE:	  switch (TYPE_PRECISION (type))	    {	    case 32:       sg[0] = 'F';  goto native;	    case 64:       sg[0] = 'D';  goto native;	    default:  goto bad_type;	    }	native:	  sg[1] = 0;	  sig = get_identifier (sg);	  break;	case RECORD_TYPE:	  if (TYPE_ARRAY_P (type))	    {	      t = build_java_signature (TYPE_ARRAY_ELEMENT (type));	      sig = ident_subst (IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t),				 "[", 0, 0, "");	    }	  else	    {	      t = DECL_NAME (TYPE_NAME (type));	      sig = ident_subst (IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t),				 "L", '.', '/', ";");	    }	  break;	case METHOD_TYPE:	case FUNCTION_TYPE:	  {	    extern struct obstack temporary_obstack;	    sig = build_java_argument_signature (type);	    obstack_1grow (&temporary_obstack, '(');	    obstack_grow (&temporary_obstack,			  IDENTIFIER_POINTER (sig), IDENTIFIER_LENGTH (sig));	    obstack_1grow (&temporary_obstack, ')');	    t = build_java_signature (TREE_TYPE (type));	    obstack_grow0 (&temporary_obstack,			   IDENTIFIER_POINTER (t), IDENTIFIER_LENGTH (t));	    sig = get_identifier ((char *) obstack_base (&temporary_obstack));	    obstack_free (&temporary_obstack,			  obstack_base (&temporary_obstack));	  }	  break;	bad_type:	default:	  gcc_unreachable ();	}      TYPE_SIGNATURE (type) = sig;    }  return sig;}