If @var{incoming} is nonzero and the address is to be found on the
stack, return a @code{mem} which refers to the frame pointer. If
@var{incoming} is @code{2}, the result is being used to fetch the
-structure value address at the beginning of a function. If you need
+structure value address at the beginning of a function. If you need
to emit adjusting code, you should do it at this point.
@end deftypefn
@end deftypefn
@deftypefn {Target Hook} int TARGET_SCHED_SPECULATE_INSN (rtx @var{insn}, int @var{request}, rtx *@var{new_pat})
-This hook is called by the insn scheduler when @var{insn} has only
-speculative dependencies and therefore can be scheduled speculatively.
-The hook is used to check if the pattern of @var{insn} has a speculative
-version and, in case of successful check, to generate that speculative
-pattern. The hook should return 1, if the instruction has a speculative form,
-or -1, if it doesn't. @var{request} describes the type of requested
+This hook is called by the insn scheduler when @var{insn} has only
+speculative dependencies and therefore can be scheduled speculatively.
+The hook is used to check if the pattern of @var{insn} has a speculative
+version and, in case of successful check, to generate that speculative
+pattern. The hook should return 1, if the instruction has a speculative form,
+or -1, if it doesn't. @var{request} describes the type of requested
speculation. If the return value equals 1 then @var{new_pat} is assigned
the generated speculative pattern.
@end deftypefn
@deftypefn {Target Hook} rtx TARGET_SCHED_GEN_CHECK (rtx @var{insn}, rtx @var{label}, int @var{mutate_p})
This hook is called by the insn scheduler to generate a pattern for recovery
-check instruction. If @var{mutate_p} is zero, then @var{insn} is a
-speculative instruction for which the check should be generated.
-@var{label} is either a label of a basic block, where recovery code should
-be emitted, or a null pointer, when requested check doesn't branch to
-recovery code (a simple check). If @var{mutate_p} is nonzero, then
-a pattern for a branchy check corresponding to a simple check denoted by
+check instruction. If @var{mutate_p} is zero, then @var{insn} is a
+speculative instruction for which the check should be generated.
+@var{label} is either a label of a basic block, where recovery code should
+be emitted, or a null pointer, when requested check doesn't branch to
+recovery code (a simple check). If @var{mutate_p} is nonzero, then
+a pattern for a branchy check corresponding to a simple check denoted by
@var{insn} should be generated. In this case @var{label} can't be null.
@end deftypefn
@samp{TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD} not being
called on the first instruction of the ready list. The hook is used to
discard speculative instruction that stand first in the ready list from
-being scheduled on the current cycle. For non-speculative instructions,
+being scheduled on the current cycle. For non-speculative instructions,
the hook should always return nonzero. For example, in the ia64 backend
the hook is used to cancel data speculative insns when the ALAT table
is nearly full.
@end deftypefn
@deftypefn {Target Hook} void TARGET_SCHED_SET_SCHED_FLAGS (unsigned int *@var{flags}, spec_info_t @var{spec_info})
-This hook is used by the insn scheduler to find out what features should be
+This hook is used by the insn scheduler to find out what features should be
enabled/used. @var{flags} initially may have either the SCHED_RGN or SCHED_EBB
-bit set. This denotes the scheduler pass for which the data should be
+bit set. This denotes the scheduler pass for which the data should be
provided. The target backend should modify @var{flags} by modifying
the bits corresponding to the following features: USE_DEPS_LIST, USE_GLAT,
-DETACH_LIFE_INFO, and DO_SPECULATION. For the DO_SPECULATION feature
-an additional structure @var{spec_info} should be filled by the target.
+DETACH_LIFE_INFO, and DO_SPECULATION. For the DO_SPECULATION feature
+an additional structure @var{spec_info} should be filled by the target.
The structure describes speculation types that can be used in the scheduler.
@end deftypefn
classes. By default, TARGET_USE_JCR_SECTION is defined to 1 if both
SUPPORTS_WEAK and TARGET_HAVE_NAMED_SECTIONS are true, else 0.
@end defmac
+
+@defmac OBJC_JBLEN
+This macro determines the size of the objective C jump buffer for the
+NeXT runtime. By default, OBJC_JBLEN is defined to an innocuous value.
+@end defmac
in the class. */
DECL_SIZE (base)
= (field && TREE_CODE (field) == FIELD_DECL
- ? size_binop (PLUS_EXPR,
+ ? size_binop (PLUS_EXPR,
size_binop (PLUS_EXPR,
size_binop
(MULT_EXPR,
a new one. */
t = build_variant_type_copy (type);
TYPE_VOLATILE (t) = 1;
-
+
return t;
}
objc_object_reference = xref_tag (RECORD_TYPE, objc_object_id);
objc_class_reference = xref_tag (RECORD_TYPE, objc_class_id);
-
+
objc_object_type = build_pointer_type (objc_object_reference);
objc_class_type = build_pointer_type (objc_class_reference);
type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
TREE_NOTHROW (umsg_fast_decl) = 0;
- DECL_ATTRIBUTES (umsg_fast_decl)
- = tree_cons (get_identifier ("hard_coded_address"),
+ DECL_ATTRIBUTES (umsg_fast_decl)
+ = tree_cons (get_identifier ("hard_coded_address"),
build_int_cst (NULL_TREE, OFFS_MSGSEND_FAST),
NULL_TREE);
#else
/* typedef id (*IMP)(id, SEL, ...); */
tree IMP_type
= build_pointer_type
- (build_function_type (objc_object_type,
- tree_cons (NULL_TREE, objc_object_type,
- tree_cons (NULL_TREE, objc_selector_type,
- NULL_TREE))));
+ (build_function_type (objc_object_type,
+ tree_cons (NULL_TREE, objc_object_type,
+ tree_cons (NULL_TREE, objc_selector_type,
+ NULL_TREE))));
/* IMP objc_msg_lookup (id, SEL); */
type
static void __objc_gnu_init (void) {
__objc_exec_class (&L_OBJC_MODULES);
- } */
+ } */
static void
build_module_initializer_routine (void)
#ifdef OBJCPLUS
push_lang_context (lang_name_c); /* extern "C" */
-#endif
+#endif
objc_push_parm (build_decl (PARM_DECL, NULL_TREE, void_type_node));
objc_start_function (get_identifier (TAG_GNUINIT),
tree_cons (NULL_TREE,
build_int_cst (NULL_TREE, 0),
tree_cons (NULL_TREE,
- build_int_cst (NULL_TREE, 0),
+ build_int_cst (NULL_TREE, 0),
NULL_TREE)))
: build_int_cst (NULL_TREE, 0), initlist);
initlist = objc_build_constructor (TREE_TYPE (UOBJC_SELECTOR_TABLE_decl),
}
decl = build_objc_string_decl (section);
-
+
type = build_array_type
(char_type_node,
build_index_type
- (build_int_cst (NULL_TREE,
+ (build_int_cst (NULL_TREE,
IDENTIFIER_LENGTH (ident))));
decl = start_var_decl (type, IDENTIFIER_POINTER (DECL_NAME (decl)));
string_expr = my_build_string (IDENTIFIER_LENGTH (ident) + 1,
DECL_ARTIFICIAL (decl) = 1;
#ifdef OBJCPLUS
DECL_THIS_STATIC (decl) = 1; /* squash redeclaration errors */
-#endif
+#endif
make_decl_rtl (decl);
pushdecl_top_level (decl);
return (objc_object_type && type
&& (IS_ID (type) || IS_CLASS (type) || IS_SUPER (type))
? type
- : NULL_TREE);
+ : NULL_TREE);
}
/* Check whether TYPE is either 'id', 'Class', or a pointer to an ObjC
static int
objc_is_gcable_type (tree type, int or_strong_p)
{
- tree name;
+ tree name;
if (!TYPE_P (type))
return 0;
offs = convert (integer_type_node, build_unary_op (ADDR_EXPR, offs, 0));
offs = fold (offs);
- func_params = tree_cons (NULL_TREE,
+ func_params = tree_cons (NULL_TREE,
convert (objc_object_type, rhs),
tree_cons (NULL_TREE, convert (objc_object_type, outervar),
tree_cons (NULL_TREE, offs,
tree func_params = tree_cons (NULL_TREE,
convert (objc_object_type, rhs),
tree_cons (NULL_TREE, convert (build_pointer_type (objc_object_type),
- build_unary_op (ADDR_EXPR, lhs, 0)),
+ build_unary_op (ADDR_EXPR, lhs, 0)),
NULL_TREE));
assemble_external (objc_assign_strong_cast_decl);
}
outer_gc_p = objc_is_gcable_p (outer);
-
+
/* Handle ivar assignments. */
if (objc_is_ivar_reference_p (lhs))
{
}
/* Likewise, intercept assignment to global/static variables if their type is
- GC-marked. */
+ GC-marked. */
if (objc_is_global_reference_p (outer))
{
if (indirect_p)
objc_create_temporary_var (tree type)
{
tree decl;
-
+
decl = build_decl (VAR_DECL, NULL_TREE, type);
TREE_USED (decl) = 1;
DECL_ARTIFICIAL (decl) = 1;
/* Build:
DECL = objc_exception_extract(&_stack); */
-
+
static tree
next_sjlj_build_exc_extract (tree decl)
{
objc_mark_locals_volatile (NULL);
}
-/* Called just after parsing "@catch (parm)". Open a binding level,
+/* Called just after parsing "@catch (parm)". Open a binding level,
enter DECL into the binding level, and initialize it. Leave the
binding level open while the body of the compound statement is parsed. */
-
+
void
objc_begin_catch_clause (tree decl)
{
struct _objc_exception_data
{
- int buf[JBLEN];
+ int buf[OBJC_JBLEN];
void *pointers[4];
}; */
/* The following yuckiness should prevent users from having to #include
<setjmp.h> in their code... */
-#ifdef TARGET_POWERPC
-/* snarfed from /usr/include/ppc/setjmp.h */
-#define JBLEN (26 + 36 + 129 + 1)
-#else
-/* snarfed from /usr/include/i386/{setjmp,signal}.h */
-#define JBLEN 18
+/* Define to a harmless positive value so the below code doesn't die. */
+#ifndef OBJC_JBLEN
+#define OBJC_JBLEN 18
#endif
static void
objc_exception_data_template
= start_struct (RECORD_TYPE, get_identifier (UTAG_EXCDATA));
- /* int buf[JBLEN]; */
+ /* int buf[OBJC_JBLEN]; */
- index = build_index_type (build_int_cst (NULL_TREE, JBLEN - 1));
+ index = build_index_type (build_int_cst (NULL_TREE, OBJC_JBLEN - 1));
field_decl = create_field_decl (build_array_type (integer_type_node, index),
"buf");
field_decl_chain = field_decl;
= builtin_function (TAG_EXCEPTIONTRYEXIT, temp_type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
/* int objc_exception_match(id, id); */
- temp_type
+ temp_type
= build_function_type (integer_type_node,
tree_cons (NULL_TREE, objc_object_type,
tree_cons (NULL_TREE, objc_object_type,
objc_assign_ivar_fast_decl
= builtin_function (TAG_ASSIGNIVAR_FAST, temp_type, 0,
NOT_BUILT_IN, NULL, NULL_TREE);
- DECL_ATTRIBUTES (objc_assign_ivar_fast_decl)
- = tree_cons (get_identifier ("hard_coded_address"),
+ DECL_ATTRIBUTES (objc_assign_ivar_fast_decl)
+ = tree_cons (get_identifier ("hard_coded_address"),
build_int_cst (NULL_TREE, OFFS_ASSIGNIVAR_FAST),
NULL_TREE);
#else
elemlist
= tree_cons (NULL_TREE,
- convert (ptr_type_node,
+ convert (ptr_type_node,
build_unary_op (ADDR_EXPR,
METHOD_DEFINITION (entries), 1)),
elemlist);
else
{
expr = convert (build_pointer_type
- (build_pointer_type
+ (build_pointer_type
(objc_protocol_template)),
build_unary_op (ADDR_EXPR, protocol_list, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
else
{
expr = convert (build_pointer_type
- (build_pointer_type
+ (build_pointer_type
(objc_protocol_template)),
build_unary_op (ADDR_EXPR, protocol_list, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
warn_with_method (methods ? "using" : "found",
((TREE_CODE (meth) == INSTANCE_METHOD_DECL)
? '-'
- : '+'),
+ : '+'),
meth);
for (loop = hsh->list; loop; loop = loop->next)
warn_with_method ("also found",
((TREE_CODE (loop->value) == INSTANCE_METHOD_DECL)
- ? '-'
+ ? '-'
: '+'),
loop->value);
}
if (!is_class)
method_prototype = hash_lookup (nst_method_hash_list,
sel_name);
-
+
if (!method_prototype)
{
method_prototype = hash_lookup (cls_method_hash_list,
exist locally as part of the @implementation. */
if (!method_prototype && objc_implementation_context
&& CLASS_NAME (objc_implementation_context)
- == OBJC_TYPE_NAME (rtype))
+ == OBJC_TYPE_NAME (rtype))
method_prototype
= lookup_method
((class_tree
lookup as if we were messaging 'id'. */
rtype = rprotos = NULL_TREE;
}
- }
+ }
/* For 'id' or 'Class' receivers, search in the global hash table
tree method, t;
lookup_object = build_c_cast (rcv_p, lookup_object);
-
+
/* Use SAVE_EXPR to avoid evaluating the receiver twice. */
lookup_object = save_expr (lookup_object);
/* First, call the lookup function to get a pointer to the method,
then cast the pointer, then call it with the method arguments. */
-
+
object = (super_flag ? self_decl : lookup_object);
t = tree_cons (NULL_TREE, selector, NULL_TREE);
/* Look up a class (if OBJC_LOOKUP_CLASS is set in FLAGS) or instance method
in INTERFACE, along with any categories and protocols attached thereto.
If method is not found, and the OBJC_LOOKUP_NO_SUPER is _not_ set in FLAGS,
- recursively examine the INTERFACE's superclass. If OBJC_LOOKUP_CLASS is
+ recursively examine the INTERFACE's superclass. If OBJC_LOOKUP_CLASS is
set, OBJC_LOOKUP_NO_SUPER is cleared, and no suitable class method could
be found in INTERFACE or any of its superclasses, look for an _instance_
method of the same name in the root class as a last resort.
If a suitable method cannot be found, return NULL_TREE. */
-
+
static tree
lookup_method_static (tree interface, tree ident, int flags)
{
|| TREE_CODE (class) == CATEGORY_INTERFACE_TYPE)
&& !comp_proto_with_proto (method, mth, 1))
error ("duplicate declaration of method %<%c%s%>",
- is_class ? '+' : '-',
+ is_class ? '+' : '-',
IDENTIFIER_POINTER (METHOD_SEL_NAME (mth)));
}
TREE_PRIVATE (decl) ? "@private" : "@protected");
return 1;
}
-
+
error ("instance variable %qs is declared %s",
IDENTIFIER_POINTER (identifier),
TREE_PRIVATE (decl) ? "private" : "protected");
error ("duplicate interface declaration for class %qs",
#else
warning (0, "duplicate interface declaration for class %qs",
-#endif
+#endif
IDENTIFIER_POINTER (class_name));
else
add_class (class, class_name);
if (TREE_INT_CST_LOW (TYPE_SIZE (array_of)) == 0)
sprintf (buffer, "[" HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT)0);
- else
+ else
sprintf (buffer, "[" HOST_WIDE_INT_PRINT_DEC,
TREE_INT_CST_LOW (an_int_cst)
/ TREE_INT_CST_LOW (TYPE_SIZE (array_of)));
#endif
/* Recursively encode fields of embedded base classes. */
- if (DECL_ARTIFICIAL (field) && !DECL_NAME (field)
+ if (DECL_ARTIFICIAL (field) && !DECL_NAME (field)
&& TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE)
{
encode_aggregate_fields (TREE_TYPE (field),
original struct and its tag name (if any). */
type = TYPE_MAIN_VARIANT (type);
name = OBJC_TYPE_NAME (type);
- /* Open parenth/bracket. */
+ /* Open parenth/bracket. */
obstack_1grow (&util_obstack, left);
/* Encode the struct/union tag name, or '?' if a tag was
obstack_1grow (&util_obstack, '=');
encode_aggregate_fields (type, pointed_to, curtype, format);
}
- /* Close parenth/bracket. */
+ /* Close parenth/bracket. */
obstack_1grow (&util_obstack, right);
}
{
case 8: c = TYPE_UNSIGNED (type) ? 'C' : 'c'; break;
case 16: c = TYPE_UNSIGNED (type) ? 'S' : 's'; break;
- case 32:
+ case 32:
if (type == long_unsigned_type_node
|| type == long_integer_type_node)
c = TYPE_UNSIGNED (type) ? 'L' : 'l';
else if (code == FUNCTION_TYPE) /* '?' */
obstack_1grow (&util_obstack, '?');
-
+
else if (code == COMPLEX_TYPE)
{
obstack_1grow (&util_obstack, 'j');
((TYPE_READONLY (TREE_TYPE (parm)) ? TYPE_QUAL_CONST : 0)
| (TYPE_RESTRICT (TREE_TYPE (parm)) ? TYPE_QUAL_RESTRICT : 0)
| (TYPE_VOLATILE (TREE_TYPE (parm)) ? TYPE_QUAL_VOLATILE : 0), parm);
-
+
objc_parmlist = chainon (objc_parmlist, parm);
}
{
tree next = TREE_CHAIN (parm_info);
- TREE_CHAIN (parm_info) = NULL_TREE;
+ TREE_CHAIN (parm_info) = NULL_TREE;
parm_info = pushdecl (parm_info);
finish_decl (parm_info, NULL_TREE, NULL_TREE);
parm_info = next;
{
tree akey;
- for (akey = TREE_CHAIN (METHOD_ADD_ARGS (method));
+ for (akey = TREE_CHAIN (METHOD_ADD_ARGS (method));
akey; akey = TREE_CHAIN (akey))
{
objc_push_parm (TREE_VALUE (akey));
sprintf (errbuf + strlen (errbuf), ": " HOST_WIDE_INT_PRINT_DEC,
TREE_INT_CST_LOW (DECL_INITIAL (decl)));
}
-
+
return errbuf;
}
inner = TREE_TYPE (inner);
gen_type_name_0 (inner);
-
+
if (!POINTER_TYPE_P (inner))
strcat (errbuf, " ");
char sz[20];
sprintf (sz, HOST_WIDE_INT_PRINT_DEC,
- (TREE_INT_CST_LOW
+ (TREE_INT_CST_LOW
(TYPE_MAX_VALUE (TYPE_DOMAIN (type))) + 1));
strcat (errbuf, sz);
}
/* For 'id' and 'Class', adopted protocols are stored in the pointee. */
if (objc_is_id (orig))
orig = TREE_TYPE (orig);
-
+
proto = TYPE_HAS_OBJC_INFO (orig) ? TYPE_OBJC_PROTOCOL_LIST (orig) : NULL_TREE;
if (proto)
strcat (errbuf, " <");
while (proto) {
- strcat (errbuf,
+ strcat (errbuf,
IDENTIFIER_POINTER (PROTOCOL_NAME (TREE_VALUE (proto))));
proto = TREE_CHAIN (proto);
strcat (errbuf, proto ? ", " : ">");
projects / thirdparty / gcc.git / commitdiff
