OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [objc/] [objc-act.c] - Blame information for rev 717

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 717 jeremybenn
/* Implement classes and message passing for Objective C.
2
   Copyright (C) 1992, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2001,
3
   2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
4
   Free Software Foundation, Inc.
5
   Contributed by Steve Naroff.
6
 
7
This file is part of GCC.
8
 
9
GCC is free software; you can redistribute it and/or modify
10
it under the terms of the GNU General Public License as published by
11
the Free Software Foundation; either version 3, or (at your option)
12
any later version.
13
 
14
GCC is distributed in the hope that it will be useful,
15
but WITHOUT ANY WARRANTY; without even the implied warranty of
16
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17
GNU General Public License for more details.
18
 
19
You should have received a copy of the GNU General Public License
20
along with GCC; see the file COPYING3.  If not see
21
<http://www.gnu.org/licenses/>.  */
22
 
23
#include "config.h"
24
#include "system.h"
25
#include "coretypes.h"
26
#include "tm.h"
27
#include "tree.h"
28
 
29
#ifdef OBJCPLUS
30
#include "cp-tree.h"
31
#else
32
#include "c-tree.h"
33
#include "c-lang.h"
34
#endif
35
 
36
#include "c-family/c-common.h"
37
#include "c-family/c-objc.h"
38
#include "c-family/c-pragma.h"
39
#include "c-family/c-format.h"
40
#include "flags.h"
41
#include "langhooks.h"
42
#include "objc-act.h"
43
#include "objc-map.h"
44
#include "input.h"
45
#include "function.h"
46
#include "output.h"
47
#include "toplev.h"
48
#include "ggc.h"
49
#include "debug.h"
50
#include "c-family/c-target.h"
51
#include "diagnostic-core.h"
52
#include "intl.h"
53
#include "cgraph.h"
54
#include "tree-iterator.h"
55
#include "hashtab.h"
56
#include "langhooks-def.h"
57
/* Different initialization, code gen and meta data generation for each
58
   runtime.  */
59
#include "objc-runtime-hooks.h"
60
/* Routines used mainly by the runtimes.  */
61
#include "objc-runtime-shared-support.h"
62
/* For default_tree_printer ().  */
63
#include "tree-pretty-print.h"
64
 
65
/* For enum gimplify_status */
66
#include "gimple.h"
67
 
68
/* For encode_method_prototype().  */
69
#include "objc-encoding.h"
70
 
71
static unsigned int should_call_super_dealloc = 0;
72
 
73
/* When building Objective-C++, we are not linking against the C front-end
74
   and so need to replicate the C tree-construction functions in some way.  */
75
#ifdef OBJCPLUS
76
#define OBJCP_REMAP_FUNCTIONS
77
#include "objcp-decl.h"
78
#endif  /* OBJCPLUS */
79
 
80
/* This is the default way of generating a method name.  */
81
/* This has the problem that "test_method:argument:" and
82
   "test:method_argument:" will generate the same name
83
   ("_i_Test__test_method_argument_" for an instance method of the
84
   class "Test"), so you can't have them both in the same class!
85
   Moreover, the demangling (going from
86
   "_i_Test__test_method_argument" back to the original name) is
87
   undefined because there are two correct ways of demangling the
88
   name.  */
89
#ifndef OBJC_GEN_METHOD_LABEL
90
#define OBJC_GEN_METHOD_LABEL(BUF, IS_INST, CLASS_NAME, CAT_NAME, SEL_NAME, NUM) \
91
  do {                                      \
92
    char *temp;                             \
93
    sprintf ((BUF), "_%s_%s_%s_%s",         \
94
             ((IS_INST) ? "i" : "c"),       \
95
             (CLASS_NAME),                  \
96
             ((CAT_NAME)? (CAT_NAME) : ""), \
97
             (SEL_NAME));                   \
98
    for (temp = (BUF); *temp; temp++)       \
99
      if (*temp == ':') *temp = '_';        \
100
  } while (0)
101
#endif
102
 
103
/* These need specifying.  */
104
#ifndef OBJC_FORWARDING_STACK_OFFSET
105
#define OBJC_FORWARDING_STACK_OFFSET 0
106
#endif
107
 
108
#ifndef OBJC_FORWARDING_MIN_OFFSET
109
#define OBJC_FORWARDING_MIN_OFFSET 0
110
#endif
111
 
112
/*** Private Interface (procedures) ***/
113
 
114
/* Init stuff.  */
115
static void synth_module_prologue (void);
116
 
117
/* Code generation.  */
118
 
119
static tree start_class (enum tree_code, tree, tree, tree, tree);
120
static tree continue_class (tree);
121
static void finish_class (tree);
122
static void start_method_def (tree, tree);
123
 
124
static tree start_protocol (enum tree_code, tree, tree, tree);
125
static tree build_method_decl (enum tree_code, tree, tree, tree, bool);
126
static tree objc_add_method (tree, tree, int, bool);
127
static tree add_instance_variable (tree, objc_ivar_visibility_kind, tree);
128
static tree build_ivar_reference (tree);
129
static tree is_ivar (tree, tree);
130
 
131
/* We only need the following for ObjC; ObjC++ will use C++'s definition
132
   of DERIVED_FROM_P.  */
133
#ifndef OBJCPLUS
134
static bool objc_derived_from_p (tree, tree);
135
#define DERIVED_FROM_P(PARENT, CHILD) objc_derived_from_p (PARENT, CHILD)
136
#endif
137
 
138
/* Property.  */
139
static void objc_gen_property_data (tree, tree);
140
static void objc_synthesize_getter (tree, tree, tree);
141
static void objc_synthesize_setter (tree, tree, tree);
142
static tree lookup_property (tree, tree);
143
static tree lookup_property_in_list (tree, tree);
144
static tree lookup_property_in_protocol_list (tree, tree);
145
static void build_common_objc_property_accessor_helpers (void);
146
 
147
static void objc_xref_basetypes (tree, tree);
148
 
149
static tree get_class_ivars (tree, bool);
150
 
151
static void build_fast_enumeration_state_template (void);
152
 
153
#ifdef OBJCPLUS
154
static void objc_generate_cxx_cdtors (void);
155
#endif
156
 
157
/* objc attribute */
158
static void objc_decl_method_attributes (tree*, tree, int);
159
static tree build_keyword_selector (tree);
160
 
161
static void hash_init (void);
162
 
163
/* Hash tables to manage the global pool of method prototypes.  Each
164
   of these maps map a method name (selector) identifier to either a
165
   single tree (for methods with a single method prototype) or a
166
   TREE_VEC (for methods with multiple method prototypes).  */
167
static GTY(()) objc_map_t instance_method_map = 0;
168
static GTY(()) objc_map_t class_method_map = 0;
169
 
170
/* Hash tables to manage the global pool of class names.  */
171
 
172
static GTY(()) objc_map_t class_name_map = 0;
173
static GTY(()) objc_map_t alias_name_map = 0;
174
 
175
static tree lookup_method (tree, tree);
176
static tree lookup_method_static (tree, tree, int);
177
 
178
static void interface_hash_init (void);
179
static tree add_interface (tree, tree);
180
static void add_category (tree, tree);
181
static inline tree lookup_category (tree, tree);
182
 
183
/* Protocols.  */
184
 
185
static tree lookup_protocol (tree, bool, bool);
186
static tree lookup_and_install_protocols (tree, bool);
187
 
188
#ifdef OBJCPLUS
189
static void really_start_method (tree, tree);
190
#else
191
static void really_start_method (tree, struct c_arg_info *);
192
#endif
193
static int comp_proto_with_proto (tree, tree, int);
194
static tree objc_decay_parm_type (tree);
195
 
196
/* Utilities for debugging and error diagnostics.  */
197
 
198
static char *gen_type_name (tree);
199
static char *gen_type_name_0 (tree);
200
static char *gen_method_decl (tree);
201
static char *gen_declaration (tree);
202
 
203
/* Everything else.  */
204
 
205
static void generate_struct_by_value_array (void) ATTRIBUTE_NORETURN;
206
 
207
static void mark_referenced_methods (void);
208
static bool objc_type_valid_for_messaging (tree type, bool allow_classes);
209
static tree check_duplicates (tree, int, int);
210
 
211
/*** Private Interface (data) ***/
212
/* Flags for lookup_method_static().  */
213
 
214
/* Look for class methods.  */
215
#define OBJC_LOOKUP_CLASS       1
216
/* Do not examine superclasses.  */
217
#define OBJC_LOOKUP_NO_SUPER    2
218
/* Disable returning an instance method of a root class when a class
219
   method can't be found.  */
220
#define OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS 4
221
 
222
/* The OCTI_... enumeration itself is in objc/objc-act.h.  */
223
tree objc_global_trees[OCTI_MAX];
224
 
225
struct imp_entry *imp_list = 0;
226
int imp_count = 0;       /* `@implementation' */
227
int cat_count = 0;       /* `@category' */
228
 
229
objc_ivar_visibility_kind objc_ivar_visibility;
230
 
231
/* Use to generate method labels.  */
232
static int method_slot = 0;
233
 
234
/* Flag to say whether methods in a protocol are optional or
235
   required.  */
236
static bool objc_method_optional_flag = false;
237
 
238
static int objc_collecting_ivars = 0;
239
 
240
/* Flag that is set to 'true' while we are processing a class
241
   extension.  Since a class extension just "reopens" the main
242
   @interface, this can be used to determine if we are in the main
243
   @interface, or in a class extension.  */
244
static bool objc_in_class_extension = false;
245
 
246
static char *errbuf;    /* Buffer for error diagnostics */
247
 
248
/* An array of all the local variables in the current function that
249
   need to be marked as volatile.  */
250
VEC(tree,gc) *local_variables_to_volatilize = NULL;
251
 
252
/* Store all constructed constant strings in a hash table so that
253
   they get uniqued properly.  */
254
 
255
struct GTY(()) string_descriptor {
256
  /* The literal argument .  */
257
  tree literal;
258
 
259
  /* The resulting constant string.  */
260
  tree constructor;
261
};
262
 
263
static GTY((param_is (struct string_descriptor))) htab_t string_htab;
264
 
265
FILE *gen_declaration_file;
266
 
267
/* Hooks for stuff that differs between runtimes.  */
268
objc_runtime_hooks runtime;
269
 
270
/* Create a temporary variable of type 'type'.  If 'name' is set, uses
271
   the specified name, else use no name.  Returns the declaration of
272
   the type.  The 'name' is mostly useful for debugging.
273
*/
274
tree
275
objc_create_temporary_var (tree type, const char *name)
276
{
277
  tree decl;
278
 
279
  if (name != NULL)
280
    {
281
      decl = build_decl (input_location,
282
                         VAR_DECL, get_identifier (name), type);
283
    }
284
  else
285
    {
286
      decl = build_decl (input_location,
287
                         VAR_DECL, NULL_TREE, type);
288
    }
289
  TREE_USED (decl) = 1;
290
  DECL_ARTIFICIAL (decl) = 1;
291
  DECL_IGNORED_P (decl) = 1;
292
  DECL_CONTEXT (decl) = current_function_decl;
293
 
294
  return decl;
295
}
296
 
297
/* Some platforms pass small structures through registers versus
298
   through an invisible pointer.  Determine at what size structure is
299
   the transition point between the two possibilities.  */
300
 
301
static void
302
generate_struct_by_value_array (void)
303
{
304
  tree type;
305
  tree decls;
306
  int i, j;
307
  int aggregate_in_mem[32];
308
  int found = 0;
309
 
310
  /* Presumably no platform passes 32 byte structures in a register.  */
311
  /* ??? As an example, m64/ppc/Darwin can pass up to 8*long+13*double
312
     in registers.  */
313
  for (i = 1; i < 32; i++)
314
    {
315
      char buffer[5];
316
      tree *chain = NULL;
317
 
318
      /* Create an unnamed struct that has `i' character components */
319
      type = objc_start_struct (NULL_TREE);
320
 
321
      strcpy (buffer, "c1");
322
      decls = add_field_decl (char_type_node, buffer, &chain);
323
 
324
      for (j = 1; j < i; j++)
325
        {
326
          sprintf (buffer, "c%d", j + 1);
327
          add_field_decl (char_type_node, buffer, &chain);
328
        }
329
      objc_finish_struct (type, decls);
330
 
331
      aggregate_in_mem[i] = aggregate_value_p (type, 0);
332
      if (!aggregate_in_mem[i])
333
        found = 1;
334
    }
335
 
336
  /* We found some structures that are returned in registers instead of memory
337
     so output the necessary data.  */
338
  if (found)
339
    {
340
      for (i = 31; i >= 0;  i--)
341
        if (!aggregate_in_mem[i])
342
          break;
343
      printf ("#define OBJC_MAX_STRUCT_BY_VALUE %d\n", i);
344
    }
345
 
346
  exit (0);
347
}
348
 
349
bool
350
objc_init (void)
351
{
352
  bool ok;
353
#ifdef OBJCPLUS
354
  if (cxx_init () == false)
355
#else
356
  if (c_objc_common_init () == false)
357
#endif
358
    return false;
359
 
360
  /* print_struct_values is triggered by -print-runtime-info (used
361
     when building libobjc, with an empty file as input).  It does not
362
     require any ObjC setup, and it never returns.
363
 
364
     -fcompare-debug is used to check the compiler output; we are
365
     executed twice, once with flag_compare_debug set, and once with
366
     it not set.  If the flag is used together with
367
     -print-runtime-info, we want to print the runtime info only once,
368
     else it would be output in duplicate.  So we check
369
     flag_compare_debug to output it in only one of the invocations.
370
 
371
     As a side effect, this also that means -fcompare-debug
372
     -print-runtime-info will run the compiler twice, and compare the
373
     generated assembler file; the first time the compiler exits
374
     immediately (producing no file), and the second time it compiles
375
     an empty file.  This checks, as a side effect, that compiling an
376
     empty file produces no assembler output.  */
377
  if (print_struct_values && !flag_compare_debug)
378
    generate_struct_by_value_array ();
379
 
380
  /* Set up stuff used by FE parser and all runtimes.  */
381
  errbuf = XNEWVEC (char, 1024 * 10);
382
  interface_hash_init ();
383
  hash_init ();
384
  objc_encoding_init ();
385
  /* ... and then check flags and set-up for the selected runtime ... */
386
  if (flag_next_runtime && flag_objc_abi >= 2)
387
    ok = objc_next_runtime_abi_02_init (&runtime);
388
  else if (flag_next_runtime)
389
    ok = objc_next_runtime_abi_01_init (&runtime);
390
  else
391
    ok = objc_gnu_runtime_abi_01_init (&runtime);
392
 
393
  /* If that part of the setup failed - bail out immediately.  */
394
  if (!ok)
395
    return false;
396
 
397
  /* Generate general types and push runtime-specific decls to file scope.  */
398
  synth_module_prologue ();
399
 
400
  return true;
401
}
402
 
403
/* This is called automatically (at the very end of compilation) by
404
   c_write_global_declarations and cp_write_global_declarations.  */
405
void
406
objc_write_global_declarations (void)
407
{
408
  mark_referenced_methods ();
409
 
410
  /* A missing @end might not be detected by the parser.  */
411
  if (objc_implementation_context)
412
    {
413
      warning (0, "%<@end%> missing in implementation context");
414
      finish_class (objc_implementation_context);
415
      objc_ivar_chain = NULL_TREE;
416
      objc_implementation_context = NULL_TREE;
417
    }
418
 
419
  if (warn_selector)
420
    {
421
      objc_map_iterator_t i;
422
 
423
      objc_map_iterator_initialize (class_method_map, &i);
424
      while (objc_map_iterator_move_to_next (class_method_map, &i))
425
        check_duplicates (objc_map_iterator_current_value (class_method_map, i), 0, 1);
426
 
427
      objc_map_iterator_initialize (instance_method_map, &i);
428
      while (objc_map_iterator_move_to_next (instance_method_map, &i))
429
        check_duplicates (objc_map_iterator_current_value (instance_method_map, i), 0, 0);
430
    }
431
 
432
  /* TODO: consider an early exit here if either errorcount or sorrycount
433
     is non-zero.  Not only is it wasting time to generate the metadata,
434
     it needlessly imposes need to re-check for things that are already
435
     determined to be errors.  */
436
 
437
  /* Finalize Objective-C runtime data.  No need to generate tables
438
     and code if only checking syntax, or if generating a PCH file.  */
439
  if (!flag_syntax_only && !pch_file)
440
    {
441
      location_t saved_location;
442
 
443
      /* If gen_declaration desired, open the output file.  */
444
      if (flag_gen_declaration)
445
        {
446
          char * const dumpname = concat (dump_base_name, ".decl", NULL);
447
          gen_declaration_file = fopen (dumpname, "w");
448
          if (gen_declaration_file == 0)
449
            fatal_error ("can%'t open %s: %m", dumpname);
450
          free (dumpname);
451
        }
452
 
453
      /* Set the input location to BUILTINS_LOCATION.  This is good
454
         for error messages, in case any is generated while producing
455
         the metadata, but it also silences warnings that would be
456
         produced when compiling with -Wpadded in case when padding is
457
         automatically added to the built-in runtime data structure
458
         declarations.  We know about this padding, and it is fine; we
459
         don't want users to see any warnings about it if they use
460
         -Wpadded.  */
461
      saved_location = input_location;
462
      input_location = BUILTINS_LOCATION;
463
 
464
      /* Compute and emit the meta-data tables for this runtime.  */
465
      (*runtime.generate_metadata) ();
466
 
467
      /* Restore the original location, just in case it mattered.  */
468
      input_location = saved_location;
469
 
470
      /* ... and then close any declaration file we opened.  */
471
      if (gen_declaration_file)
472
        fclose (gen_declaration_file);
473
    }
474
}
475
 
476
/* Return the first occurrence of a method declaration corresponding
477
   to sel_name in rproto_list.  Search rproto_list recursively.
478
   If is_class is 0, search for instance methods, otherwise for class
479
   methods.  */
480
static tree
481
lookup_method_in_protocol_list (tree rproto_list, tree sel_name,
482
                                int is_class)
483
{
484
  tree rproto, p, m;
485
 
486
   for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto))
487
     {
488
       p = TREE_VALUE (rproto);
489
       m = NULL_TREE;
490
 
491
        if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
492
          {
493
            /* First, search the @required protocol methods.  */
494
            if (is_class)
495
              m = lookup_method (PROTOCOL_CLS_METHODS (p),  sel_name);
496
            else
497
              m = lookup_method (PROTOCOL_NST_METHODS (p), sel_name);
498
 
499
            if (m)
500
              return m;
501
 
502
            /* If still not found, search the @optional protocol methods.  */
503
            if (is_class)
504
              m = lookup_method (PROTOCOL_OPTIONAL_CLS_METHODS (p), sel_name);
505
            else
506
              m = lookup_method (PROTOCOL_OPTIONAL_NST_METHODS (p), sel_name);
507
 
508
            if (m)
509
              return m;
510
 
511
            /* If still not found, search the attached protocols.  */
512
            if (PROTOCOL_LIST (p))
513
              m = lookup_method_in_protocol_list (PROTOCOL_LIST (p),
514
                                                  sel_name, is_class);
515
            if (m)
516
              return m;
517
          }
518
        else
519
          {
520
            ; /* An identifier...if we could not find a protocol.  */
521
          }
522
     }
523
 
524
   return 0;
525
}
526
 
527
static tree
528
lookup_protocol_in_reflist (tree rproto_list, tree lproto)
529
{
530
  tree rproto, p;
531
 
532
  /* Make sure the protocol is supported by the object on the rhs.  */
533
  if (TREE_CODE (lproto) == PROTOCOL_INTERFACE_TYPE)
534
    {
535
      tree fnd = 0;
536
      for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto))
537
        {
538
          p = TREE_VALUE (rproto);
539
 
540
          if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
541
            {
542
              if (lproto == p)
543
                fnd = lproto;
544
 
545
              else if (PROTOCOL_LIST (p))
546
                fnd = lookup_protocol_in_reflist (PROTOCOL_LIST (p), lproto);
547
            }
548
 
549
          if (fnd)
550
            return fnd;
551
        }
552
    }
553
  else
554
    {
555
      ; /* An identifier...if we could not find a protocol.  */
556
    }
557
 
558
  return 0;
559
}
560
 
561
void
562
objc_start_class_interface (tree klass, tree super_class,
563
                            tree protos, tree attributes)
564
{
565
  if (flag_objc1_only && attributes)
566
    error_at (input_location, "class attributes are not available in Objective-C 1.0");
567
 
568
  objc_interface_context
569
    = objc_ivar_context
570
    = start_class (CLASS_INTERFACE_TYPE, klass, super_class, protos, attributes);
571
  objc_ivar_visibility = OBJC_IVAR_VIS_PROTECTED;
572
}
573
 
574
void
575
objc_start_category_interface (tree klass, tree categ,
576
                               tree protos, tree attributes)
577
{
578
  if (attributes)
579
    {
580
      if (flag_objc1_only)
581
        error_at (input_location, "category attributes are not available in Objective-C 1.0");
582
      else
583
        warning_at (input_location, OPT_Wattributes,
584
                    "category attributes are not available in this version"
585
                    " of the compiler, (ignored)");
586
    }
587
  if (categ == NULL_TREE)
588
    {
589
      if (flag_objc1_only)
590
        error_at (input_location, "class extensions are not available in Objective-C 1.0");
591
      else
592
        {
593
          /* Iterate over all the classes and categories implemented
594
             up to now in this compilation unit.  */
595
          struct imp_entry *t;
596
 
597
          for (t = imp_list; t; t = t->next)
598
            {
599
              /* If we find a class @implementation with the same name
600
                 as the one we are extending, produce an error.  */
601
            if (TREE_CODE (t->imp_context) == CLASS_IMPLEMENTATION_TYPE
602
                && IDENTIFIER_POINTER (CLASS_NAME (t->imp_context)) == IDENTIFIER_POINTER (klass))
603
              error_at (input_location,
604
                        "class extension for class %qE declared after its %<@implementation%>",
605
                        klass);
606
            }
607
        }
608
    }
609
  objc_interface_context
610
    = start_class (CATEGORY_INTERFACE_TYPE, klass, categ, protos, NULL_TREE);
611
  objc_ivar_chain
612
    = continue_class (objc_interface_context);
613
}
614
 
615
void
616
objc_start_protocol (tree name, tree protos, tree attributes)
617
{
618
  if (flag_objc1_only && attributes)
619
    error_at (input_location, "protocol attributes are not available in Objective-C 1.0");
620
 
621
  objc_interface_context
622
    = start_protocol (PROTOCOL_INTERFACE_TYPE, name, protos, attributes);
623
  objc_method_optional_flag = false;
624
}
625
 
626
void
627
objc_continue_interface (void)
628
{
629
  objc_ivar_chain
630
    = continue_class (objc_interface_context);
631
}
632
 
633
void
634
objc_finish_interface (void)
635
{
636
  finish_class (objc_interface_context);
637
  objc_interface_context = NULL_TREE;
638
  objc_method_optional_flag = false;
639
  objc_in_class_extension = false;
640
}
641
 
642
void
643
objc_start_class_implementation (tree klass, tree super_class)
644
{
645
  objc_implementation_context
646
    = objc_ivar_context
647
    = start_class (CLASS_IMPLEMENTATION_TYPE, klass, super_class, NULL_TREE,
648
                   NULL_TREE);
649
  objc_ivar_visibility = OBJC_IVAR_VIS_PROTECTED;
650
}
651
 
652
void
653
objc_start_category_implementation (tree klass, tree categ)
654
{
655
  objc_implementation_context
656
    = start_class (CATEGORY_IMPLEMENTATION_TYPE, klass, categ, NULL_TREE,
657
                   NULL_TREE);
658
  objc_ivar_chain
659
    = continue_class (objc_implementation_context);
660
}
661
 
662
void
663
objc_continue_implementation (void)
664
{
665
  objc_ivar_chain
666
    = continue_class (objc_implementation_context);
667
}
668
 
669
void
670
objc_finish_implementation (void)
671
{
672
#ifdef OBJCPLUS
673
  if (flag_objc_call_cxx_cdtors)
674
    objc_generate_cxx_cdtors ();
675
#endif
676
 
677
  if (objc_implementation_context)
678
    {
679
      finish_class (objc_implementation_context);
680
      objc_ivar_chain = NULL_TREE;
681
      objc_implementation_context = NULL_TREE;
682
    }
683
  else
684
    warning (0, "%<@end%> must appear in an @implementation context");
685
}
686
 
687
void
688
objc_set_visibility (objc_ivar_visibility_kind visibility)
689
{
690
  if (visibility == OBJC_IVAR_VIS_PACKAGE)
691
    {
692
      if (flag_objc1_only)
693
        error ("%<@package%> is not available in Objective-C 1.0");
694
      else
695
        warning (0, "%<@package%> presently has the same effect as %<@public%>");
696
    }
697
  objc_ivar_visibility = visibility;
698
}
699
 
700
void
701
objc_set_method_opt (bool optional)
702
{
703
  if (flag_objc1_only)
704
    {
705
      if (optional)
706
        error_at (input_location, "%<@optional%> is not available in Objective-C 1.0");
707
      else
708
        error_at (input_location, "%<@required%> is not available in Objective-C 1.0");
709
    }
710
 
711
  objc_method_optional_flag = optional;
712
  if (!objc_interface_context
713
      || TREE_CODE (objc_interface_context) != PROTOCOL_INTERFACE_TYPE)
714
    {
715
      if (optional)
716
        error ("%<@optional%> is allowed in @protocol context only");
717
      else
718
        error ("%<@required%> is allowed in @protocol context only");
719
      objc_method_optional_flag = false;
720
    }
721
}
722
 
723
/* This routine looks for a given PROPERTY in a list of CLASS, CATEGORY, or
724
   PROTOCOL.  */
725
static tree
726
lookup_property_in_list (tree chain, tree property)
727
{
728
  tree x;
729
  for (x = CLASS_PROPERTY_DECL (chain); x; x = TREE_CHAIN (x))
730
    if (PROPERTY_NAME (x) == property)
731
      return x;
732
  return NULL_TREE;
733
}
734
 
735
/* This routine looks for a given PROPERTY in the tree chain of RPROTO_LIST. */
736
static tree lookup_property_in_protocol_list (tree rproto_list, tree property)
737
{
738
  tree rproto, x;
739
  for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto))
740
    {
741
      tree p = TREE_VALUE (rproto);
742
      if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
743
        {
744
          if ((x = lookup_property_in_list (p, property)))
745
            return x;
746
          if (PROTOCOL_LIST (p))
747
            return lookup_property_in_protocol_list (PROTOCOL_LIST (p), property);
748
        }
749
      else
750
        {
751
          ; /* An identifier...if we could not find a protocol.  */
752
        }
753
    }
754
  return NULL_TREE;
755
}
756
 
757
/* This routine looks up the PROPERTY in current INTERFACE, its categories and up the
758
   chain of interface hierarchy.  */
759
static tree
760
lookup_property (tree interface_type, tree property)
761
{
762
  tree inter = interface_type;
763
  while (inter)
764
    {
765
      tree x, category;
766
      if ((x = lookup_property_in_list (inter, property)))
767
        return x;
768
      /* Failing that, look for the property in each category of the class.  */
769
      category = inter;
770
      while ((category = CLASS_CATEGORY_LIST (category)))
771
        {
772
          if ((x = lookup_property_in_list (category, property)))
773
            return x;
774
 
775
          /* When checking a category, also check the protocols
776
             attached with the category itself.  */
777
          if (CLASS_PROTOCOL_LIST (category)
778
              && (x = lookup_property_in_protocol_list
779
                  (CLASS_PROTOCOL_LIST (category), property)))
780
            return x;
781
        }
782
 
783
      /*  Failing to find in categories, look for property in protocol list. */
784
      if (CLASS_PROTOCOL_LIST (inter)
785
          && (x = lookup_property_in_protocol_list
786
              (CLASS_PROTOCOL_LIST (inter), property)))
787
        return x;
788
 
789
      /* Failing that, climb up the inheritance hierarchy.  */
790
      inter = lookup_interface (CLASS_SUPER_NAME (inter));
791
    }
792
  return inter;
793
}
794
 
795
/* This routine is called by the parser when a
796
   @property... declaration is found.  'decl' is the declaration of
797
   the property (type/identifier), and the other arguments represent
798
   property attributes that may have been specified in the Objective-C
799
   declaration.  'parsed_property_readonly' is 'true' if the attribute
800
   'readonly' was specified, and 'false' if not; similarly for the
801
   other bool parameters.  'parsed_property_getter_ident' is NULL_TREE
802
   if the attribute 'getter' was not specified, and is the identifier
803
   corresponding to the specified getter if it was; similarly for
804
   'parsed_property_setter_ident'.  */
805
void
806
objc_add_property_declaration (location_t location, tree decl,
807
                               bool parsed_property_readonly, bool parsed_property_readwrite,
808
                               bool parsed_property_assign, bool parsed_property_retain,
809
                               bool parsed_property_copy, bool parsed_property_nonatomic,
810
                               tree parsed_property_getter_ident, tree parsed_property_setter_ident)
811
{
812
  tree property_decl;
813
  tree x;
814
  /* 'property_readonly' and 'property_assign_semantics' are the final
815
     attributes of the property after all parsed attributes have been
816
     considered (eg, if we parsed no 'readonly' and no 'readwrite', ie
817
     parsed_property_readonly = false and parsed_property_readwrite =
818
     false, then property_readonly will be false because the default
819
     is readwrite).  */
820
  bool property_readonly = false;
821
  objc_property_assign_semantics property_assign_semantics = OBJC_PROPERTY_ASSIGN;
822
  bool property_extension_in_class_extension = false;
823
 
824
  if (flag_objc1_only)
825
    error_at (input_location, "%<@property%> is not available in Objective-C 1.0");
826
 
827
  if (parsed_property_readonly && parsed_property_readwrite)
828
    {
829
      error_at (location, "%<readonly%> attribute conflicts with %<readwrite%> attribute");
830
      /* In case of conflicting attributes (here and below), after
831
         producing an error, we pick one of the attributes and keep
832
         going.  */
833
      property_readonly = false;
834
    }
835
  else
836
    {
837
      if (parsed_property_readonly)
838
        property_readonly = true;
839
 
840
      if (parsed_property_readwrite)
841
        property_readonly = false;
842
    }
843
 
844
  if (parsed_property_readonly && parsed_property_setter_ident)
845
    {
846
      error_at (location, "%<readonly%> attribute conflicts with %<setter%> attribute");
847
      property_readonly = false;
848
    }
849
 
850
  if (parsed_property_assign && parsed_property_retain)
851
    {
852
      error_at (location, "%<assign%> attribute conflicts with %<retain%> attribute");
853
      property_assign_semantics = OBJC_PROPERTY_RETAIN;
854
    }
855
  else if (parsed_property_assign && parsed_property_copy)
856
    {
857
      error_at (location, "%<assign%> attribute conflicts with %<copy%> attribute");
858
      property_assign_semantics = OBJC_PROPERTY_COPY;
859
    }
860
  else if (parsed_property_retain && parsed_property_copy)
861
    {
862
      error_at (location, "%<retain%> attribute conflicts with %<copy%> attribute");
863
      property_assign_semantics = OBJC_PROPERTY_COPY;
864
    }
865
  else
866
    {
867
      if (parsed_property_assign)
868
        property_assign_semantics = OBJC_PROPERTY_ASSIGN;
869
 
870
      if (parsed_property_retain)
871
        property_assign_semantics = OBJC_PROPERTY_RETAIN;
872
 
873
      if (parsed_property_copy)
874
        property_assign_semantics = OBJC_PROPERTY_COPY;
875
    }
876
 
877
  if (!objc_interface_context)
878
    {
879
      error_at (location, "property declaration not in @interface or @protocol context");
880
      return;
881
    }
882
 
883
  /* At this point we know that we are either in an interface, a
884
     category, or a protocol.  */
885
 
886
  /* We expect a FIELD_DECL from the parser.  Make sure we didn't get
887
     something else, as that would confuse the checks below.  */
888
  if (TREE_CODE (decl) != FIELD_DECL)
889
    {
890
      error_at (location, "invalid property declaration");
891
      return;
892
    }
893
 
894
  /* Do some spot-checks for the most obvious invalid types.  */
895
 
896
  if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
897
    {
898
      error_at (location, "property can not be an array");
899
      return;
900
    }
901
 
902
  /* The C++/ObjC++ parser seems to reject the ':' for a bitfield when
903
     parsing, while the C/ObjC parser accepts it and gives us a
904
     FIELD_DECL with a DECL_INITIAL set.  So we use the DECL_INITIAL
905
     to check for a bitfield when doing ObjC.  */
906
#ifndef OBJCPLUS
907
  if (DECL_INITIAL (decl))
908
    {
909
      /* A @property is not an actual variable, but it is a way to
910
         describe a pair of accessor methods, so its type (which is
911
         the type of the return value of the getter and the first
912
         argument of the setter) can't be a bitfield (as return values
913
         and arguments of functions can not be bitfields).  The
914
         underlying instance variable could be a bitfield, but that is
915
         a different matter.  */
916
      error_at (location, "property can not be a bit-field");
917
      return;
918
    }
919
#endif
920
 
921
  /* TODO: Check that the property type is an Objective-C object or a
922
     "POD".  */
923
 
924
  /* Implement -Wproperty-assign-default (which is enabled by default).  */
925
  if (warn_property_assign_default
926
      /* If garbage collection is not being used, then 'assign' is
927
         valid for objects (and typically used for delegates) but it
928
         is wrong in most cases (since most objects need to be
929
         retained or copied in setters).  Warn users when 'assign' is
930
         used implicitly.  */
931
      && property_assign_semantics == OBJC_PROPERTY_ASSIGN
932
      /* Read-only properties are never assigned, so the assignment
933
         semantics do not matter in that case.  */
934
      && !property_readonly
935
      && !flag_objc_gc)
936
    {
937
      /* Please note that it would make sense to default to 'assign'
938
         for non-{Objective-C objects}, and to 'retain' for
939
         Objective-C objects.  But that would break compatibility with
940
         other compilers.  */
941
      if (!parsed_property_assign && !parsed_property_retain && !parsed_property_copy)
942
        {
943
          /* Use 'false' so we do not warn for Class objects.  */
944
          if (objc_type_valid_for_messaging (TREE_TYPE (decl), false))
945
            {
946
              warning_at (location,
947
                          0,
948
                          "object property %qD has no %<assign%>, %<retain%> or %<copy%> attribute; assuming %<assign%>",
949
                          decl);
950
              inform (location,
951
                      "%<assign%> can be unsafe for Objective-C objects; please state explicitly if you need it");
952
            }
953
        }
954
    }
955
 
956
  if (property_assign_semantics == OBJC_PROPERTY_RETAIN
957
      && !objc_type_valid_for_messaging (TREE_TYPE (decl), true))
958
    error_at (location, "%<retain%> attribute is only valid for Objective-C objects");
959
 
960
  if (property_assign_semantics == OBJC_PROPERTY_COPY
961
      && !objc_type_valid_for_messaging (TREE_TYPE (decl), true))
962
    error_at (location, "%<copy%> attribute is only valid for Objective-C objects");
963
 
964
  /* Now determine the final property getter and setter names.  They
965
     will be stored in the PROPERTY_DECL, from which they'll always be
966
     extracted and used.  */
967
 
968
  /* Adjust, or fill in, setter and getter names.  We overwrite the
969
     parsed_property_setter_ident and parsed_property_getter_ident
970
     with the final setter and getter identifiers that will be
971
     used.  */
972
  if (parsed_property_setter_ident)
973
    {
974
      /* The setter should be terminated by ':', but the parser only
975
         gives us an identifier without ':'.  So, we need to add ':'
976
         at the end.  */
977
      const char *parsed_setter = IDENTIFIER_POINTER (parsed_property_setter_ident);
978
      size_t length = strlen (parsed_setter);
979
      char *final_setter = (char *)alloca (length + 2);
980
 
981
      sprintf (final_setter, "%s:", parsed_setter);
982
      parsed_property_setter_ident = get_identifier (final_setter);
983
    }
984
  else
985
    {
986
      if (!property_readonly)
987
        parsed_property_setter_ident = get_identifier (objc_build_property_setter_name
988
                                                       (DECL_NAME (decl)));
989
    }
990
 
991
  if (!parsed_property_getter_ident)
992
    parsed_property_getter_ident = DECL_NAME (decl);
993
 
994
  /* Check for duplicate property declarations.  We first check the
995
     immediate context for a property with the same name.  Any such
996
     declarations are an error, unless this is a class extension and
997
     we are extending a property from readonly to readwrite.  */
998
  for (x = CLASS_PROPERTY_DECL (objc_interface_context); x; x = TREE_CHAIN (x))
999
    {
1000
      if (PROPERTY_NAME (x) == DECL_NAME (decl))
1001
        {
1002
          if (objc_in_class_extension
1003
              && property_readonly == 0
1004
              && PROPERTY_READONLY (x) == 1)
1005
            {
1006
              /* This is a class extension, and we are extending an
1007
                 existing readonly property to a readwrite one.
1008
                 That's fine.  :-) */
1009
              property_extension_in_class_extension = true;
1010
              break;
1011
            }
1012
          else
1013
            {
1014
              location_t original_location = DECL_SOURCE_LOCATION (x);
1015
 
1016
              error_at (location, "redeclaration of property %qD", decl);
1017
 
1018
              if (original_location != UNKNOWN_LOCATION)
1019
                inform (original_location, "originally specified here");
1020
              return;
1021
            }
1022
        }
1023
    }
1024
 
1025
  /* If x is not NULL_TREE, we must be in a class extension and we're
1026
     extending a readonly property.  In that case, no point in
1027
     searching for another declaration.  */
1028
  if (x == NULL_TREE)
1029
    {
1030
      /* We now need to check for existing property declarations (in
1031
         the superclass, other categories or protocols) and check that
1032
         the new declaration is not in conflict with existing
1033
         ones.  */
1034
 
1035
      /* Search for a previous, existing declaration of a property
1036
         with the same name in superclasses, protocols etc.  If one is
1037
         found, it will be in the 'x' variable.  */
1038
 
1039
      /* Note that, for simplicity, the following may search again the
1040
         local context.  That's Ok as nothing will be found (else we'd
1041
         have thrown an error above); it's only a little inefficient,
1042
         but the code is simpler.  */
1043
      switch (TREE_CODE (objc_interface_context))
1044
        {
1045
        case CLASS_INTERFACE_TYPE:
1046
          /* Look up the property in the current @interface (which
1047
             will find nothing), then its protocols and categories and
1048
             superclasses.  */
1049
          x = lookup_property (objc_interface_context, DECL_NAME (decl));
1050
          break;
1051
        case CATEGORY_INTERFACE_TYPE:
1052
          /* Look up the property in the main @interface, then
1053
             protocols and categories (one of them is ours, and will
1054
             find nothing) and superclasses.  */
1055
          x = lookup_property (lookup_interface (CLASS_NAME (objc_interface_context)),
1056
                               DECL_NAME (decl));
1057
          break;
1058
        case PROTOCOL_INTERFACE_TYPE:
1059
          /* Looks up the property in any protocols attached to the
1060
             current protocol.  */
1061
          if (PROTOCOL_LIST (objc_interface_context))
1062
            {
1063
              x = lookup_property_in_protocol_list (PROTOCOL_LIST (objc_interface_context),
1064
                                                    DECL_NAME (decl));
1065
            }
1066
          break;
1067
        default:
1068
          gcc_unreachable ();
1069
        }
1070
    }
1071
 
1072
  if (x != NULL_TREE)
1073
    {
1074
      /* An existing property was found; check that it has the same
1075
         types, or it is compatible.  */
1076
      location_t original_location = DECL_SOURCE_LOCATION (x);
1077
 
1078
      if (PROPERTY_NONATOMIC (x) != parsed_property_nonatomic)
1079
        {
1080
          warning_at (location, 0,
1081
                      "'nonatomic' attribute of property %qD conflicts with previous declaration", decl);
1082
 
1083
          if (original_location != UNKNOWN_LOCATION)
1084
            inform (original_location, "originally specified here");
1085
          return;
1086
        }
1087
 
1088
      if (PROPERTY_GETTER_NAME (x) != parsed_property_getter_ident)
1089
        {
1090
          warning_at (location, 0,
1091
                      "'getter' attribute of property %qD conflicts with previous declaration", decl);
1092
 
1093
          if (original_location != UNKNOWN_LOCATION)
1094
            inform (original_location, "originally specified here");
1095
          return;
1096
        }
1097
 
1098
      /* We can only compare the setter names if both the old and new property have a setter.  */
1099
      if (!property_readonly  &&  !PROPERTY_READONLY(x))
1100
        {
1101
          if (PROPERTY_SETTER_NAME (x) != parsed_property_setter_ident)
1102
            {
1103
              warning_at (location, 0,
1104
                          "'setter' attribute of property %qD conflicts with previous declaration", decl);
1105
 
1106
              if (original_location != UNKNOWN_LOCATION)
1107
                inform (original_location, "originally specified here");
1108
              return;
1109
            }
1110
        }
1111
 
1112
      if (PROPERTY_ASSIGN_SEMANTICS (x) != property_assign_semantics)
1113
        {
1114
          warning_at (location, 0,
1115
                      "assign semantics attributes of property %qD conflict with previous declaration", decl);
1116
 
1117
          if (original_location != UNKNOWN_LOCATION)
1118
            inform (original_location, "originally specified here");
1119
          return;
1120
        }
1121
 
1122
      /* It's ok to have a readonly property that becomes a readwrite, but not vice versa.  */
1123
      if (PROPERTY_READONLY (x) == 0  &&  property_readonly == 1)
1124
        {
1125
          warning_at (location, 0,
1126
                      "'readonly' attribute of property %qD conflicts with previous declaration", decl);
1127
 
1128
          if (original_location != UNKNOWN_LOCATION)
1129
            inform (original_location, "originally specified here");
1130
          return;
1131
        }
1132
 
1133
      /* We now check that the new and old property declarations have
1134
         the same types (or compatible one).  In the Objective-C
1135
         tradition of loose type checking, we do type-checking but
1136
         only generate warnings (not errors) if they do not match.
1137
         For non-readonly properties, the types must match exactly;
1138
         for readonly properties, it is allowed to use a "more
1139
         specialized" type in the new property declaration.  Eg, the
1140
         superclass has a getter returning (NSArray *) and the
1141
         subclass a getter returning (NSMutableArray *).  The object's
1142
         getter returns an (NSMutableArray *); but if you cast the
1143
         object to the superclass, which is allowed, you'd still
1144
         expect the getter to return an (NSArray *), which works since
1145
         an (NSMutableArray *) is an (NSArray *) too.  So, the set of
1146
         objects belonging to the type of the new @property should be
1147
         a subset of the set of objects belonging to the type of the
1148
         old @property.  This is what "specialization" means.  And the
1149
         reason it only applies to readonly properties is that for a
1150
         readwrite property the setter would have the opposite
1151
         requirement - ie that the superclass type is more specialized
1152
         then the subclass one; hence the only way to satisfy both
1153
         constraints is that the types match.  */
1154
 
1155
      /* If the types are not the same in the C sense, we warn ...  */
1156
      if (!comptypes (TREE_TYPE (x), TREE_TYPE (decl))
1157
          /* ... unless the property is readonly, in which case we
1158
             allow a new, more specialized, declaration.  */
1159
          && (!property_readonly
1160
              || !objc_compare_types (TREE_TYPE (x),
1161
                                      TREE_TYPE (decl), -5, NULL_TREE)))
1162
        {
1163
          warning_at (location, 0,
1164
                      "type of property %qD conflicts with previous declaration", decl);
1165
          if (original_location != UNKNOWN_LOCATION)
1166
            inform (original_location, "originally specified here");
1167
          return;
1168
        }
1169
 
1170
      /* If we are in a class extension and we're extending a readonly
1171
         property in the main @interface, we'll just update the
1172
         existing property with the readwrite flag and potentially the
1173
         new setter name.  */
1174
      if (property_extension_in_class_extension)
1175
        {
1176
          PROPERTY_READONLY (x) = 0;
1177
          PROPERTY_SETTER_NAME (x) = parsed_property_setter_ident;
1178
          return;
1179
        }
1180
    }
1181
 
1182
  /* Create a PROPERTY_DECL node.  */
1183
  property_decl = make_node (PROPERTY_DECL);
1184
 
1185
  /* Copy the basic information from the original decl.  */
1186
  TREE_TYPE (property_decl) = TREE_TYPE (decl);
1187
  DECL_SOURCE_LOCATION (property_decl) = DECL_SOURCE_LOCATION (decl);
1188
  TREE_DEPRECATED (property_decl) = TREE_DEPRECATED (decl);
1189
 
1190
  /* Add property-specific information.  */
1191
  PROPERTY_NAME (property_decl) = DECL_NAME (decl);
1192
  PROPERTY_GETTER_NAME (property_decl) = parsed_property_getter_ident;
1193
  PROPERTY_SETTER_NAME (property_decl) = parsed_property_setter_ident;
1194
  PROPERTY_READONLY (property_decl) = property_readonly;
1195
  PROPERTY_NONATOMIC (property_decl) = parsed_property_nonatomic;
1196
  PROPERTY_ASSIGN_SEMANTICS (property_decl) = property_assign_semantics;
1197
  PROPERTY_IVAR_NAME (property_decl) = NULL_TREE;
1198
  PROPERTY_DYNAMIC (property_decl) = 0;
1199
 
1200
  /* Remember the fact that the property was found in the @optional
1201
     section in a @protocol, or not.  */
1202
  if (objc_method_optional_flag)
1203
    PROPERTY_OPTIONAL (property_decl) = 1;
1204
  else
1205
    PROPERTY_OPTIONAL (property_decl) = 0;
1206
 
1207
  /* Note that PROPERTY_GETTER_NAME is always set for all
1208
     PROPERTY_DECLs, and PROPERTY_SETTER_NAME is always set for all
1209
     PROPERTY_DECLs where PROPERTY_READONLY == 0.  Any time we deal
1210
     with a getter or setter, we should get the PROPERTY_DECL and use
1211
     PROPERTY_GETTER_NAME and PROPERTY_SETTER_NAME to know the correct
1212
     names.  */
1213
 
1214
  /* Add the PROPERTY_DECL to the list of properties for the class.  */
1215
  TREE_CHAIN (property_decl) = CLASS_PROPERTY_DECL (objc_interface_context);
1216
  CLASS_PROPERTY_DECL (objc_interface_context) = property_decl;
1217
}
1218
 
1219
/* This is a subroutine of objc_maybe_build_component_ref.  Search the
1220
   list of methods in the interface (and, failing that, the local list
1221
   in the implementation, and failing that, the protocol list)
1222
   provided for a 'setter' or 'getter' for 'component' with default
1223
   names (ie, if 'component' is "name", then search for "name" and
1224
   "setName:").  It is also possible to specify a different
1225
   'getter_name' (this is used for @optional readonly properties).  If
1226
   any is found, then create an artificial property that uses them.
1227
   Return NULL_TREE if 'getter' or 'setter' could not be found.  */
1228
static tree
1229
maybe_make_artificial_property_decl (tree interface, tree implementation,
1230
                                     tree protocol_list, tree component, bool is_class,
1231
                                     tree getter_name)
1232
{
1233
  tree setter_name = get_identifier (objc_build_property_setter_name (component));
1234
  tree getter = NULL_TREE;
1235
  tree setter = NULL_TREE;
1236
 
1237
  if (getter_name == NULL_TREE)
1238
    getter_name = component;
1239
 
1240
  /* First, check the @interface and all superclasses.  */
1241
  if (interface)
1242
    {
1243
      int flags = 0;
1244
 
1245
      /* Using instance methods of the root class as accessors is most
1246
         likely unwanted and can be extremely confusing (and, most
1247
         importantly, other Objective-C 2.0 compilers do not do it).
1248
         Turn it off.  */
1249
      if (is_class)
1250
        flags = OBJC_LOOKUP_CLASS | OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS;
1251
 
1252
      getter = lookup_method_static (interface, getter_name, flags);
1253
      setter = lookup_method_static (interface, setter_name, flags);
1254
    }
1255
 
1256
  /* Second, check the local @implementation context.  */
1257
  if (!getter && !setter)
1258
    {
1259
      if (implementation)
1260
        {
1261
          if (is_class)
1262
            {
1263
              getter = lookup_method (CLASS_CLS_METHODS (implementation), getter_name);
1264
              setter = lookup_method (CLASS_CLS_METHODS (implementation), setter_name);
1265
            }
1266
          else
1267
            {
1268
              getter = lookup_method (CLASS_NST_METHODS (implementation), getter_name);
1269
              setter = lookup_method (CLASS_NST_METHODS (implementation), setter_name);
1270
            }
1271
        }
1272
    }
1273
 
1274
  /* Try the protocol_list if we didn't find anything in the
1275
     @interface and in the @implementation.  */
1276
  if (!getter && !setter)
1277
    {
1278
      getter = lookup_method_in_protocol_list (protocol_list, getter_name, is_class);
1279
      setter = lookup_method_in_protocol_list (protocol_list, setter_name, is_class);
1280
    }
1281
 
1282
  /* There needs to be at least a getter or setter for this to be a
1283
     valid 'object.component' syntax.  */
1284
  if (getter || setter)
1285
    {
1286
      /* Yes ... determine the type of the expression.  */
1287
      tree property_decl;
1288
      tree type;
1289
 
1290
      if (getter)
1291
        type = TREE_VALUE (TREE_TYPE (getter));
1292
      else
1293
        type = TREE_VALUE (TREE_TYPE (METHOD_SEL_ARGS (setter)));
1294
 
1295
      /* Create an artificial property declaration with the
1296
         information we collected on the type and getter/setter
1297
         names.  */
1298
      property_decl = make_node (PROPERTY_DECL);
1299
 
1300
      TREE_TYPE (property_decl) = type;
1301
      DECL_SOURCE_LOCATION (property_decl) = input_location;
1302
      TREE_DEPRECATED (property_decl) = 0;
1303
      DECL_ARTIFICIAL (property_decl) = 1;
1304
 
1305
      /* Add property-specific information.  Note that one of
1306
         PROPERTY_GETTER_NAME or PROPERTY_SETTER_NAME may refer to a
1307
         non-existing method; this will generate an error when the
1308
         expression is later compiled.  At this stage we don't know if
1309
         the getter or setter will be used, so we can't generate an
1310
         error.  */
1311
      PROPERTY_NAME (property_decl) = component;
1312
      PROPERTY_GETTER_NAME (property_decl) = getter_name;
1313
      PROPERTY_SETTER_NAME (property_decl) = setter_name;
1314
      PROPERTY_READONLY (property_decl) = 0;
1315
      PROPERTY_NONATOMIC (property_decl) = 0;
1316
      PROPERTY_ASSIGN_SEMANTICS (property_decl) = 0;
1317
      PROPERTY_IVAR_NAME (property_decl) = NULL_TREE;
1318
      PROPERTY_DYNAMIC (property_decl) = 0;
1319
      PROPERTY_OPTIONAL (property_decl) = 0;
1320
 
1321
      if (!getter)
1322
        PROPERTY_HAS_NO_GETTER (property_decl) = 1;
1323
 
1324
      /* The following is currently unused, but it's nice to have
1325
         there.  We may use it if we need in the future.  */
1326
      if (!setter)
1327
        PROPERTY_HAS_NO_SETTER (property_decl) = 1;
1328
 
1329
      return property_decl;
1330
    }
1331
 
1332
  return NULL_TREE;
1333
}
1334
 
1335
/* This hook routine is invoked by the parser when an expression such
1336
   as 'xxx.yyy' is parsed.  We get a chance to process these
1337
   expressions in a way that is specified to Objective-C (to implement
1338
   the Objective-C 2.0 dot-syntax, properties, or non-fragile ivars).
1339
   If the expression is not an Objective-C specified expression, we
1340
   should return NULL_TREE; else we return the expression.
1341
 
1342
   At the moment this only implements dot-syntax and properties (not
1343
   non-fragile ivars yet), ie 'object.property' or 'object.component'
1344
   where 'component' is not a declared property, but a valid getter or
1345
   setter for it could be found.  */
1346
tree
1347
objc_maybe_build_component_ref (tree object, tree property_ident)
1348
{
1349
  tree x = NULL_TREE;
1350
  tree rtype;
1351
 
1352
  /* If we are in Objective-C 1.0 mode, dot-syntax and properties are
1353
     not available.  */
1354
  if (flag_objc1_only)
1355
    return NULL_TREE;
1356
 
1357
  /* Try to determine if 'object' is an Objective-C object or not.  If
1358
     not, return.  */
1359
  if (object == NULL_TREE || object == error_mark_node
1360
      || (rtype = TREE_TYPE (object)) == NULL_TREE)
1361
    return NULL_TREE;
1362
 
1363
  if (property_ident == NULL_TREE || property_ident == error_mark_node
1364
      || TREE_CODE (property_ident) != IDENTIFIER_NODE)
1365
    return NULL_TREE;
1366
 
1367
  /* The following analysis of 'object' is similar to the one used for
1368
     the 'receiver' of a method invocation.  We need to determine what
1369
     'object' is and find the appropriate property (either declared,
1370
     or artificial) for it (in the same way as we need to find the
1371
     appropriate method prototype for a method invocation).  There are
1372
     some simplifications here though: "object.property" is invalid if
1373
     "object" has a type of "id" or "Class"; it must at least have a
1374
     protocol attached to it, and "object" is never a class name as
1375
     that is done by objc_build_class_component_ref.  Finally, we
1376
     don't know if this really is a dot-syntax expression, so we want
1377
     to make a quick exit if it is not; for this reason, we try to
1378
     postpone checks after determining that 'object' looks like an
1379
     Objective-C object.  */
1380
 
1381
  if (objc_is_id (rtype))
1382
    {
1383
      /* This is the case that the 'object' is of type 'id' or
1384
         'Class'.  */
1385
 
1386
      /* Check if at least it is of type 'id <Protocol>' or 'Class
1387
         <Protocol>'; if so, look the property up in the
1388
         protocols.  */
1389
      if (TYPE_HAS_OBJC_INFO (TREE_TYPE (rtype)))
1390
        {
1391
          tree rprotos = TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (rtype));
1392
 
1393
          if (rprotos)
1394
            {
1395
              /* No point looking up declared @properties if we are
1396
                 dealing with a class.  Classes have no declared
1397
                 properties.  */
1398
              if (!IS_CLASS (rtype))
1399
                x = lookup_property_in_protocol_list (rprotos, property_ident);
1400
 
1401
              if (x == NULL_TREE)
1402
                {
1403
                  /* Ok, no property.  Maybe it was an
1404
                     object.component dot-syntax without a declared
1405
                     property (this is valid for classes too).  Look
1406
                     for getter/setter methods and internally declare
1407
                     an artifical property based on them if found.  */
1408
                  x = maybe_make_artificial_property_decl (NULL_TREE,
1409
                                                           NULL_TREE,
1410
                                                           rprotos,
1411
                                                           property_ident,
1412
                                                           IS_CLASS (rtype),
1413
                                                           NULL_TREE);
1414
                }
1415
              else if (PROPERTY_OPTIONAL (x) && PROPERTY_READONLY (x))
1416
                {
1417
                  /* This is a special, complicated case.  If the
1418
                     property is optional, and is read-only, then the
1419
                     property is always used for reading, but an
1420
                     eventual existing non-property setter can be used
1421
                     for writing.  We create an artificial property
1422
                     decl copying the getter from the optional
1423
                     property, and looking up the setter in the
1424
                     interface.  */
1425
                  x = maybe_make_artificial_property_decl (NULL_TREE,
1426
                                                           NULL_TREE,
1427
                                                           rprotos,
1428
                                                           property_ident,
1429
                                                           false,
1430
                                                           PROPERTY_GETTER_NAME (x));
1431
                }
1432
            }
1433
        }
1434
      else if (objc_method_context)
1435
        {
1436
          /* Else, if we are inside a method it could be the case of
1437
             'super' or 'self'.  */
1438
          tree interface_type = NULL_TREE;
1439
          tree t = object;
1440
          while (TREE_CODE (t) == COMPOUND_EXPR
1441
                 || TREE_CODE (t) == MODIFY_EXPR
1442
                 || CONVERT_EXPR_P (t)
1443
                 || TREE_CODE (t) == COMPONENT_REF)
1444
            t = TREE_OPERAND (t, 0);
1445
 
1446
          if (t == UOBJC_SUPER_decl)
1447
            interface_type = lookup_interface (CLASS_SUPER_NAME (implementation_template));
1448
          else if (t == self_decl)
1449
            interface_type = lookup_interface (CLASS_NAME (implementation_template));
1450
 
1451
          if (interface_type)
1452
            {
1453
              if (TREE_CODE (objc_method_context) != CLASS_METHOD_DECL)
1454
                x = lookup_property (interface_type, property_ident);
1455
 
1456
              if (x == NULL_TREE)
1457
                {
1458
                  /* Try the dot-syntax without a declared property.
1459
                     If this is an access to 'self', it is possible
1460
                     that they may refer to a setter/getter that is
1461
                     not declared in the interface, but exists locally
1462
                     in the implementation.  In that case, get the
1463
                     implementation context and use it.  */
1464
                  tree implementation = NULL_TREE;
1465
 
1466
                  if (t == self_decl)
1467
                    implementation = objc_implementation_context;
1468
 
1469
                  x = maybe_make_artificial_property_decl
1470
                    (interface_type, implementation, NULL_TREE,
1471
                     property_ident,
1472
                     (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL),
1473
                     NULL_TREE);
1474
                }
1475
              else if (PROPERTY_OPTIONAL (x) && PROPERTY_READONLY (x))
1476
                {
1477
                  tree implementation = NULL_TREE;
1478
 
1479
                  if (t == self_decl)
1480
                    implementation = objc_implementation_context;
1481
 
1482
                  x = maybe_make_artificial_property_decl (interface_type,
1483
                                                           implementation,
1484
                                                           NULL_TREE,
1485
                                                           property_ident,
1486
                                                           false,
1487
                                                           PROPERTY_GETTER_NAME (x));
1488
                }
1489
            }
1490
        }
1491
    }
1492
  else
1493
    {
1494
      /* This is the case where we have more information on 'rtype'.  */
1495
      tree basetype = TYPE_MAIN_VARIANT (rtype);
1496
 
1497
      /* Skip the pointer - if none, it's not an Objective-C object or
1498
         class.  */
1499
      if (basetype != NULL_TREE && TREE_CODE (basetype) == POINTER_TYPE)
1500
        basetype = TREE_TYPE (basetype);
1501
      else
1502
        return NULL_TREE;
1503
 
1504
      /* Traverse typedefs.  */
1505
      while (basetype != NULL_TREE
1506
             && TREE_CODE (basetype) == RECORD_TYPE
1507
             && OBJC_TYPE_NAME (basetype)
1508
             && TREE_CODE (OBJC_TYPE_NAME (basetype)) == TYPE_DECL
1509
             && DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (basetype)))
1510
        basetype = DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (basetype));
1511
 
1512
      if (basetype != NULL_TREE && TYPED_OBJECT (basetype))
1513
        {
1514
          tree interface_type = TYPE_OBJC_INTERFACE (basetype);
1515
          tree protocol_list = TYPE_OBJC_PROTOCOL_LIST (basetype);
1516
 
1517
          if (interface_type
1518
              && (TREE_CODE (interface_type) == CLASS_INTERFACE_TYPE
1519
                  || TREE_CODE (interface_type) == CATEGORY_INTERFACE_TYPE
1520
                  || TREE_CODE (interface_type) == PROTOCOL_INTERFACE_TYPE))
1521
            {
1522
              /* Not sure 'rtype' could ever be a class here!  Just
1523
                 for safety we keep the checks.  */
1524
              if (!IS_CLASS (rtype))
1525
                {
1526
                  x = lookup_property (interface_type, property_ident);
1527
 
1528
                  if (x == NULL_TREE)
1529
                    x = lookup_property_in_protocol_list (protocol_list,
1530
                                                          property_ident);
1531
                }
1532
 
1533
              if (x == NULL_TREE)
1534
                {
1535
                  /* Try the dot-syntax without a declared property.
1536
                     If we are inside a method implementation, it is
1537
                     possible that they may refer to a setter/getter
1538
                     that is not declared in the interface, but exists
1539
                     locally in the implementation.  In that case, get
1540
                     the implementation context and use it.  */
1541
                  tree implementation = NULL_TREE;
1542
 
1543
                  if (objc_implementation_context
1544
                      && CLASS_NAME (objc_implementation_context)
1545
                      == OBJC_TYPE_NAME (interface_type))
1546
                    implementation = objc_implementation_context;
1547
 
1548
                  x = maybe_make_artificial_property_decl (interface_type,
1549
                                                           implementation,
1550
                                                           protocol_list,
1551
                                                           property_ident,
1552
                                                           IS_CLASS (rtype),
1553
                                                           NULL_TREE);
1554
                }
1555
              else if (PROPERTY_OPTIONAL (x) && PROPERTY_READONLY (x))
1556
                {
1557
                  tree implementation = NULL_TREE;
1558
 
1559
                  if (objc_implementation_context
1560
                      && CLASS_NAME (objc_implementation_context)
1561
                      == OBJC_TYPE_NAME (interface_type))
1562
                    implementation = objc_implementation_context;
1563
 
1564
                  x = maybe_make_artificial_property_decl (interface_type,
1565
                                                           implementation,
1566
                                                           protocol_list,
1567
                                                           property_ident,
1568
                                                           false,
1569
                                                           PROPERTY_GETTER_NAME (x));
1570
                }
1571
            }
1572
        }
1573
    }
1574
 
1575
  if (x)
1576
    {
1577
      tree expression;
1578
      tree getter_call;
1579
      tree deprecated_method_prototype = NULL_TREE;
1580
 
1581
      /* We have an additional nasty problem here; if this
1582
         PROPERTY_REF needs to become a 'getter', then the conversion
1583
         from PROPERTY_REF into a getter call happens in gimplify,
1584
         after the selector table has already been generated and when
1585
         it is too late to add another selector to it.  To work around
1586
         the problem, we always create the getter call at this stage,
1587
         which puts the selector in the table.  Note that if the
1588
         PROPERTY_REF becomes a 'setter' instead of a 'getter', then
1589
         we have added a selector too many to the selector table.
1590
         This is a little inefficient.
1591
 
1592
         Also note that method calls to 'self' and 'super' require the
1593
         context (self_decl, UOBJS_SUPER_decl,
1594
         objc_implementation_context etc) to be built correctly; this
1595
         is yet another reason why building the call at the gimplify
1596
         stage (when this context has been lost) is not very
1597
         practical.  If we build it at this stage, we know it will
1598
         always be built correctly.
1599
 
1600
         If the PROPERTY_HAS_NO_GETTER() (ie, it is an artificial
1601
         property decl created to deal with a dotsyntax not really
1602
         referring to an existing property) then do not try to build a
1603
         call to the getter as there is no getter.  */
1604
      if (PROPERTY_HAS_NO_GETTER (x))
1605
        getter_call = NULL_TREE;
1606
      else
1607
        getter_call = objc_finish_message_expr
1608
          (object, PROPERTY_GETTER_NAME (x), NULL_TREE,
1609
           /* Disable the immediate deprecation warning if the getter
1610
              is deprecated, but record the fact that the getter is
1611
              deprecated by setting PROPERTY_REF_DEPRECATED_GETTER to
1612
              the method prototype.  */
1613
           &deprecated_method_prototype);
1614
 
1615
      expression = build4 (PROPERTY_REF, TREE_TYPE(x), object, x, getter_call,
1616
                           deprecated_method_prototype);
1617
      SET_EXPR_LOCATION (expression, input_location);
1618
      TREE_SIDE_EFFECTS (expression) = 1;
1619
 
1620
      return expression;
1621
    }
1622
 
1623
  return NULL_TREE;
1624
}
1625
 
1626
/* This hook routine is invoked by the parser when an expression such
1627
   as 'xxx.yyy' is parsed, and 'xxx' is a class name.  This is the
1628
   Objective-C 2.0 dot-syntax applied to classes, so we need to
1629
   convert it into a setter/getter call on the class.  */
1630
tree
1631
objc_build_class_component_ref (tree class_name, tree property_ident)
1632
{
1633
  tree x = NULL_TREE;
1634
  tree object, rtype;
1635
 
1636
  if (flag_objc1_only)
1637
    error_at (input_location, "the dot syntax is not available in Objective-C 1.0");
1638
 
1639
  if (class_name == NULL_TREE || class_name == error_mark_node
1640
      || TREE_CODE (class_name) != IDENTIFIER_NODE)
1641
    return error_mark_node;
1642
 
1643
  if (property_ident == NULL_TREE || property_ident == error_mark_node
1644
      || TREE_CODE (property_ident) != IDENTIFIER_NODE)
1645
    return NULL_TREE;
1646
 
1647
  object = objc_get_class_reference (class_name);
1648
  if (!object)
1649
    {
1650
      /* We know that 'class_name' is an Objective-C class name as the
1651
         parser won't call this function if it is not.  This is only a
1652
         double-check for safety.  */
1653
      error_at (input_location, "could not find class %qE", class_name);
1654
      return error_mark_node;
1655
    }
1656
 
1657
  rtype = lookup_interface (class_name);
1658
  if (!rtype)
1659
    {
1660
      /* Again, this should never happen, but we do check.  */
1661
      error_at (input_location, "could not find interface for class %qE", class_name);
1662
      return error_mark_node;
1663
    }
1664
  else
1665
    {
1666
      if (TREE_DEPRECATED (rtype))
1667
        warning (OPT_Wdeprecated_declarations, "class %qE is deprecated", class_name);
1668
    }
1669
 
1670
  x = maybe_make_artificial_property_decl (rtype, NULL_TREE, NULL_TREE,
1671
                                           property_ident,
1672
                                           true, NULL_TREE);
1673
 
1674
  if (x)
1675
    {
1676
      tree expression;
1677
      tree getter_call;
1678
      tree deprecated_method_prototype = NULL_TREE;
1679
 
1680
      if (PROPERTY_HAS_NO_GETTER (x))
1681
        getter_call = NULL_TREE;
1682
      else
1683
        getter_call = objc_finish_message_expr
1684
          (object, PROPERTY_GETTER_NAME (x), NULL_TREE,
1685
           &deprecated_method_prototype);
1686
 
1687
      expression = build4 (PROPERTY_REF, TREE_TYPE(x), object, x, getter_call,
1688
                           deprecated_method_prototype);
1689
      SET_EXPR_LOCATION (expression, input_location);
1690
      TREE_SIDE_EFFECTS (expression) = 1;
1691
 
1692
      return expression;
1693
    }
1694
  else
1695
    {
1696
      error_at (input_location, "could not find setter/getter for %qE in class %qE",
1697
                property_ident, class_name);
1698
      return error_mark_node;
1699
    }
1700
 
1701
  return NULL_TREE;
1702
}
1703
 
1704
 
1705
 
1706
/* This is used because we don't want to expose PROPERTY_REF to the
1707
   C/C++ frontends.  Maybe we should!  */
1708
bool
1709
objc_is_property_ref (tree node)
1710
{
1711
  if (node  &&  TREE_CODE (node) == PROPERTY_REF)
1712
    return true;
1713
  else
1714
    return false;
1715
}
1716
 
1717
/* This function builds a setter call for a PROPERTY_REF (real, for a
1718
   declared property, or artificial, for a dot-syntax accessor which
1719
   is not corresponding to a property).  'lhs' must be a PROPERTY_REF
1720
   (the caller must check this beforehand).  'rhs' is the value to
1721
   assign to the property.  A plain setter call is returned, or
1722
   error_mark_node if the property is readonly.  */
1723
 
1724
static tree
1725
objc_build_setter_call (tree lhs, tree rhs)
1726
{
1727
  tree object_expr = PROPERTY_REF_OBJECT (lhs);
1728
  tree property_decl = PROPERTY_REF_PROPERTY_DECL (lhs);
1729
 
1730
  if (PROPERTY_READONLY (property_decl))
1731
    {
1732
      error ("readonly property can not be set");
1733
      return error_mark_node;
1734
    }
1735
  else
1736
    {
1737
      tree setter_argument = build_tree_list (NULL_TREE, rhs);
1738
      tree setter;
1739
 
1740
      /* TODO: Check that the setter return type is 'void'.  */
1741
 
1742
      /* TODO: Decay arguments in C.  */
1743
      setter = objc_finish_message_expr (object_expr,
1744
                                         PROPERTY_SETTER_NAME (property_decl),
1745
                                         setter_argument, NULL);
1746
      return setter;
1747
    }
1748
 
1749
  /* Unreachable, but the compiler may not realize.  */
1750
  return error_mark_node;
1751
}
1752
 
1753
/* This hook routine is called when a MODIFY_EXPR is being built.  We
1754
   check what is being modified; if it is a PROPERTY_REF, we need to
1755
   generate a 'setter' function call for the property.  If this is not
1756
   a PROPERTY_REF, we return NULL_TREE and the C/C++ frontend will go
1757
   on creating their MODIFY_EXPR.
1758
 
1759
   This is used for example if you write
1760
 
1761
   object.count = 1;
1762
 
1763
   where 'count' is a property.  The left-hand side creates a
1764
   PROPERTY_REF, and then the compiler tries to generate a MODIFY_EXPR
1765
   to assign something to it.  We intercept that here, and generate a
1766
   call to the 'setter' method instead.  */
1767
tree
1768
objc_maybe_build_modify_expr (tree lhs, tree rhs)
1769
{
1770
  if (lhs && TREE_CODE (lhs) == PROPERTY_REF)
1771
    {
1772
      /* Building a simple call to the setter method would work for cases such as
1773
 
1774
      object.count = 1;
1775
 
1776
      but wouldn't work for cases such as
1777
 
1778
      count = object2.count = 1;
1779
 
1780
      to get these to work with very little effort, we build a
1781
      compound statement which does the setter call (to set the
1782
      property to 'rhs'), but which can also be evaluated returning
1783
      the 'rhs'.  If the 'rhs' has no side effects, we can simply
1784
      evaluate it twice, building
1785
 
1786
      ([object setProperty: rhs]; rhs)
1787
 
1788
      If it has side effects, we put it in a temporary variable first,
1789
      so we create the following:
1790
 
1791
      (temp = rhs; [object setProperty: temp]; temp)
1792
 
1793
      setter_argument is rhs in the first case, and temp in the second
1794
      case.
1795
      */
1796
      tree setter_argument;
1797
 
1798
      /* s1, s2 and s3 are the tree statements that we need in the
1799
         compound expression.  */
1800
      tree s1, s2, s3, compound_expr;
1801
 
1802
      if (TREE_SIDE_EFFECTS (rhs))
1803
        {
1804
          tree bind;
1805
 
1806
          /* Declare __objc_property_temp in a local bind.  */
1807
          setter_argument = objc_create_temporary_var (TREE_TYPE (rhs), "__objc_property_temp");
1808
          DECL_SOURCE_LOCATION (setter_argument) = input_location;
1809
          bind = build3 (BIND_EXPR, void_type_node, setter_argument, NULL, NULL);
1810
          SET_EXPR_LOCATION (bind, input_location);
1811
          TREE_SIDE_EFFECTS (bind) = 1;
1812
          add_stmt (bind);
1813
 
1814
          /* s1: x = rhs */
1815
          s1 = build_modify_expr (input_location, setter_argument, NULL_TREE,
1816
                                  NOP_EXPR,
1817
                                  input_location, rhs, NULL_TREE);
1818
          SET_EXPR_LOCATION (s1, input_location);
1819
        }
1820
      else
1821
        {
1822
          /* No s1.  */
1823
          setter_argument = rhs;
1824
          s1 = NULL_TREE;
1825
        }
1826
 
1827
      /* Now build the compound statement.  */
1828
 
1829
      /* s2: [object setProperty: x] */
1830
      s2 = objc_build_setter_call (lhs, setter_argument);
1831
 
1832
      /* This happens if building the setter failed because the
1833
         property is readonly.  */
1834
      if (s2 == error_mark_node)
1835
        return error_mark_node;
1836
 
1837
      SET_EXPR_LOCATION (s2, input_location);
1838
 
1839
      /* s3: x */
1840
      s3 = convert (TREE_TYPE (lhs), setter_argument);
1841
 
1842
      /* Now build the compound statement (s1, s2, s3) or (s2, s3) as
1843
         appropriate.  */
1844
      if (s1)
1845
        compound_expr = build_compound_expr (input_location, build_compound_expr (input_location, s1, s2), s3);
1846
      else
1847
        compound_expr = build_compound_expr (input_location, s2, s3);
1848
 
1849
      /* Without this, with -Wall you get a 'valued computed is not
1850
         used' every time there is a "object.property = x" where the
1851
         value of the resulting MODIFY_EXPR is not used.  That is
1852
         correct (maybe a more sophisticated implementation could
1853
         avoid generating the compound expression if not needed), but
1854
         we need to turn it off.  */
1855
      TREE_NO_WARNING (compound_expr) = 1;
1856
      return compound_expr;
1857
    }
1858
  else
1859
    return NULL_TREE;
1860
}
1861
 
1862
/* This hook is called by the frontend when one of the four unary
1863
   expressions PREINCREMENT_EXPR, POSTINCREMENT_EXPR,
1864
   PREDECREMENT_EXPR and POSTDECREMENT_EXPR is being built with an
1865
   argument which is a PROPERTY_REF.  For example, this happens if you have
1866
 
1867
   object.count++;
1868
 
1869
   where 'count' is a property.  We need to use the 'getter' and
1870
   'setter' for the property in an appropriate way to build the
1871
   appropriate expression.  'code' is the code for the expression (one
1872
   of the four mentioned above); 'argument' is the PROPERTY_REF, and
1873
   'increment' is how much we need to add or subtract.  */
1874
tree
1875
objc_build_incr_expr_for_property_ref (location_t location,
1876
                                       enum tree_code code,
1877
                                       tree argument, tree increment)
1878
{
1879
  /* Here are the expressions that we want to build:
1880
 
1881
     For PREINCREMENT_EXPR / PREDECREMENT_EXPR:
1882
    (temp = [object property] +/- increment, [object setProperty: temp], temp)
1883
 
1884
    For POSTINCREMENT_EXPR / POSTECREMENT_EXPR:
1885
    (temp = [object property], [object setProperty: temp +/- increment], temp) */
1886
 
1887
  tree temp_variable_decl, bind;
1888
  /* s1, s2 and s3 are the tree statements that we need in the
1889
     compound expression.  */
1890
  tree s1, s2, s3, compound_expr;
1891
 
1892
  /* Safety check.  */
1893
  if (!argument || TREE_CODE (argument) != PROPERTY_REF)
1894
    return error_mark_node;
1895
 
1896
  /* Declare __objc_property_temp in a local bind.  */
1897
  temp_variable_decl = objc_create_temporary_var (TREE_TYPE (argument), "__objc_property_temp");
1898
  DECL_SOURCE_LOCATION (temp_variable_decl) = location;
1899
  bind = build3 (BIND_EXPR, void_type_node, temp_variable_decl, NULL, NULL);
1900
  SET_EXPR_LOCATION (bind, location);
1901
  TREE_SIDE_EFFECTS (bind) = 1;
1902
  add_stmt (bind);
1903
 
1904
  /* Now build the compound statement.  */
1905
 
1906
  /* Note that the 'getter' is generated at gimplify time; at this
1907
     time, we can simply put the property_ref (ie, argument) wherever
1908
     we want the getter ultimately to be.  */
1909
 
1910
  /* s1: __objc_property_temp = [object property] <+/- increment> */
1911
  switch (code)
1912
    {
1913
    case PREINCREMENT_EXPR:
1914
      /* __objc_property_temp = [object property] + increment */
1915
      s1 = build_modify_expr (location, temp_variable_decl, NULL_TREE,
1916
                              NOP_EXPR,
1917
                              location, build2 (PLUS_EXPR, TREE_TYPE (argument),
1918
                                                argument, increment), NULL_TREE);
1919
      break;
1920
    case PREDECREMENT_EXPR:
1921
      /* __objc_property_temp = [object property] - increment */
1922
      s1 = build_modify_expr (location, temp_variable_decl, NULL_TREE,
1923
                              NOP_EXPR,
1924
                              location, build2 (MINUS_EXPR, TREE_TYPE (argument),
1925
                                                argument, increment), NULL_TREE);
1926
      break;
1927
    case POSTINCREMENT_EXPR:
1928
    case POSTDECREMENT_EXPR:
1929
      /* __objc_property_temp = [object property] */
1930
      s1 = build_modify_expr (location, temp_variable_decl, NULL_TREE,
1931
                              NOP_EXPR,
1932
                              location, argument, NULL_TREE);
1933
      break;
1934
    default:
1935
      gcc_unreachable ();
1936
    }
1937
 
1938
  /* s2: [object setProperty: __objc_property_temp <+/- increment>] */
1939
  switch (code)
1940
    {
1941
    case PREINCREMENT_EXPR:
1942
    case PREDECREMENT_EXPR:
1943
      /* [object setProperty: __objc_property_temp] */
1944
      s2 = objc_build_setter_call (argument, temp_variable_decl);
1945
      break;
1946
    case POSTINCREMENT_EXPR:
1947
      /* [object setProperty: __objc_property_temp + increment] */
1948
      s2 = objc_build_setter_call (argument,
1949
                                   build2 (PLUS_EXPR, TREE_TYPE (argument),
1950
                                           temp_variable_decl, increment));
1951
      break;
1952
    case POSTDECREMENT_EXPR:
1953
      /* [object setProperty: __objc_property_temp - increment] */
1954
      s2 = objc_build_setter_call (argument,
1955
                                   build2 (MINUS_EXPR, TREE_TYPE (argument),
1956
                                           temp_variable_decl, increment));
1957
      break;
1958
    default:
1959
      gcc_unreachable ();
1960
    }
1961
 
1962
  /* This happens if building the setter failed because the property
1963
     is readonly.  */
1964
  if (s2 == error_mark_node)
1965
    return error_mark_node;
1966
 
1967
  SET_EXPR_LOCATION (s2, location);
1968
 
1969
  /* s3: __objc_property_temp */
1970
  s3 = convert (TREE_TYPE (argument), temp_variable_decl);
1971
 
1972
  /* Now build the compound statement (s1, s2, s3) */
1973
  compound_expr = build_compound_expr (location, build_compound_expr (location, s1, s2), s3);
1974
 
1975
  /* Prevent C++ from warning with -Wall that "right operand of comma
1976
     operator has no effect".  */
1977
  TREE_NO_WARNING (compound_expr) = 1;
1978
  return compound_expr;
1979
}
1980
 
1981
tree
1982
objc_build_method_signature (bool is_class_method, tree rettype, tree selector,
1983
                             tree optparms, bool ellipsis)
1984
{
1985
  if (is_class_method)
1986
    return build_method_decl (CLASS_METHOD_DECL, rettype, selector,
1987
                              optparms, ellipsis);
1988
  else
1989
    return build_method_decl (INSTANCE_METHOD_DECL, rettype, selector,
1990
                              optparms, ellipsis);
1991
}
1992
 
1993
void
1994
objc_add_method_declaration (bool is_class_method, tree decl, tree attributes)
1995
{
1996
  if (!objc_interface_context)
1997
    {
1998
      /* PS: At the moment, due to how the parser works, it should be
1999
         impossible to get here.  But it's good to have the check in
2000
         case the parser changes.
2001
      */
2002
      fatal_error ("method declaration not in @interface context");
2003
    }
2004
 
2005
  if (flag_objc1_only && attributes)
2006
    error_at (input_location, "method attributes are not available in Objective-C 1.0");
2007
 
2008
  objc_decl_method_attributes (&decl, attributes, 0);
2009
  objc_add_method (objc_interface_context,
2010
                   decl,
2011
                   is_class_method,
2012
                   objc_method_optional_flag);
2013
}
2014
 
2015
/* Return 'true' if the method definition could be started, and
2016
   'false' if not (because we are outside an @implementation context).
2017
   EXPR is NULL or an expression that needs to be evaluated for the
2018
   side effects of array size expressions in the parameters.
2019
*/
2020
bool
2021
objc_start_method_definition (bool is_class_method, tree decl, tree attributes,
2022
                              tree expr)
2023
{
2024
  if (!objc_implementation_context)
2025
    {
2026
      error ("method definition not in @implementation context");
2027
      return false;
2028
    }
2029
 
2030
  if (decl != NULL_TREE  && METHOD_SEL_NAME (decl) == error_mark_node)
2031
    return false;
2032
 
2033
#ifndef OBJCPLUS
2034
  /* Indicate no valid break/continue context by setting these variables
2035
     to some non-null, non-label value.  We'll notice and emit the proper
2036
     error message in c_finish_bc_stmt.  */
2037
  c_break_label = c_cont_label = size_zero_node;
2038
#endif
2039
 
2040
  if (attributes)
2041
    warning_at (input_location, 0, "method attributes can not be specified in @implementation context");
2042
  else
2043
    objc_decl_method_attributes (&decl, attributes, 0);
2044
 
2045
  objc_add_method (objc_implementation_context,
2046
                   decl,
2047
                   is_class_method,
2048
                   /* is optional */ false);
2049
  start_method_def (decl, expr);
2050
  return true;
2051
}
2052
 
2053
void
2054
objc_add_instance_variable (tree decl)
2055
{
2056
  (void) add_instance_variable (objc_ivar_context,
2057
                                objc_ivar_visibility,
2058
                                decl);
2059
}
2060
 
2061
/* Construct a C struct with same name as KLASS, a base struct with tag
2062
   SUPER_NAME (if any), and FIELDS indicated.  */
2063
 
2064
static tree
2065
objc_build_struct (tree klass, tree fields, tree super_name)
2066
{
2067
  tree name = CLASS_NAME (klass);
2068
  tree s = objc_start_struct (name);
2069
  tree super = (super_name ? xref_tag (RECORD_TYPE, super_name) : NULL_TREE);
2070
  tree t;
2071
  VEC(tree,heap) *objc_info = NULL;
2072
  int i;
2073
 
2074
  if (super)
2075
    {
2076
      /* Prepend a packed variant of the base class into the layout.  This
2077
         is necessary to preserve ObjC ABI compatibility.  */
2078
      tree base = build_decl (input_location,
2079
                              FIELD_DECL, NULL_TREE, super);
2080
      tree field = TYPE_FIELDS (super);
2081
 
2082
      while (field && DECL_CHAIN (field)
2083
             && TREE_CODE (DECL_CHAIN (field)) == FIELD_DECL)
2084
        field = DECL_CHAIN (field);
2085
 
2086
      /* For ObjC ABI purposes, the "packed" size of a base class is
2087
         the sum of the offset and the size (in bits) of the last field
2088
         in the class.  */
2089
      DECL_SIZE (base)
2090
        = (field && TREE_CODE (field) == FIELD_DECL
2091
           ? size_binop (PLUS_EXPR,
2092
                         size_binop (PLUS_EXPR,
2093
                                     size_binop
2094
                                     (MULT_EXPR,
2095
                                      convert (bitsizetype,
2096
                                               DECL_FIELD_OFFSET (field)),
2097
                                      bitsize_int (BITS_PER_UNIT)),
2098
                                     DECL_FIELD_BIT_OFFSET (field)),
2099
                         DECL_SIZE (field))
2100
           : bitsize_zero_node);
2101
      DECL_SIZE_UNIT (base)
2102
        = size_binop (FLOOR_DIV_EXPR, convert (sizetype, DECL_SIZE (base)),
2103
                      size_int (BITS_PER_UNIT));
2104
      DECL_ARTIFICIAL (base) = 1;
2105
      DECL_ALIGN (base) = 1;
2106
      DECL_FIELD_CONTEXT (base) = s;
2107
#ifdef OBJCPLUS
2108
      DECL_FIELD_IS_BASE (base) = 1;
2109
 
2110
      if (fields)
2111
        TREE_NO_WARNING (fields) = 1;   /* Suppress C++ ABI warnings -- we   */
2112
#endif                                  /* are following the ObjC ABI here.  */
2113
      DECL_CHAIN (base) = fields;
2114
      fields = base;
2115
    }
2116
 
2117
  /* NB: Calling finish_struct() may cause type TYPE_OBJC_INFO
2118
     information in all variants of this RECORD_TYPE to be destroyed
2119
     (this is because the C frontend manipulates TYPE_LANG_SPECIFIC
2120
     for something else and then will change all variants to use the
2121
     same resulting TYPE_LANG_SPECIFIC, ignoring the fact that we use
2122
     it for ObjC protocols and that such propagation will make all
2123
     variants use the same objc_info), but it is therein that we store
2124
     protocol conformance info (e.g., 'NSObject <MyProtocol>').
2125
     Hence, we must save the ObjC-specific information before calling
2126
     finish_struct(), and then reinstate it afterwards.  */
2127
 
2128
  for (t = TYPE_MAIN_VARIANT (s); t; t = TYPE_NEXT_VARIANT (t))
2129
    {
2130
      INIT_TYPE_OBJC_INFO (t);
2131
      VEC_safe_push (tree, heap, objc_info, TYPE_OBJC_INFO (t));
2132
    }
2133
 
2134
  s = objc_finish_struct (s, fields);
2135
 
2136
  for (i = 0, t = TYPE_MAIN_VARIANT (s); t; t = TYPE_NEXT_VARIANT (t), i++)
2137
    {
2138
      /* We now want to restore the different TYPE_OBJC_INFO, but we
2139
         have the additional problem that the C frontend doesn't just
2140
         copy TYPE_LANG_SPECIFIC from one variant to the other; it
2141
         actually makes all of them the *same* TYPE_LANG_SPECIFIC.  As
2142
         we need a different TYPE_OBJC_INFO for each (and
2143
         TYPE_OBJC_INFO is a field in TYPE_LANG_SPECIFIC), we need to
2144
         make a copy of each TYPE_LANG_SPECIFIC before we modify
2145
         TYPE_OBJC_INFO.  */
2146
      if (TYPE_LANG_SPECIFIC (t))
2147
        {
2148
          /* Create a copy of TYPE_LANG_SPECIFIC.  */
2149
          struct lang_type *old_lang_type = TYPE_LANG_SPECIFIC (t);
2150
          ALLOC_OBJC_TYPE_LANG_SPECIFIC (t);
2151
          memcpy (TYPE_LANG_SPECIFIC (t), old_lang_type,
2152
                  SIZEOF_OBJC_TYPE_LANG_SPECIFIC);
2153
        }
2154
      else
2155
        {
2156
          /* Just create a new one.  */
2157
          ALLOC_OBJC_TYPE_LANG_SPECIFIC (t);
2158
        }
2159
      /* Replace TYPE_OBJC_INFO with the saved one.  This restores any
2160
         protocol information that may have been associated with the
2161
         type.  */
2162
      TYPE_OBJC_INFO (t) = VEC_index (tree, objc_info, i);
2163
      /* Replace the IDENTIFIER_NODE with an actual @interface now
2164
         that we have it.  */
2165
      TYPE_OBJC_INTERFACE (t) = klass;
2166
    }
2167
  VEC_free (tree, heap, objc_info);
2168
 
2169
  /* Use TYPE_BINFO structures to point at the super class, if any.  */
2170
  objc_xref_basetypes (s, super);
2171
 
2172
  /* Mark this struct as a class template.  */
2173
  CLASS_STATIC_TEMPLATE (klass) = s;
2174
 
2175
  return s;
2176
}
2177
 
2178
/* Mark DECL as being 'volatile' for purposes of Darwin
2179
   _setjmp()/_longjmp() exception handling.  Called from
2180
   objc_mark_locals_volatile().  */
2181
void
2182
objc_volatilize_decl (tree decl)
2183
{
2184
  /* Do not mess with variables that are 'static' or (already)
2185
     'volatile'.  */
2186
  if (!TREE_THIS_VOLATILE (decl) && !TREE_STATIC (decl)
2187
      && (TREE_CODE (decl) == VAR_DECL
2188
          || TREE_CODE (decl) == PARM_DECL))
2189
    {
2190
      if (local_variables_to_volatilize == NULL)
2191
        local_variables_to_volatilize = VEC_alloc (tree, gc, 8);
2192
 
2193
      VEC_safe_push (tree, gc, local_variables_to_volatilize, decl);
2194
    }
2195
}
2196
 
2197
/* Called when parsing of a function completes; if any local variables
2198
   in the function were marked as variables to volatilize, change them
2199
   to volatile.  We do this at the end of the function when the
2200
   warnings about discarding 'volatile' have already been produced.
2201
   We are making the variables as volatile just to force the compiler
2202
   to preserve them between setjmp/longjmp, but we don't want warnings
2203
   for them as they aren't really volatile.  */
2204
void
2205
objc_finish_function (void)
2206
{
2207
  /* If there are any local variables to volatilize, volatilize them.  */
2208
  if (local_variables_to_volatilize)
2209
    {
2210
      int i;
2211
      tree decl;
2212
      FOR_EACH_VEC_ELT (tree, local_variables_to_volatilize, i, decl)
2213
        {
2214
          tree t = TREE_TYPE (decl);
2215
 
2216
          t = build_qualified_type (t, TYPE_QUALS (t) | TYPE_QUAL_VOLATILE);
2217
          TREE_TYPE (decl) = t;
2218
          TREE_THIS_VOLATILE (decl) = 1;
2219
          TREE_SIDE_EFFECTS (decl) = 1;
2220
          DECL_REGISTER (decl) = 0;
2221
#ifndef OBJCPLUS
2222
          C_DECL_REGISTER (decl) = 0;
2223
#endif
2224
        }
2225
 
2226
      /* Now we delete the vector.  This sets it to NULL as well.  */
2227
      VEC_free (tree, gc, local_variables_to_volatilize);
2228
    }
2229
}
2230
 
2231
/* Check if protocol PROTO is adopted (directly or indirectly) by class CLS
2232
   (including its categories and superclasses) or by object type TYP.
2233
   Issue a warning if PROTO is not adopted anywhere and WARN is set.  */
2234
 
2235
static bool
2236
objc_lookup_protocol (tree proto, tree cls, tree typ, bool warn)
2237
{
2238
  bool class_type = (cls != NULL_TREE);
2239
 
2240
  while (cls)
2241
    {
2242
      tree c;
2243
 
2244
      /* Check protocols adopted by the class and its categories.  */
2245
      for (c = cls; c; c = CLASS_CATEGORY_LIST (c))
2246
        {
2247
          if (lookup_protocol_in_reflist (CLASS_PROTOCOL_LIST (c), proto))
2248
            return true;
2249
        }
2250
 
2251
      /* Repeat for superclasses.  */
2252
      cls = lookup_interface (CLASS_SUPER_NAME (cls));
2253
    }
2254
 
2255
  /* Check for any protocols attached directly to the object type.  */
2256
  if (TYPE_HAS_OBJC_INFO (typ))
2257
    {
2258
      if (lookup_protocol_in_reflist (TYPE_OBJC_PROTOCOL_LIST (typ), proto))
2259
        return true;
2260
    }
2261
 
2262
  if (warn)
2263
    {
2264
      *errbuf = 0;
2265
      gen_type_name_0 (class_type ? typ : TYPE_POINTER_TO (typ));
2266
      /* NB: Types 'id' and 'Class' cannot reasonably be described as
2267
         "implementing" a given protocol, since they do not have an
2268
         implementation.  */
2269
      if (class_type)
2270
        warning (0, "class %qs does not implement the %qE protocol",
2271
                 identifier_to_locale (errbuf), PROTOCOL_NAME (proto));
2272
      else
2273
        warning (0, "type %qs does not conform to the %qE protocol",
2274
                 identifier_to_locale (errbuf), PROTOCOL_NAME (proto));
2275
    }
2276
 
2277
  return false;
2278
}
2279
 
2280
/* Check if class RCLS and instance struct type RTYP conform to at least the
2281
   same protocols that LCLS and LTYP conform to.  */
2282
 
2283
static bool
2284
objc_compare_protocols (tree lcls, tree ltyp, tree rcls, tree rtyp, bool warn)
2285
{
2286
  tree p;
2287
  bool have_lproto = false;
2288
 
2289
  while (lcls)
2290
    {
2291
      /* NB: We do _not_ look at categories defined for LCLS; these may or
2292
         may not get loaded in, and therefore it is unreasonable to require
2293
         that RCLS/RTYP must implement any of their protocols.  */
2294
      for (p = CLASS_PROTOCOL_LIST (lcls); p; p = TREE_CHAIN (p))
2295
        {
2296
          have_lproto = true;
2297
 
2298
          if (!objc_lookup_protocol (TREE_VALUE (p), rcls, rtyp, warn))
2299
            return warn;
2300
        }
2301
 
2302
      /* Repeat for superclasses.  */
2303
      lcls = lookup_interface (CLASS_SUPER_NAME (lcls));
2304
    }
2305
 
2306
  /* Check for any protocols attached directly to the object type.  */
2307
  if (TYPE_HAS_OBJC_INFO (ltyp))
2308
    {
2309
      for (p = TYPE_OBJC_PROTOCOL_LIST (ltyp); p; p = TREE_CHAIN (p))
2310
        {
2311
          have_lproto = true;
2312
 
2313
          if (!objc_lookup_protocol (TREE_VALUE (p), rcls, rtyp, warn))
2314
            return warn;
2315
        }
2316
    }
2317
 
2318
  /* NB: If LTYP and LCLS have no protocols to search for, return 'true'
2319
     vacuously, _unless_ RTYP is a protocol-qualified 'id'.  We can get
2320
     away with simply checking for 'id' or 'Class' (!RCLS), since this
2321
     routine will not get called in other cases.  */
2322
  return have_lproto || (rcls != NULL_TREE);
2323
}
2324
 
2325
/* Given two types TYPE1 and TYPE2, return their least common ancestor.
2326
   Both TYPE1 and TYPE2 must be pointers, and already determined to be
2327
   compatible by objc_compare_types() below.  */
2328
 
2329
tree
2330
objc_common_type (tree type1, tree type2)
2331
{
2332
  tree inner1 = TREE_TYPE (type1), inner2 = TREE_TYPE (type2);
2333
 
2334
  while (POINTER_TYPE_P (inner1))
2335
    {
2336
      inner1 = TREE_TYPE (inner1);
2337
      inner2 = TREE_TYPE (inner2);
2338
    }
2339
 
2340
  /* If one type is derived from another, return the base type.  */
2341
  if (DERIVED_FROM_P (inner1, inner2))
2342
    return type1;
2343
  else if (DERIVED_FROM_P (inner2, inner1))
2344
    return type2;
2345
 
2346
  /* If both types are 'Class', return 'Class'.  */
2347
  if (objc_is_class_id (inner1) && objc_is_class_id (inner2))
2348
    return objc_class_type;
2349
 
2350
  /* Otherwise, return 'id'.  */
2351
  return objc_object_type;
2352
}
2353
 
2354
/* Determine if it is permissible to assign (if ARGNO is greater than -3)
2355
   an instance of RTYP to an instance of LTYP or to compare the two
2356
   (if ARGNO is equal to -3), per ObjC type system rules.  Before
2357
   returning 'true', this routine may issue warnings related to, e.g.,
2358
   protocol conformance.  When returning 'false', the routine must
2359
   produce absolutely no warnings; the C or C++ front-end will do so
2360
   instead, if needed.  If either LTYP or RTYP is not an Objective-C
2361
   type, the routine must return 'false'.
2362
 
2363
   The ARGNO parameter is encoded as follows:
2364
     >= 1       Parameter number (CALLEE contains function being called);
2365
 
2366
     -1         Assignment;
2367
     -2         Initialization;
2368
     -3         Comparison (LTYP and RTYP may match in either direction);
2369
     -4         Silent comparison (for C++ overload resolution);
2370
     -5         Silent "specialization" comparison for RTYP to be a "specialization"
2371
                of LTYP (a specialization means that RTYP is LTYP plus some constraints,
2372
                so that each object of type RTYP is also of type LTYP).  This is used
2373
                when comparing property types.  */
2374
 
2375
bool
2376
objc_compare_types (tree ltyp, tree rtyp, int argno, tree callee)
2377
{
2378
  tree lcls, rcls, lproto, rproto;
2379
  bool pointers_compatible;
2380
 
2381
  /* We must be dealing with pointer types */
2382
  if (!POINTER_TYPE_P (ltyp) || !POINTER_TYPE_P (rtyp))
2383
    return false;
2384
 
2385
  do
2386
    {
2387
      ltyp = TREE_TYPE (ltyp);  /* Remove indirections.  */
2388
      rtyp = TREE_TYPE (rtyp);
2389
    }
2390
  while (POINTER_TYPE_P (ltyp) && POINTER_TYPE_P (rtyp));
2391
 
2392
  /* We must also handle function pointers, since ObjC is a bit more
2393
     lenient than C or C++ on this.  */
2394
  if (TREE_CODE (ltyp) == FUNCTION_TYPE && TREE_CODE (rtyp) == FUNCTION_TYPE)
2395
    {
2396
      function_args_iterator liter, riter;
2397
 
2398
      /* Return types must be covariant.  */
2399
      if (!comptypes (TREE_TYPE (ltyp), TREE_TYPE (rtyp))
2400
          && !objc_compare_types (TREE_TYPE (ltyp), TREE_TYPE (rtyp),
2401
                                  argno, callee))
2402
      return false;
2403
 
2404
      /* Argument types must be contravariant.  */
2405
      function_args_iter_init (&liter, ltyp);
2406
      function_args_iter_init (&riter, rtyp);
2407
 
2408
      while (1)
2409
        {
2410
          ltyp = function_args_iter_cond (&liter);
2411
          rtyp = function_args_iter_cond (&riter);
2412
 
2413
          /* If we've exhaused both lists simulateously, we're done.  */
2414
          if (ltyp == NULL_TREE && rtyp == NULL_TREE)
2415
            break;
2416
 
2417
          /* If one list is shorter than the other, they fail to match.  */
2418
          if (ltyp == NULL_TREE || rtyp == NULL_TREE)
2419
            return false;
2420
 
2421
          if (!comptypes (rtyp, ltyp)
2422
              && !objc_compare_types (rtyp, ltyp, argno, callee))
2423
            return false;
2424
 
2425
          function_args_iter_next (&liter);
2426
          function_args_iter_next (&riter);
2427
        }
2428
 
2429
      return true;
2430
    }
2431
 
2432
  /* Past this point, we are only interested in ObjC class instances,
2433
     or 'id' or 'Class'.  */
2434
  if (TREE_CODE (ltyp) != RECORD_TYPE || TREE_CODE (rtyp) != RECORD_TYPE)
2435
    return false;
2436
 
2437
  if (!objc_is_object_id (ltyp) && !objc_is_class_id (ltyp)
2438
      && !TYPE_HAS_OBJC_INFO (ltyp))
2439
    return false;
2440
 
2441
  if (!objc_is_object_id (rtyp) && !objc_is_class_id (rtyp)
2442
      && !TYPE_HAS_OBJC_INFO (rtyp))
2443
    return false;
2444
 
2445
  /* Past this point, we are committed to returning 'true' to the caller
2446
     (unless performing a silent comparison; see below).  However, we can
2447
     still warn about type and/or protocol mismatches.  */
2448
 
2449
  if (TYPE_HAS_OBJC_INFO (ltyp))
2450
    {
2451
      lcls = TYPE_OBJC_INTERFACE (ltyp);
2452
      lproto = TYPE_OBJC_PROTOCOL_LIST (ltyp);
2453
    }
2454
  else
2455
    lcls = lproto = NULL_TREE;
2456
 
2457
  if (TYPE_HAS_OBJC_INFO (rtyp))
2458
    {
2459
      rcls = TYPE_OBJC_INTERFACE (rtyp);
2460
      rproto = TYPE_OBJC_PROTOCOL_LIST (rtyp);
2461
    }
2462
  else
2463
    rcls = rproto = NULL_TREE;
2464
 
2465
  /* If we could not find an @interface declaration, we must have
2466
     only seen a @class declaration; for purposes of type comparison,
2467
     treat it as a stand-alone (root) class.  */
2468
 
2469
  if (lcls && TREE_CODE (lcls) == IDENTIFIER_NODE)
2470
    lcls = NULL_TREE;
2471
 
2472
  if (rcls && TREE_CODE (rcls) == IDENTIFIER_NODE)
2473
    rcls = NULL_TREE;
2474
 
2475
  /* If either type is an unqualified 'id', we're done.  This is because
2476
     an 'id' can be assigned to or from any type with no warnings.  */
2477
  if (argno != -5)
2478
    {
2479
      if ((!lproto && objc_is_object_id (ltyp))
2480
          || (!rproto && objc_is_object_id (rtyp)))
2481
        return true;
2482
    }
2483
  else
2484
    {
2485
      /* For property checks, though, an 'id' is considered the most
2486
         general type of object, hence if you try to specialize an
2487
         'NSArray *' (ltyp) property with an 'id' (rtyp) one, we need
2488
         to warn.  */
2489
      if (!lproto && objc_is_object_id (ltyp))
2490
        return true;
2491
    }
2492
 
2493
  pointers_compatible = (TYPE_MAIN_VARIANT (ltyp) == TYPE_MAIN_VARIANT (rtyp));
2494
 
2495
  /* If the underlying types are the same, and at most one of them has
2496
     a protocol list, we do not need to issue any diagnostics.  */
2497
  if (pointers_compatible && (!lproto || !rproto))
2498
    return true;
2499
 
2500
  /* If exactly one of the types is 'Class', issue a diagnostic; any
2501
     exceptions of this rule have already been handled.  */
2502
  if (objc_is_class_id (ltyp) ^ objc_is_class_id (rtyp))
2503
    pointers_compatible = false;
2504
  /* Otherwise, check for inheritance relations.  */
2505
  else
2506
    {
2507
      if (!pointers_compatible)
2508
        {
2509
          /* Again, if any of the two is an 'id', we're satisfied,
2510
             unless we're comparing properties, in which case only an
2511
             'id' on the left-hand side (old property) is good
2512
             enough.  */
2513
          if (argno != -5)
2514
            pointers_compatible
2515
              = (objc_is_object_id (ltyp) || objc_is_object_id (rtyp));
2516
          else
2517
            pointers_compatible = objc_is_object_id (ltyp);
2518
        }
2519
 
2520
      if (!pointers_compatible)
2521
        pointers_compatible = DERIVED_FROM_P (ltyp, rtyp);
2522
 
2523
      if (!pointers_compatible && (argno == -3 || argno == -4))
2524
        pointers_compatible = DERIVED_FROM_P (rtyp, ltyp);
2525
    }
2526
 
2527
  /* If the pointers match modulo protocols, check for protocol conformance
2528
     mismatches.  */
2529
  if (pointers_compatible)
2530
    {
2531
      pointers_compatible = objc_compare_protocols (lcls, ltyp, rcls, rtyp,
2532
                                                    argno != -3);
2533
 
2534
      if (!pointers_compatible && argno == -3)
2535
        pointers_compatible = objc_compare_protocols (rcls, rtyp, lcls, ltyp,
2536
                                                      argno != -3);
2537
    }
2538
 
2539
  if (!pointers_compatible)
2540
    {
2541
      /* The two pointers are not exactly compatible.  Issue a warning, unless
2542
         we are performing a silent comparison, in which case return 'false'
2543
         instead.  */
2544
      /* NB: For the time being, we shall make our warnings look like their
2545
         C counterparts.  In the future, we may wish to make them more
2546
         ObjC-specific.  */
2547
      switch (argno)
2548
        {
2549
        case -5:
2550
        case -4:
2551
          return false;
2552
 
2553
        case -3:
2554
          warning (0, "comparison of distinct Objective-C types lacks a cast");
2555
          break;
2556
 
2557
        case -2:
2558
          warning (0, "initialization from distinct Objective-C type");
2559
          break;
2560
 
2561
        case -1:
2562
          warning (0, "assignment from distinct Objective-C type");
2563
          break;
2564
 
2565
        case 0:
2566
          warning (0, "distinct Objective-C type in return");
2567
          break;
2568
 
2569
        default:
2570
          warning (0, "passing argument %d of %qE from distinct "
2571
                   "Objective-C type", argno, callee);
2572
          break;
2573
        }
2574
    }
2575
 
2576
  return true;
2577
}
2578
 
2579
/* This routine is similar to objc_compare_types except that function-pointers are
2580
   excluded. This is because, caller assumes that common types are of (id, Object*)
2581
   variety and calls objc_common_type to obtain a common type. There is no commonolty
2582
   between two function-pointers in this regard. */
2583
 
2584
bool
2585
objc_have_common_type (tree ltyp, tree rtyp, int argno, tree callee)
2586
{
2587
  if (objc_compare_types (ltyp, rtyp, argno, callee))
2588
    {
2589
      /* exclude function-pointer types. */
2590
      do
2591
        {
2592
          ltyp = TREE_TYPE (ltyp);  /* Remove indirections.  */
2593
          rtyp = TREE_TYPE (rtyp);
2594
        }
2595
      while (POINTER_TYPE_P (ltyp) && POINTER_TYPE_P (rtyp));
2596
      return !(TREE_CODE (ltyp) == FUNCTION_TYPE && TREE_CODE (rtyp) == FUNCTION_TYPE);
2597
    }
2598
  return false;
2599
}
2600
 
2601
#ifndef OBJCPLUS
2602
/* Determine if CHILD is derived from PARENT.  The routine assumes that
2603
   both parameters are RECORD_TYPEs, and is non-reflexive.  */
2604
 
2605
static bool
2606
objc_derived_from_p (tree parent, tree child)
2607
{
2608
  parent = TYPE_MAIN_VARIANT (parent);
2609
 
2610
  for (child = TYPE_MAIN_VARIANT (child);
2611
       TYPE_BINFO (child) && BINFO_N_BASE_BINFOS (TYPE_BINFO (child));)
2612
    {
2613
      child = TYPE_MAIN_VARIANT (BINFO_TYPE (BINFO_BASE_BINFO
2614
                                             (TYPE_BINFO (child),
2615
                                              0)));
2616
 
2617
      if (child == parent)
2618
        return true;
2619
    }
2620
 
2621
  return false;
2622
}
2623
#endif
2624
 
2625
tree
2626
objc_build_component_ref (tree datum, tree component)
2627
{
2628
  /* If COMPONENT is NULL, the caller is referring to the anonymous
2629
     base class field.  */
2630
  if (!component)
2631
    {
2632
      tree base = TYPE_FIELDS (TREE_TYPE (datum));
2633
 
2634
      return build3 (COMPONENT_REF, TREE_TYPE (base), datum, base, NULL_TREE);
2635
    }
2636
 
2637
  /* The 'build_component_ref' routine has been removed from the C++
2638
     front-end, but 'finish_class_member_access_expr' seems to be
2639
     a worthy substitute.  */
2640
#ifdef OBJCPLUS
2641
  return finish_class_member_access_expr (datum, component, false,
2642
                                          tf_warning_or_error);
2643
#else
2644
  return build_component_ref (input_location, datum, component);
2645
#endif
2646
}
2647
 
2648
/* Recursively copy inheritance information rooted at BINFO.  To do this,
2649
   we emulate the song and dance performed by cp/tree.c:copy_binfo().  */
2650
 
2651
static tree
2652
objc_copy_binfo (tree binfo)
2653
{
2654
  tree btype = BINFO_TYPE (binfo);
2655
  tree binfo2 = make_tree_binfo (BINFO_N_BASE_BINFOS (binfo));
2656
  tree base_binfo;
2657
  int ix;
2658
 
2659
  BINFO_TYPE (binfo2) = btype;
2660
  BINFO_OFFSET (binfo2) = BINFO_OFFSET (binfo);
2661
  BINFO_BASE_ACCESSES (binfo2) = BINFO_BASE_ACCESSES (binfo);
2662
 
2663
  /* Recursively copy base binfos of BINFO.  */
2664
  for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
2665
    {
2666
      tree base_binfo2 = objc_copy_binfo (base_binfo);
2667
 
2668
      BINFO_INHERITANCE_CHAIN (base_binfo2) = binfo2;
2669
      BINFO_BASE_APPEND (binfo2, base_binfo2);
2670
    }
2671
 
2672
  return binfo2;
2673
}
2674
 
2675
/* Record superclass information provided in BASETYPE for ObjC class REF.
2676
   This is loosely based on cp/decl.c:xref_basetypes().  */
2677
 
2678
static void
2679
objc_xref_basetypes (tree ref, tree basetype)
2680
{
2681
  tree binfo = make_tree_binfo (basetype ? 1 : 0);
2682
 
2683
  TYPE_BINFO (ref) = binfo;
2684
  BINFO_OFFSET (binfo) = size_zero_node;
2685
  BINFO_TYPE (binfo) = ref;
2686
 
2687
  if (basetype)
2688
    {
2689
      tree base_binfo = objc_copy_binfo (TYPE_BINFO (basetype));
2690
 
2691
      BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
2692
      BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, 1);
2693
      BINFO_BASE_APPEND (binfo, base_binfo);
2694
      BINFO_BASE_ACCESS_APPEND (binfo, access_public_node);
2695
    }
2696
}
2697
 
2698
/* Called from finish_decl.  */
2699
 
2700
void
2701
objc_check_decl (tree decl)
2702
{
2703
  tree type = TREE_TYPE (decl);
2704
 
2705
  if (TREE_CODE (type) != RECORD_TYPE)
2706
    return;
2707
  if (OBJC_TYPE_NAME (type) && (type = objc_is_class_name (OBJC_TYPE_NAME (type))))
2708
    error ("statically allocated instance of Objective-C class %qE",
2709
           type);
2710
}
2711
 
2712
void
2713
objc_check_global_decl (tree decl)
2714
{
2715
  tree id = DECL_NAME (decl);
2716
  if (objc_is_class_name (id) && global_bindings_p())
2717
    error ("redeclaration of Objective-C class %qs", IDENTIFIER_POINTER (id));
2718
}
2719
 
2720
/* Construct a PROTOCOLS-qualified variant of INTERFACE, where
2721
   INTERFACE may either name an Objective-C class, or refer to the
2722
   special 'id' or 'Class' types.  If INTERFACE is not a valid ObjC
2723
   type, just return it unchanged.  This function is often called when
2724
   PROTOCOLS is NULL_TREE, in which case we simply look up the
2725
   appropriate INTERFACE.  */
2726
 
2727
tree
2728
objc_get_protocol_qualified_type (tree interface, tree protocols)
2729
{
2730
  /* If INTERFACE is not provided, default to 'id'.  */
2731
  tree type = (interface ? objc_is_id (interface) : objc_object_type);
2732
  bool is_ptr = (type != NULL_TREE);
2733
 
2734
  if (!is_ptr)
2735
    {
2736
      type = objc_is_class_name (interface);
2737
 
2738
      if (type)
2739
        {
2740
          /* If looking at a typedef, retrieve the precise type it
2741
             describes.  */
2742
          if (TREE_CODE (interface) == IDENTIFIER_NODE)
2743
            interface = identifier_global_value (interface);
2744
 
2745
          type = ((interface && TREE_CODE (interface) == TYPE_DECL
2746
                   && DECL_ORIGINAL_TYPE (interface))
2747
                  ? DECL_ORIGINAL_TYPE (interface)
2748
                  : xref_tag (RECORD_TYPE, type));
2749
        }
2750
      else
2751
        {
2752
          /* This case happens when we are given an 'interface' which
2753
             is not a valid class name.  For example if a typedef was
2754
             used, and 'interface' really is the identifier of the
2755
             typedef, but when you resolve it you don't get an
2756
             Objective-C class, but something else, such as 'int'.
2757
             This is an error; protocols make no sense unless you use
2758
             them with Objective-C objects.  */
2759
          error_at (input_location, "only Objective-C object types can be qualified with a protocol");
2760
 
2761
          /* Try to recover.  Ignore the invalid class name, and treat
2762
             the object as an 'id' to silence further warnings about
2763
             the class.  */
2764
          type = objc_object_type;
2765
          is_ptr = true;
2766
        }
2767
    }
2768
 
2769
  if (protocols)
2770
    {
2771
      type = build_variant_type_copy (type);
2772
 
2773
      /* For pointers (i.e., 'id' or 'Class'), attach the protocol(s)
2774
         to the pointee.  */
2775
      if (is_ptr)
2776
        {
2777
          tree orig_pointee_type = TREE_TYPE (type);
2778
          TREE_TYPE (type) = build_variant_type_copy (orig_pointee_type);
2779
 
2780
          /* Set up the canonical type information. */
2781
          TYPE_CANONICAL (type)
2782
            = TYPE_CANONICAL (TYPE_POINTER_TO (orig_pointee_type));
2783
 
2784
          TYPE_POINTER_TO (TREE_TYPE (type)) = type;
2785
          type = TREE_TYPE (type);
2786
        }
2787
 
2788
      /* Look up protocols and install in lang specific list.  */
2789
      DUP_TYPE_OBJC_INFO (type, TYPE_MAIN_VARIANT (type));
2790
      TYPE_OBJC_PROTOCOL_LIST (type) = lookup_and_install_protocols
2791
        (protocols, /* definition_required */ false);
2792
 
2793
      /* For RECORD_TYPEs, point to the @interface; for 'id' and 'Class',
2794
         return the pointer to the new pointee variant.  */
2795
      if (is_ptr)
2796
        type = TYPE_POINTER_TO (type);
2797
      else
2798
        TYPE_OBJC_INTERFACE (type)
2799
          = TYPE_OBJC_INTERFACE (TYPE_MAIN_VARIANT (type));
2800
    }
2801
 
2802
  return type;
2803
}
2804
 
2805
/* Check for circular dependencies in protocols.  The arguments are
2806
   PROTO, the protocol to check, and LIST, a list of protocol it
2807
   conforms to.  */
2808
 
2809
static void
2810
check_protocol_recursively (tree proto, tree list)
2811
{
2812
  tree p;
2813
 
2814
  for (p = list; p; p = TREE_CHAIN (p))
2815
    {
2816
      tree pp = TREE_VALUE (p);
2817
 
2818
      if (TREE_CODE (pp) == IDENTIFIER_NODE)
2819
        pp = lookup_protocol (pp, /* warn if deprecated */ false,
2820
                              /* definition_required */ false);
2821
 
2822
      if (pp == proto)
2823
        fatal_error ("protocol %qE has circular dependency",
2824
                     PROTOCOL_NAME (pp));
2825
      if (pp)
2826
        check_protocol_recursively (proto, PROTOCOL_LIST (pp));
2827
    }
2828
}
2829
 
2830
/* Look up PROTOCOLS, and return a list of those that are found.  If
2831
   none are found, return NULL.  Note that this function will emit a
2832
   warning if a protocol is found and is deprecated.  If
2833
   'definition_required', then warn if the protocol is found but is
2834
   not defined (ie, if we only saw a forward-declaration of the
2835
   protocol (as in "@protocol NSObject;") not a real definition with
2836
   the list of methods).  */
2837
static tree
2838
lookup_and_install_protocols (tree protocols, bool definition_required)
2839
{
2840
  tree proto;
2841
  tree return_value = NULL_TREE;
2842
 
2843
  if (protocols == error_mark_node)
2844
    return NULL;
2845
 
2846
  for (proto = protocols; proto; proto = TREE_CHAIN (proto))
2847
    {
2848
      tree ident = TREE_VALUE (proto);
2849
      tree p = lookup_protocol (ident, /* warn_if_deprecated */ true,
2850
                                definition_required);
2851
 
2852
      if (p)
2853
        return_value = chainon (return_value,
2854
                                build_tree_list (NULL_TREE, p));
2855
      else if (ident != error_mark_node)
2856
        error ("cannot find protocol declaration for %qE",
2857
               ident);
2858
    }
2859
 
2860
  return return_value;
2861
}
2862
 
2863
static void
2864
build_common_objc_exception_stuff (void)
2865
{
2866
  tree noreturn_list, nothrow_list, temp_type;
2867
 
2868
  noreturn_list = tree_cons (get_identifier ("noreturn"), NULL, NULL);
2869
  nothrow_list = tree_cons (get_identifier ("nothrow"), NULL, NULL);
2870
 
2871
  /* void objc_exception_throw(id) __attribute__((noreturn)); */
2872
  /* void objc_sync_enter(id); */
2873
  /* void objc_sync_exit(id); */
2874
  temp_type = build_function_type_list (void_type_node,
2875
                                        objc_object_type,
2876
                                        NULL_TREE);
2877
  objc_exception_throw_decl
2878
    = add_builtin_function (TAG_EXCEPTIONTHROW, temp_type, 0, NOT_BUILT_IN, NULL,
2879
                            noreturn_list);
2880
  /* Make sure that objc_exception_throw (id) claims that it may throw an
2881
     exception. */
2882
  TREE_NOTHROW (objc_exception_throw_decl) = 0;
2883
 
2884
  objc_sync_enter_decl
2885
    = add_builtin_function (TAG_SYNCENTER, temp_type, 0, NOT_BUILT_IN,
2886
                            NULL, nothrow_list);
2887
 
2888
  objc_sync_exit_decl
2889
    = add_builtin_function (TAG_SYNCEXIT, temp_type, 0, NOT_BUILT_IN,
2890
                            NULL, nothrow_list);
2891
}
2892
 
2893
/* Purpose: "play" parser, creating/installing representations
2894
   of the declarations that are required by Objective-C.
2895
 
2896
   Model:
2897
 
2898
        type_spec--------->sc_spec
2899
        (tree_list)        (tree_list)
2900
            |                  |
2901
            |                  |
2902
        identifier_node    identifier_node  */
2903
 
2904
static void
2905
synth_module_prologue (void)
2906
{
2907
  tree type;
2908
  enum debug_info_type save_write_symbols = write_symbols;
2909
  const struct gcc_debug_hooks *const save_hooks = debug_hooks;
2910
 
2911
  /* Suppress outputting debug symbols, because
2912
     dbxout_init hasn't been called yet.  */
2913
  write_symbols = NO_DEBUG;
2914
  debug_hooks = &do_nothing_debug_hooks;
2915
 
2916
#ifdef OBJCPLUS
2917
  push_lang_context (lang_name_c); /* extern "C" */
2918
#endif
2919
 
2920
  /* The following are also defined in <objc/objc.h> and friends.  */
2921
 
2922
  objc_object_id = get_identifier (TAG_OBJECT);
2923
  objc_class_id = get_identifier (TAG_CLASS);
2924
 
2925
  objc_object_reference = xref_tag (RECORD_TYPE, objc_object_id);
2926
  objc_class_reference = xref_tag (RECORD_TYPE, objc_class_id);
2927
 
2928
  objc_object_type = build_pointer_type (objc_object_reference);
2929
  objc_class_type = build_pointer_type (objc_class_reference);
2930
 
2931
  objc_object_name = get_identifier (OBJECT_TYPEDEF_NAME);
2932
  objc_class_name = get_identifier (CLASS_TYPEDEF_NAME);
2933
 
2934
  /* Declare the 'id' and 'Class' typedefs.  */
2935
  type = lang_hooks.decls.pushdecl (build_decl (input_location,
2936
                                                TYPE_DECL,
2937
                                                objc_object_name,
2938
                                                objc_object_type));
2939
  TREE_NO_WARNING (type) = 1;
2940
 
2941
  type = lang_hooks.decls.pushdecl (build_decl (input_location,
2942
                                                TYPE_DECL,
2943
                                                objc_class_name,
2944
                                                objc_class_type));
2945
  TREE_NO_WARNING (type) = 1;
2946
 
2947
  /* Forward-declare '@interface Protocol'.  */
2948
  type = get_identifier (PROTOCOL_OBJECT_CLASS_NAME);
2949
  objc_declare_class (type);
2950
  objc_protocol_type = build_pointer_type (xref_tag (RECORD_TYPE, type));
2951
 
2952
  /* Declare receiver type used for dispatching messages to 'super'.  */
2953
  /* `struct objc_super *' */
2954
  objc_super_type = build_pointer_type (xref_tag (RECORD_TYPE,
2955
                                                  get_identifier (TAG_SUPER)));
2956
 
2957
  /* Declare pointers to method and ivar lists.  */
2958
  objc_method_list_ptr = build_pointer_type
2959
                         (xref_tag (RECORD_TYPE,
2960
                                    get_identifier (UTAG_METHOD_LIST)));
2961
  objc_method_proto_list_ptr
2962
    = build_pointer_type (xref_tag (RECORD_TYPE,
2963
                                    get_identifier (UTAG_METHOD_PROTOTYPE_LIST)));
2964
  objc_ivar_list_ptr = build_pointer_type
2965
                       (xref_tag (RECORD_TYPE,
2966
                                  get_identifier (UTAG_IVAR_LIST)));
2967
 
2968
  build_common_objc_exception_stuff ();
2969
 
2970
  /* Set-up runtime-specific templates, message and exception stuff.  */
2971
  (*runtime.initialize) ();
2972
 
2973
  /* Declare objc_getProperty, object_setProperty and other property
2974
     accessor helpers.  */
2975
  build_common_objc_property_accessor_helpers ();
2976
 
2977
  /* Forward declare constant_string_id and constant_string_type.  */
2978
  if (!constant_string_class_name)
2979
    constant_string_class_name = runtime.default_constant_string_class_name;
2980
  constant_string_id = get_identifier (constant_string_class_name);
2981
  objc_declare_class (constant_string_id);
2982
 
2983
  /* Pre-build the following entities - for speed/convenience.  */
2984
  self_id = get_identifier ("self");
2985
  ucmd_id = get_identifier ("_cmd");
2986
 
2987
  /* Declare struct _objc_fast_enumeration_state { ... };  */
2988
  build_fast_enumeration_state_template ();
2989
 
2990
  /* void objc_enumeration_mutation (id) */
2991
  type = build_function_type_list (void_type_node,
2992
                                   objc_object_type, NULL_TREE);
2993
  objc_enumeration_mutation_decl
2994
    = add_builtin_function (TAG_ENUMERATION_MUTATION, type, 0, NOT_BUILT_IN,
2995
                            NULL, NULL_TREE);
2996
  TREE_NOTHROW (objc_enumeration_mutation_decl) = 0;
2997
 
2998
#ifdef OBJCPLUS
2999
  pop_lang_context ();
3000
#endif
3001
 
3002
  write_symbols = save_write_symbols;
3003
  debug_hooks = save_hooks;
3004
}
3005
 
3006
/* --- const strings --- */
3007
 
3008
/* Ensure that the ivar list for NSConstantString/NXConstantString
3009
   (or whatever was specified via `-fconstant-string-class')
3010
   contains fields at least as large as the following three, so that
3011
   the runtime can stomp on them with confidence:
3012
 
3013
   struct STRING_OBJECT_CLASS_NAME
3014
   {
3015
     Object isa;
3016
     char *cString;
3017
     unsigned int length;
3018
   }; */
3019
 
3020
static int
3021
check_string_class_template (void)
3022
{
3023
  tree field_decl = objc_get_class_ivars (constant_string_id);
3024
 
3025
#define AT_LEAST_AS_LARGE_AS(F, T) \
3026
  (F && TREE_CODE (F) == FIELD_DECL \
3027
     && (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (F))) \
3028
         >= TREE_INT_CST_LOW (TYPE_SIZE (T))))
3029
 
3030
  if (!AT_LEAST_AS_LARGE_AS (field_decl, ptr_type_node))
3031
    return 0;
3032
 
3033
  field_decl = DECL_CHAIN (field_decl);
3034
  if (!AT_LEAST_AS_LARGE_AS (field_decl, ptr_type_node))
3035
    return 0;
3036
 
3037
  field_decl = DECL_CHAIN (field_decl);
3038
  return AT_LEAST_AS_LARGE_AS (field_decl, unsigned_type_node);
3039
 
3040
#undef AT_LEAST_AS_LARGE_AS
3041
}
3042
 
3043
/* Avoid calling `check_string_class_template ()' more than once.  */
3044
static GTY(()) int string_layout_checked;
3045
 
3046
/* Construct an internal string layout to be used as a template for
3047
   creating NSConstantString/NXConstantString instances.  */
3048
 
3049
static tree
3050
objc_build_internal_const_str_type (void)
3051
{
3052
  tree type = (*lang_hooks.types.make_type) (RECORD_TYPE);
3053
  tree fields = build_decl (input_location,
3054
                            FIELD_DECL, NULL_TREE, ptr_type_node);
3055
  tree field = build_decl (input_location,
3056
                           FIELD_DECL, NULL_TREE, ptr_type_node);
3057
 
3058
  DECL_CHAIN (field) = fields; fields = field;
3059
  field = build_decl (input_location,
3060
                      FIELD_DECL, NULL_TREE, unsigned_type_node);
3061
  DECL_CHAIN (field) = fields; fields = field;
3062
  /* NB: The finish_builtin_struct() routine expects FIELD_DECLs in
3063
     reverse order!  */
3064
  finish_builtin_struct (type, "__builtin_ObjCString",
3065
                         fields, NULL_TREE);
3066
 
3067
  return type;
3068
}
3069
 
3070
/* Custom build_string which sets TREE_TYPE!  */
3071
 
3072
tree
3073
my_build_string (int len, const char *str)
3074
{
3075
  return fix_string_type (build_string (len, str));
3076
}
3077
 
3078
/* Build a string with contents STR and length LEN and convert it to a
3079
   pointer.  */
3080
 
3081
tree
3082
my_build_string_pointer (int len, const char *str)
3083
{
3084
  tree string = my_build_string (len, str);
3085
  tree ptrtype = build_pointer_type (TREE_TYPE (TREE_TYPE (string)));
3086
  return build1 (ADDR_EXPR, ptrtype, string);
3087
}
3088
 
3089
static hashval_t
3090
string_hash (const void *ptr)
3091
{
3092
  const_tree const str = ((const struct string_descriptor *)ptr)->literal;
3093
  const unsigned char *p = (const unsigned char *) TREE_STRING_POINTER (str);
3094
  int i, len = TREE_STRING_LENGTH (str);
3095
  hashval_t h = len;
3096
 
3097
  for (i = 0; i < len; i++)
3098
    h = ((h * 613) + p[i]);
3099
 
3100
  return h;
3101
}
3102
 
3103
static int
3104
string_eq (const void *ptr1, const void *ptr2)
3105
{
3106
  const_tree const str1 = ((const struct string_descriptor *)ptr1)->literal;
3107
  const_tree const str2 = ((const struct string_descriptor *)ptr2)->literal;
3108
  int len1 = TREE_STRING_LENGTH (str1);
3109
 
3110
  return (len1 == TREE_STRING_LENGTH (str2)
3111
          && !memcmp (TREE_STRING_POINTER (str1), TREE_STRING_POINTER (str2),
3112
                      len1));
3113
}
3114
 
3115
/* Given a chain of STRING_CST's, build a static instance of
3116
   NXConstantString which points at the concatenation of those
3117
   strings.  We place the string object in the __string_objects
3118
   section of the __OBJC segment.  The Objective-C runtime will
3119
   initialize the isa pointers of the string objects to point at the
3120
   NXConstantString class object.  */
3121
 
3122
tree
3123
objc_build_string_object (tree string)
3124
{
3125
  tree constant_string_class;
3126
  int length;
3127
  tree addr;
3128
  struct string_descriptor *desc, key;
3129
  void **loc;
3130
 
3131
  /* We should be passed a STRING_CST.  */
3132
  gcc_checking_assert (TREE_CODE (string) == STRING_CST);
3133
  length = TREE_STRING_LENGTH (string) - 1;
3134
 
3135
  /* The target may have different ideas on how to construct an ObjC string
3136
     literal.  On Darwin (Mac OS X), for example, we may wish to obtain a
3137
     constant CFString reference instead.
3138
     At present, this is only supported for the NeXT runtime.  */
3139
  if (flag_next_runtime
3140
      && targetcm.objc_construct_string_object)
3141
    {
3142
      tree constructor = (*targetcm.objc_construct_string_object) (string);
3143
      if (constructor)
3144
        return build1 (NOP_EXPR, objc_object_type, constructor);
3145
    }
3146
 
3147
  /* Check whether the string class being used actually exists and has the
3148
     correct ivar layout.  */
3149
  if (!string_layout_checked)
3150
    {
3151
      string_layout_checked = -1;
3152
      constant_string_class = lookup_interface (constant_string_id);
3153
      internal_const_str_type = objc_build_internal_const_str_type ();
3154
 
3155
      if (!constant_string_class
3156
          || !(constant_string_type
3157
               = CLASS_STATIC_TEMPLATE (constant_string_class)))
3158
        error ("cannot find interface declaration for %qE",
3159
               constant_string_id);
3160
      /* The NSConstantString/NXConstantString ivar layout is now known.  */
3161
      else if (!check_string_class_template ())
3162
        error ("interface %qE does not have valid constant string layout",
3163
               constant_string_id);
3164
      /* If the runtime can generate a literal reference to the string class,
3165
         don't need to run a constructor.  */
3166
      else if (!(*runtime.setup_const_string_class_decl)())
3167
        error ("cannot find reference tag for class %qE", constant_string_id);
3168
      else
3169
        {
3170
          string_layout_checked = 1;  /* Success!  */
3171
          add_class_reference (constant_string_id);
3172
        }
3173
    }
3174
 
3175
  if (string_layout_checked == -1)
3176
    return error_mark_node;
3177
 
3178
  /* Perhaps we already constructed a constant string just like this one? */
3179
  key.literal = string;
3180
  loc = htab_find_slot (string_htab, &key, INSERT);
3181
  desc = (struct string_descriptor *) *loc;
3182
 
3183
  if (!desc)
3184
    {
3185
      *loc = desc = ggc_alloc_string_descriptor ();
3186
      desc->literal = string;
3187
      desc->constructor =
3188
        (*runtime.build_const_string_constructor) (input_location, string, length);
3189
    }
3190
 
3191
  addr = convert (build_pointer_type (constant_string_type),
3192
                  build_unary_op (input_location,
3193
                                  ADDR_EXPR, desc->constructor, 1));
3194
 
3195
  return addr;
3196
}
3197
 
3198
/* Build a static constant CONSTRUCTOR
3199
   with type TYPE and elements ELTS.  */
3200
 
3201
tree
3202
objc_build_constructor (tree type, VEC(constructor_elt,gc) *elts)
3203
{
3204
  tree constructor = build_constructor (type, elts);
3205
 
3206
  TREE_CONSTANT (constructor) = 1;
3207
  TREE_STATIC (constructor) = 1;
3208
  TREE_READONLY (constructor) = 1;
3209
 
3210
#ifdef OBJCPLUS
3211
  /* Adjust for impedance mismatch.  We should figure out how to build
3212
     CONSTRUCTORs that consistently please both the C and C++ gods.  */
3213
  if (!VEC_index (constructor_elt, elts, 0)->index)
3214
    TREE_TYPE (constructor) = init_list_type_node;
3215
#endif
3216
 
3217
  return constructor;
3218
}
3219
 
3220
/* Return the DECL of the string IDENT in the SECTION.  */
3221
 
3222
tree
3223
get_objc_string_decl (tree ident, enum string_section section)
3224
{
3225
  tree chain;
3226
 
3227
  switch (section)
3228
    {
3229
    case class_names:
3230
      chain = class_names_chain;
3231
      break;
3232
    case meth_var_names:
3233
      chain = meth_var_names_chain;
3234
      break;
3235
    case meth_var_types:
3236
      chain = meth_var_types_chain;
3237
      break;
3238
    case prop_names_attr:
3239
      chain = prop_names_attr_chain;
3240
      break;
3241
    default:
3242
      gcc_unreachable ();
3243
    }
3244
 
3245
  for (; chain != 0; chain = TREE_CHAIN (chain))
3246
    if (TREE_VALUE (chain) == ident)
3247
      return (TREE_PURPOSE (chain));
3248
 
3249
  /* We didn't find the entry.  */
3250
  return NULL_TREE;
3251
}
3252
 
3253
/* Create a class reference, but don't create a variable to reference
3254
   it.  */
3255
 
3256
void
3257
add_class_reference (tree ident)
3258
{
3259
  tree chain;
3260
 
3261
  if ((chain = cls_ref_chain))
3262
    {
3263
      tree tail;
3264
      do
3265
        {
3266
          if (ident == TREE_VALUE (chain))
3267
            return;
3268
 
3269
          tail = chain;
3270
          chain = TREE_CHAIN (chain);
3271
        }
3272
      while (chain);
3273
 
3274
      /* Append to the end of the list */
3275
      TREE_CHAIN (tail) = tree_cons (NULL_TREE, ident, NULL_TREE);
3276
    }
3277
  else
3278
    cls_ref_chain = tree_cons (NULL_TREE, ident, NULL_TREE);
3279
}
3280
 
3281
/* Get a class reference, creating it if necessary.  Also create the
3282
   reference variable.  */
3283
tree
3284
objc_get_class_reference (tree ident)
3285
{
3286
  tree orig_ident = (DECL_P (ident)
3287
                     ? DECL_NAME (ident)
3288
                     : TYPE_P (ident)
3289
                     ? OBJC_TYPE_NAME (ident)
3290
                     : ident);
3291
  bool local_scope = false;
3292
 
3293
#ifdef OBJCPLUS
3294
  if (processing_template_decl)
3295
    /* Must wait until template instantiation time.  */
3296
    return build_min_nt (CLASS_REFERENCE_EXPR, ident);
3297
#endif
3298
 
3299
  if (TREE_CODE (ident) == TYPE_DECL)
3300
    ident = (DECL_ORIGINAL_TYPE (ident)
3301
             ? DECL_ORIGINAL_TYPE (ident)
3302
             : TREE_TYPE (ident));
3303
 
3304
#ifdef OBJCPLUS
3305
  if (TYPE_P (ident)
3306
      && CP_TYPE_CONTEXT (ident) != global_namespace)
3307
    local_scope = true;
3308
#endif
3309
 
3310
  if (local_scope || !(ident = objc_is_class_name (ident)))
3311
    {
3312
      error ("%qE is not an Objective-C class name or alias",
3313
             orig_ident);
3314
      return error_mark_node;
3315
    }
3316
 
3317
  return (*runtime.get_class_reference) (ident);
3318
}
3319
 
3320
void
3321
objc_declare_alias (tree alias_ident, tree class_ident)
3322
{
3323
  tree underlying_class;
3324
 
3325
#ifdef OBJCPLUS
3326
  if (current_namespace != global_namespace) {
3327
    error ("Objective-C declarations may only appear in global scope");
3328
  }
3329
#endif /* OBJCPLUS */
3330
 
3331
  if (!(underlying_class = objc_is_class_name (class_ident)))
3332
    warning (0, "cannot find class %qE", class_ident);
3333
  else if (objc_is_class_name (alias_ident))
3334
    warning (0, "class %qE already exists", alias_ident);
3335
  else
3336
    {
3337
      /* Implement @compatibility_alias as a typedef.  */
3338
#ifdef OBJCPLUS
3339
      push_lang_context (lang_name_c); /* extern "C" */
3340
#endif
3341
      lang_hooks.decls.pushdecl (build_decl
3342
                                 (input_location,
3343
                                  TYPE_DECL,
3344
                                  alias_ident,
3345
                                  xref_tag (RECORD_TYPE, underlying_class)));
3346
#ifdef OBJCPLUS
3347
      pop_lang_context ();
3348
#endif
3349
      objc_map_put (alias_name_map, alias_ident, underlying_class);
3350
    }
3351
}
3352
 
3353
void
3354
objc_declare_class (tree identifier)
3355
{
3356
#ifdef OBJCPLUS
3357
  if (current_namespace != global_namespace) {
3358
    error ("Objective-C declarations may only appear in global scope");
3359
  }
3360
#endif /* OBJCPLUS */
3361
 
3362
  if (! objc_is_class_name (identifier))
3363
    {
3364
      tree record = lookup_name (identifier), type = record;
3365
 
3366
      if (record)
3367
        {
3368
          if (TREE_CODE (record) == TYPE_DECL)
3369
            type = DECL_ORIGINAL_TYPE (record)
3370
              ? DECL_ORIGINAL_TYPE (record)
3371
              : TREE_TYPE (record);
3372
 
3373
          if (!TYPE_HAS_OBJC_INFO (type)
3374
              || !TYPE_OBJC_INTERFACE (type))
3375
            {
3376
              error ("%qE redeclared as different kind of symbol",
3377
                     identifier);
3378
              error ("previous declaration of %q+D",
3379
                     record);
3380
            }
3381
        }
3382
 
3383
      record = xref_tag (RECORD_TYPE, identifier);
3384
      INIT_TYPE_OBJC_INFO (record);
3385
      /* In the case of a @class declaration, we store the ident in
3386
         the TYPE_OBJC_INTERFACE.  If later an @interface is found,
3387
         we'll replace the ident with the interface.  */
3388
      TYPE_OBJC_INTERFACE (record) = identifier;
3389
      objc_map_put (class_name_map, identifier, NULL_TREE);
3390
    }
3391
}
3392
 
3393
tree
3394
objc_is_class_name (tree ident)
3395
{
3396
  if (ident && TREE_CODE (ident) == IDENTIFIER_NODE)
3397
    {
3398
      tree t = identifier_global_value (ident);
3399
      if (t)
3400
        ident = t;
3401
    }
3402
 
3403
  while (ident && TREE_CODE (ident) == TYPE_DECL && DECL_ORIGINAL_TYPE (ident))
3404
    ident = OBJC_TYPE_NAME (DECL_ORIGINAL_TYPE (ident));
3405
 
3406
  if (ident && TREE_CODE (ident) == RECORD_TYPE)
3407
    ident = OBJC_TYPE_NAME (ident);
3408
#ifdef OBJCPLUS
3409
  if (ident && TREE_CODE (ident) == TYPE_DECL)
3410
    {
3411
      tree type = TREE_TYPE (ident);
3412
      if (type && TREE_CODE (type) == TEMPLATE_TYPE_PARM)
3413
        return NULL_TREE;
3414
      ident = DECL_NAME (ident);
3415
    }
3416
#endif
3417
  if (!ident || TREE_CODE (ident) != IDENTIFIER_NODE)
3418
    return NULL_TREE;
3419
 
3420
  if (lookup_interface (ident))
3421
    return ident;
3422
 
3423
  {
3424
    tree target;
3425
 
3426
    target = objc_map_get (class_name_map, ident);
3427
    if (target != OBJC_MAP_NOT_FOUND)
3428
      return ident;
3429
 
3430
    target = objc_map_get (alias_name_map, ident);
3431
    if (target != OBJC_MAP_NOT_FOUND)
3432
      return target;
3433
  }
3434
 
3435
  return 0;
3436
}
3437
 
3438
/* Check whether TYPE is either 'id' or 'Class'.  */
3439
 
3440
tree
3441
objc_is_id (tree type)
3442
{
3443
  if (type && TREE_CODE (type) == IDENTIFIER_NODE)
3444
    {
3445
      tree t = identifier_global_value (type);
3446
      if (t)
3447
        type = t;
3448
    }
3449
 
3450
  if (type && TREE_CODE (type) == TYPE_DECL)
3451
    type = TREE_TYPE (type);
3452
 
3453
  /* NB: This function may be called before the ObjC front-end has
3454
     been initialized, in which case OBJC_OBJECT_TYPE will (still) be NULL.  */
3455
  return (objc_object_type && type
3456
          && (IS_ID (type) || IS_CLASS (type) || IS_SUPER (type))
3457
          ? type
3458
          : NULL_TREE);
3459
}
3460
 
3461
/* Check whether TYPE is either 'id', 'Class', or a pointer to an ObjC
3462
   class instance.  This is needed by other parts of the compiler to
3463
   handle ObjC types gracefully.  */
3464
 
3465
tree
3466
objc_is_object_ptr (tree type)
3467
{
3468
  tree ret;
3469
 
3470
  type = TYPE_MAIN_VARIANT (type);
3471
  if (!POINTER_TYPE_P (type))
3472
    return 0;
3473
 
3474
  ret = objc_is_id (type);
3475
  if (!ret)
3476
    ret = objc_is_class_name (TREE_TYPE (type));
3477
 
3478
  return ret;
3479
}
3480
 
3481
static int
3482
objc_is_gcable_type (tree type, int or_strong_p)
3483
{
3484
  tree name;
3485
 
3486
  if (!TYPE_P (type))
3487
    return 0;
3488
  if (objc_is_id (TYPE_MAIN_VARIANT (type)))
3489
    return 1;
3490
  if (or_strong_p && lookup_attribute ("objc_gc", TYPE_ATTRIBUTES (type)))
3491
    return 1;
3492
  if (TREE_CODE (type) != POINTER_TYPE && TREE_CODE (type) != INDIRECT_REF)
3493
    return 0;
3494
  type = TREE_TYPE (type);
3495
  if (TREE_CODE (type) != RECORD_TYPE)
3496
    return 0;
3497
  name = TYPE_NAME (type);
3498
  return (objc_is_class_name (name) != NULL_TREE);
3499
}
3500
 
3501
static tree
3502
objc_substitute_decl (tree expr, tree oldexpr, tree newexpr)
3503
{
3504
  if (expr == oldexpr)
3505
    return newexpr;
3506
 
3507
  switch (TREE_CODE (expr))
3508
    {
3509
    case COMPONENT_REF:
3510
      return objc_build_component_ref
3511
             (objc_substitute_decl (TREE_OPERAND (expr, 0),
3512
                                    oldexpr,
3513
                                    newexpr),
3514
              DECL_NAME (TREE_OPERAND (expr, 1)));
3515
    case ARRAY_REF:
3516
      return build_array_ref (input_location,
3517
                              objc_substitute_decl (TREE_OPERAND (expr, 0),
3518
                                                    oldexpr,
3519
                                                    newexpr),
3520
                              TREE_OPERAND (expr, 1));
3521
    case INDIRECT_REF:
3522
      return build_indirect_ref (input_location,
3523
                                 objc_substitute_decl (TREE_OPERAND (expr, 0),
3524
                                                       oldexpr,
3525
                                                       newexpr), RO_ARROW);
3526
    default:
3527
      return expr;
3528
    }
3529
}
3530
 
3531
static tree
3532
objc_build_ivar_assignment (tree outervar, tree lhs, tree rhs)
3533
{
3534
  tree func_params;
3535
  /* The LHS parameter contains the expression 'outervar->memberspec';
3536
     we need to transform it into '&((typeof(outervar) *) 0)->memberspec',
3537
     where memberspec may be arbitrarily complex (e.g., 'g->f.d[2].g[3]').
3538
  */
3539
  tree offs
3540
    = objc_substitute_decl
3541
      (lhs, outervar, convert (TREE_TYPE (outervar), integer_zero_node));
3542
  tree func
3543
    = (flag_objc_direct_dispatch
3544
       ? objc_assign_ivar_fast_decl
3545
       : objc_assign_ivar_decl);
3546
 
3547
  offs = convert (integer_type_node, build_unary_op (input_location,
3548
                                                     ADDR_EXPR, offs, 0));
3549
  offs = fold (offs);
3550
  func_params = tree_cons (NULL_TREE,
3551
        convert (objc_object_type, rhs),
3552
            tree_cons (NULL_TREE, convert (objc_object_type, outervar),
3553
                tree_cons (NULL_TREE, offs,
3554
                    NULL_TREE)));
3555
 
3556
  assemble_external (func);
3557
  return build_function_call (input_location, func, func_params);
3558
}
3559
 
3560
static tree
3561
objc_build_global_assignment (tree lhs, tree rhs)
3562
{
3563
  tree func_params = tree_cons (NULL_TREE,
3564
        convert (objc_object_type, rhs),
3565
            tree_cons (NULL_TREE, convert (build_pointer_type (objc_object_type),
3566
                      build_unary_op (input_location, ADDR_EXPR, lhs, 0)),
3567
                    NULL_TREE));
3568
 
3569
  assemble_external (objc_assign_global_decl);
3570
  return build_function_call (input_location,
3571
                              objc_assign_global_decl, func_params);
3572
}
3573
 
3574
static tree
3575
objc_build_strong_cast_assignment (tree lhs, tree rhs)
3576
{
3577
  tree func_params = tree_cons (NULL_TREE,
3578
        convert (objc_object_type, rhs),
3579
            tree_cons (NULL_TREE, convert (build_pointer_type (objc_object_type),
3580
                      build_unary_op (input_location, ADDR_EXPR, lhs, 0)),
3581
                    NULL_TREE));
3582
 
3583
  assemble_external (objc_assign_strong_cast_decl);
3584
  return build_function_call (input_location,
3585
                              objc_assign_strong_cast_decl, func_params);
3586
}
3587
 
3588
static int
3589
objc_is_gcable_p (tree expr)
3590
{
3591
  return (TREE_CODE (expr) == COMPONENT_REF
3592
          ? objc_is_gcable_p (TREE_OPERAND (expr, 1))
3593
          : TREE_CODE (expr) == ARRAY_REF
3594
          ? (objc_is_gcable_p (TREE_TYPE (expr))
3595
             || objc_is_gcable_p (TREE_OPERAND (expr, 0)))
3596
          : TREE_CODE (expr) == ARRAY_TYPE
3597
          ? objc_is_gcable_p (TREE_TYPE (expr))
3598
          : TYPE_P (expr)
3599
          ? objc_is_gcable_type (expr, 1)
3600
          : (objc_is_gcable_p (TREE_TYPE (expr))
3601
             || (DECL_P (expr)
3602
                 && lookup_attribute ("objc_gc", DECL_ATTRIBUTES (expr)))));
3603
}
3604
 
3605
static int
3606
objc_is_ivar_reference_p (tree expr)
3607
{
3608
  return (TREE_CODE (expr) == ARRAY_REF
3609
          ? objc_is_ivar_reference_p (TREE_OPERAND (expr, 0))
3610
          : TREE_CODE (expr) == COMPONENT_REF
3611
          ? TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL
3612
          : 0);
3613
}
3614
 
3615
static int
3616
objc_is_global_reference_p (tree expr)
3617
{
3618
  return (TREE_CODE (expr) == INDIRECT_REF || TREE_CODE (expr) == PLUS_EXPR
3619
          ? objc_is_global_reference_p (TREE_OPERAND (expr, 0))
3620
          : DECL_P (expr)
3621
          ? (DECL_FILE_SCOPE_P (expr) || TREE_STATIC (expr))
3622
          : 0);
3623
}
3624
 
3625
tree
3626
objc_generate_write_barrier (tree lhs, enum tree_code modifycode, tree rhs)
3627
{
3628
  tree result = NULL_TREE, outer;
3629
  int strong_cast_p = 0, outer_gc_p = 0, indirect_p = 0;
3630
 
3631
  /* This function is currently only used with the next runtime with
3632
     garbage collection enabled (-fobjc-gc).  */
3633
  gcc_assert (flag_next_runtime);
3634
 
3635
  /* See if we have any lhs casts, and strip them out.  NB: The lvalue casts
3636
     will have been transformed to the form '*(type *)&expr'.  */
3637
  if (TREE_CODE (lhs) == INDIRECT_REF)
3638
    {
3639
      outer = TREE_OPERAND (lhs, 0);
3640
 
3641
      while (!strong_cast_p
3642
             && (CONVERT_EXPR_P (outer)
3643
                 || TREE_CODE (outer) == NON_LVALUE_EXPR))
3644
        {
3645
          tree lhstype = TREE_TYPE (outer);
3646
 
3647
          /* Descend down the cast chain, and record the first objc_gc
3648
             attribute found.  */
3649
          if (POINTER_TYPE_P (lhstype))
3650
            {
3651
              tree attr
3652
                = lookup_attribute ("objc_gc",
3653
                                    TYPE_ATTRIBUTES (TREE_TYPE (lhstype)));
3654
 
3655
              if (attr)
3656
                strong_cast_p = 1;
3657
            }
3658
 
3659
          outer = TREE_OPERAND (outer, 0);
3660
        }
3661
    }
3662
 
3663
  /* If we have a __strong cast, it trumps all else.  */
3664
  if (strong_cast_p)
3665
    {
3666
      if (modifycode != NOP_EXPR)
3667
        goto invalid_pointer_arithmetic;
3668
 
3669
      if (warn_assign_intercept)
3670
        warning (0, "strong-cast assignment has been intercepted");
3671
 
3672
      result = objc_build_strong_cast_assignment (lhs, rhs);
3673
 
3674
      goto exit_point;
3675
    }
3676
 
3677
  /* the lhs must be of a suitable type, regardless of its underlying
3678
     structure.  */
3679
  if (!objc_is_gcable_p (lhs))
3680
    goto exit_point;
3681
 
3682
  outer = lhs;
3683
 
3684
  while (outer
3685
         && (TREE_CODE (outer) == COMPONENT_REF
3686
             || TREE_CODE (outer) == ARRAY_REF))
3687
    outer = TREE_OPERAND (outer, 0);
3688
 
3689
  if (TREE_CODE (outer) == INDIRECT_REF)
3690
    {
3691
      outer = TREE_OPERAND (outer, 0);
3692
      indirect_p = 1;
3693
    }
3694
 
3695
  outer_gc_p = objc_is_gcable_p (outer);
3696
 
3697
  /* Handle ivar assignments. */
3698
  if (objc_is_ivar_reference_p (lhs))
3699
    {
3700
      /* if the struct to the left of the ivar is not an Objective-C object (__strong
3701
         doesn't cut it here), the best we can do here is suggest a cast.  */
3702
      if (!objc_is_gcable_type (TREE_TYPE (outer), 0))
3703
        {
3704
          /* We may still be able to use the global write barrier... */
3705
          if (!indirect_p && objc_is_global_reference_p (outer))
3706
            goto global_reference;
3707
 
3708
         suggest_cast:
3709
          if (modifycode == NOP_EXPR)
3710
            {
3711
              if (warn_assign_intercept)
3712
                warning (0, "strong-cast may possibly be needed");
3713
            }
3714
 
3715
          goto exit_point;
3716
        }
3717
 
3718
      if (modifycode != NOP_EXPR)
3719
        goto invalid_pointer_arithmetic;
3720
 
3721
      if (warn_assign_intercept)
3722
        warning (0, "instance variable assignment has been intercepted");
3723
 
3724
      result = objc_build_ivar_assignment (outer, lhs, rhs);
3725
 
3726
      goto exit_point;
3727
    }
3728
 
3729
  /* Likewise, intercept assignment to global/static variables if their type is
3730
     GC-marked.  */
3731
  if (objc_is_global_reference_p (outer))
3732
    {
3733
      if (indirect_p)
3734
        goto suggest_cast;
3735
 
3736
     global_reference:
3737
      if (modifycode != NOP_EXPR)
3738
        {
3739
         invalid_pointer_arithmetic:
3740
          if (outer_gc_p)
3741
            warning (0, "pointer arithmetic for garbage-collected objects not allowed");
3742
 
3743
          goto exit_point;
3744
        }
3745
 
3746
      if (warn_assign_intercept)
3747
        warning (0, "global/static variable assignment has been intercepted");
3748
 
3749
      result = objc_build_global_assignment (lhs, rhs);
3750
    }
3751
 
3752
  /* In all other cases, fall back to the normal mechanism.  */
3753
 exit_point:
3754
  return result;
3755
}
3756
 
3757
/* Implementation of the table mapping a class name (as an identifier)
3758
   to a class node.  The two public functions for it are
3759
   lookup_interface() and add_interface().  add_interface() is only
3760
   used in this file, so we can make it static.  */
3761
 
3762
static GTY(()) objc_map_t interface_map;
3763
 
3764
static void
3765
interface_hash_init (void)
3766
{
3767
  interface_map = objc_map_alloc_ggc (200);
3768
}
3769
 
3770
static tree
3771
add_interface (tree class_name, tree name)
3772
{
3773
  /* Put interfaces on list in reverse order.  */
3774
  TREE_CHAIN (class_name) = interface_chain;
3775
  interface_chain = class_name;
3776
 
3777
  /* Add it to the map.  */
3778
  objc_map_put (interface_map, name, class_name);
3779
 
3780
  return interface_chain;
3781
}
3782
 
3783
tree
3784
lookup_interface (tree ident)
3785
{
3786
#ifdef OBJCPLUS
3787
  if (ident && TREE_CODE (ident) == TYPE_DECL)
3788
    ident = DECL_NAME (ident);
3789
#endif
3790
 
3791
  if (ident == NULL_TREE || TREE_CODE (ident) != IDENTIFIER_NODE)
3792
    return NULL_TREE;
3793
 
3794
  {
3795
    tree interface = objc_map_get (interface_map, ident);
3796
 
3797
    if (interface == OBJC_MAP_NOT_FOUND)
3798
      return NULL_TREE;
3799
    else
3800
      return interface;
3801
  }
3802
}
3803
 
3804
 
3805
 
3806
/* Implement @defs (<classname>) within struct bodies.  */
3807
 
3808
tree
3809
objc_get_class_ivars (tree class_name)
3810
{
3811
  tree interface = lookup_interface (class_name);
3812
 
3813
  if (interface)
3814
    return get_class_ivars (interface, true);
3815
 
3816
  error ("cannot find interface declaration for %qE",
3817
         class_name);
3818
 
3819
  return error_mark_node;
3820
}
3821
 
3822
 
3823
/* Functions used by the hashtable for field duplicates in
3824
   objc_detect_field_duplicates().  Ideally, we'd use a standard
3825
   key-value dictionary hashtable , and store as keys the field names,
3826
   and as values the actual declarations (used to print nice error
3827
   messages with the locations).  But, the hashtable we are using only
3828
   allows us to store keys in the hashtable, without values (it looks
3829
   more like a set).  So, we store the DECLs, but define equality as
3830
   DECLs having the same name, and hash as the hash of the name.  */
3831
static hashval_t
3832
hash_instance_variable (const PTR p)
3833
{
3834
  const_tree q = (const_tree)p;
3835
  return (hashval_t) ((intptr_t)(DECL_NAME (q)) >> 3);
3836
}
3837
 
3838
static int
3839
eq_instance_variable (const PTR p1, const PTR p2)
3840
{
3841
  const_tree a = (const_tree)p1;
3842
  const_tree b = (const_tree)p2;
3843
  return DECL_NAME (a) == DECL_NAME (b);
3844
}
3845
 
3846
/* Called when checking the variables in a struct.  If we are not
3847
   doing the ivars list inside an @interface context, then return
3848
   false.  Else, perform the check for duplicate ivars, then return
3849
   true.  The check for duplicates checks if an instance variable with
3850
   the same name exists in the class or in a superclass.  If
3851
   'check_superclasses_only' is set to true, then it is assumed that
3852
   checks for instance variables in the same class has already been
3853
   performed (this is the case for ObjC++) and only the instance
3854
   variables of superclasses are checked.  */
3855
bool
3856
objc_detect_field_duplicates (bool check_superclasses_only)
3857
{
3858
  if (!objc_collecting_ivars || !objc_interface_context
3859
      || TREE_CODE (objc_interface_context) != CLASS_INTERFACE_TYPE)
3860
    return false;
3861
 
3862
  /* We have two ways of doing this check:
3863
 
3864
  "direct comparison": we iterate over the instance variables and
3865
  compare them directly.  This works great for small numbers of
3866
  instance variables (such as 10 or 20), which are extremely common.
3867
  But it will potentially take forever for the pathological case with
3868
  a huge number (eg, 10k) of instance variables.
3869
 
3870
  "hashtable": we use a hashtable, which requires a single sweep
3871
  through the list of instances variables.  This is much slower for a
3872
  small number of variables, and we only use it for large numbers.
3873
 
3874
  To decide which one to use, we need to get an idea of how many
3875
  instance variables we have to compare.  */
3876
  {
3877
    unsigned int number_of_ivars_to_check = 0;
3878
    {
3879
      tree ivar;
3880
      for (ivar = CLASS_RAW_IVARS (objc_interface_context);
3881
           ivar; ivar = DECL_CHAIN (ivar))
3882
        {
3883
          /* Ignore anonymous ivars.  */
3884
          if (DECL_NAME (ivar))
3885
            number_of_ivars_to_check++;
3886
        }
3887
    }
3888
 
3889
    /* Exit if there is nothing to do.  */
3890
    if (number_of_ivars_to_check == 0)
3891
      return true;
3892
 
3893
    /* In case that there are only 1 or 2 instance variables to check,
3894
       we always use direct comparison.  If there are more, it is
3895
       worth iterating over the instance variables in the superclass
3896
       to count how many there are (note that this has the same cost
3897
       as checking 1 instance variable by direct comparison, which is
3898
       why we skip this check in the case of 1 or 2 ivars and just do
3899
       the direct comparison) and then decide if it worth using a
3900
       hashtable.  */
3901
    if (number_of_ivars_to_check > 2)
3902
      {
3903
        unsigned int number_of_superclass_ivars = 0;
3904
        {
3905
          tree interface;
3906
          for (interface = lookup_interface (CLASS_SUPER_NAME (objc_interface_context));
3907
               interface; interface = lookup_interface (CLASS_SUPER_NAME (interface)))
3908
            {
3909
              tree ivar;
3910
              for (ivar = CLASS_RAW_IVARS (interface);
3911
                   ivar; ivar = DECL_CHAIN (ivar))
3912
                number_of_superclass_ivars++;
3913
            }
3914
        }
3915
 
3916
        /* We use a hashtable if we have over 10k comparisons.  */
3917
        if (number_of_ivars_to_check * (number_of_superclass_ivars
3918
                                        + (number_of_ivars_to_check / 2))
3919
            > 10000)
3920
          {
3921
            /* First, build the hashtable by putting all the instance
3922
               variables of superclasses in it.  */
3923
            htab_t htab = htab_create (37, hash_instance_variable,
3924
                                       eq_instance_variable, NULL);
3925
            tree interface;
3926
            for (interface = lookup_interface (CLASS_SUPER_NAME
3927
                                               (objc_interface_context));
3928
                 interface; interface = lookup_interface
3929
                   (CLASS_SUPER_NAME (interface)))
3930
              {
3931
                tree ivar;
3932
                for (ivar = CLASS_RAW_IVARS (interface); ivar;
3933
                     ivar = DECL_CHAIN (ivar))
3934
                  {
3935
                    if (DECL_NAME (ivar) != NULL_TREE)
3936
                      {
3937
                        void **slot = htab_find_slot (htab, ivar, INSERT);
3938
                        /* Do not check for duplicate instance
3939
                           variables in superclasses.  Errors have
3940
                           already been generated.  */
3941
                        *slot = ivar;
3942
                      }
3943
                  }
3944
              }
3945
 
3946
            /* Now, we go through all the instance variables in the
3947
               class, and check that they are not in the
3948
               hashtable.  */
3949
            if (check_superclasses_only)
3950
              {
3951
                tree ivar;
3952
                for (ivar = CLASS_RAW_IVARS (objc_interface_context); ivar;
3953
                     ivar = DECL_CHAIN (ivar))
3954
                  {
3955
                    if (DECL_NAME (ivar) != NULL_TREE)
3956
                      {
3957
                        tree duplicate_ivar = (tree)(htab_find (htab, ivar));
3958
                        if (duplicate_ivar != HTAB_EMPTY_ENTRY)
3959
                          {
3960
                            error_at (DECL_SOURCE_LOCATION (ivar),
3961
                                      "duplicate instance variable %q+D",
3962
                                      ivar);
3963
                            inform (DECL_SOURCE_LOCATION (duplicate_ivar),
3964
                                    "previous declaration of %q+D",
3965
                                    duplicate_ivar);
3966
                            /* FIXME: Do we need the following ?  */
3967
                            /* DECL_NAME (ivar) = NULL_TREE; */
3968
                          }
3969
                      }
3970
                  }
3971
              }
3972
            else
3973
              {
3974
                /* If we're checking for duplicates in the class as
3975
                   well, we insert variables in the hashtable as we
3976
                   check them, so if a duplicate follows, it will be
3977
                   caught.  */
3978
                tree ivar;
3979
                for (ivar = CLASS_RAW_IVARS (objc_interface_context); ivar;
3980
                     ivar = DECL_CHAIN (ivar))
3981
                  {
3982
                    if (DECL_NAME (ivar) != NULL_TREE)
3983
                      {
3984
                        void **slot = htab_find_slot (htab, ivar, INSERT);
3985
                        if (*slot)
3986
                          {
3987
                            tree duplicate_ivar = (tree)(*slot);
3988
                            error_at (DECL_SOURCE_LOCATION (ivar),
3989
                                      "duplicate instance variable %q+D",
3990
                                      ivar);
3991
                            inform (DECL_SOURCE_LOCATION (duplicate_ivar),
3992
                                    "previous declaration of %q+D",
3993
                                    duplicate_ivar);
3994
                            /* FIXME: Do we need the following ?  */
3995
                            /* DECL_NAME (ivar) = NULL_TREE; */
3996
                          }
3997
                        *slot = ivar;
3998
                      }
3999
                  }
4000
              }
4001
            htab_delete (htab);
4002
            return true;
4003
          }
4004
      }
4005
  }
4006
 
4007
  /* This is the "direct comparison" approach, which is used in most
4008
     non-pathological cases.  */
4009
  {
4010
    /* Walk up to class hierarchy, starting with this class (this is
4011
       the external loop, because lookup_interface() is expensive, and
4012
       we want to do it few times).  */
4013
    tree interface = objc_interface_context;
4014
 
4015
    if (check_superclasses_only)
4016
      interface = lookup_interface (CLASS_SUPER_NAME (interface));
4017
 
4018
    for ( ; interface; interface = lookup_interface
4019
            (CLASS_SUPER_NAME (interface)))
4020
      {
4021
        tree ivar_being_checked;
4022
 
4023
        for (ivar_being_checked = CLASS_RAW_IVARS (objc_interface_context);
4024
             ivar_being_checked;
4025
             ivar_being_checked = DECL_CHAIN (ivar_being_checked))
4026
          {
4027
            tree decl;
4028
 
4029
            /* Ignore anonymous ivars.  */
4030
            if (DECL_NAME (ivar_being_checked) == NULL_TREE)
4031
              continue;
4032
 
4033
            /* Note how we stop when we find the ivar we are checking
4034
               (this can only happen in the main class, not
4035
               superclasses), to avoid comparing things twice
4036
               (otherwise, for each ivar, you'd compare A to B then B
4037
               to A, and get duplicated error messages).  */
4038
            for (decl = CLASS_RAW_IVARS (interface);
4039
                 decl && decl != ivar_being_checked;
4040
                 decl = DECL_CHAIN (decl))
4041
              {
4042
                if (DECL_NAME (ivar_being_checked) == DECL_NAME (decl))
4043
                  {
4044
                    error_at (DECL_SOURCE_LOCATION (ivar_being_checked),
4045
                              "duplicate instance variable %q+D",
4046
                              ivar_being_checked);
4047
                    inform (DECL_SOURCE_LOCATION (decl),
4048
                            "previous declaration of %q+D",
4049
                            decl);
4050
                    /* FIXME: Do we need the following ?  */
4051
                    /* DECL_NAME (ivar_being_checked) = NULL_TREE; */
4052
                  }
4053
              }
4054
          }
4055
      }
4056
  }
4057
  return true;
4058
}
4059
 
4060
/* Used by: build_private_template, continue_class,
4061
   and for @defs constructs.  */
4062
 
4063
static tree
4064
get_class_ivars (tree interface, bool inherited)
4065
{
4066
  tree ivar_chain = copy_list (CLASS_RAW_IVARS (interface));
4067
 
4068
  /* Both CLASS_RAW_IVARS and CLASS_IVARS contain a list of ivars declared
4069
     by the current class (i.e., they do not include super-class ivars).
4070
     However, the CLASS_IVARS list will be side-effected by a call to
4071
     finish_struct(), which will fill in field offsets.  */
4072
  if (!CLASS_IVARS (interface))
4073
    CLASS_IVARS (interface) = ivar_chain;
4074
 
4075
  if (!inherited)
4076
    return ivar_chain;
4077
 
4078
  while (CLASS_SUPER_NAME (interface))
4079
    {
4080
      /* Prepend super-class ivars.  */
4081
      interface = lookup_interface (CLASS_SUPER_NAME (interface));
4082
      ivar_chain = chainon (copy_list (CLASS_RAW_IVARS (interface)),
4083
                            ivar_chain);
4084
    }
4085
 
4086
  return ivar_chain;
4087
}
4088
 
4089
void
4090
objc_maybe_warn_exceptions (location_t loc)
4091
{
4092
  /* -fobjc-exceptions is required to enable Objective-C exceptions.
4093
     For example, on Darwin, ObjC exceptions require a sufficiently
4094
     recent version of the runtime, so the user must ask for them
4095
     explicitly.  On other platforms, at the moment -fobjc-exceptions
4096
     triggers -fexceptions which again is required for exceptions to
4097
     work.  */
4098
  if (!flag_objc_exceptions)
4099
    {
4100
      /* Warn only once per compilation unit.  */
4101
      static bool warned = false;
4102
 
4103
      if (!warned)
4104
        {
4105
          error_at (loc, "%<-fobjc-exceptions%> is required to enable Objective-C exception syntax");
4106
          warned = true;
4107
        }
4108
    }
4109
}
4110
 
4111
static struct objc_try_context *cur_try_context;
4112
 
4113
/* Called just after parsing the @try and its associated BODY.  We now
4114
   must prepare for the tricky bits -- handling the catches and finally.  */
4115
 
4116
void
4117
objc_begin_try_stmt (location_t try_locus, tree body)
4118
{
4119
  struct objc_try_context *c = XCNEW (struct objc_try_context);
4120
  c->outer = cur_try_context;
4121
  c->try_body = body;
4122
  c->try_locus = try_locus;
4123
  c->end_try_locus = input_location;
4124
  cur_try_context = c;
4125
 
4126
  /* Collect the list of local variables.  We'll mark them as volatile
4127
     at the end of compilation of this function to prevent them being
4128
     clobbered by setjmp/longjmp.  */
4129
  if (flag_objc_sjlj_exceptions)
4130
    objc_mark_locals_volatile (NULL);
4131
}
4132
 
4133
/* Called just after parsing "@catch (parm)".  Open a binding level,
4134
   enter DECL into the binding level, and initialize it.  Leave the
4135
   binding level open while the body of the compound statement is
4136
   parsed.  If DECL is NULL_TREE, then we are compiling "@catch(...)"
4137
   which we compile as "@catch(id tmp_variable)".  */
4138
 
4139
void
4140
objc_begin_catch_clause (tree decl)
4141
{
4142
  tree compound, type, t;
4143
  bool ellipsis = false;
4144
 
4145
  /* Begin a new scope that the entire catch clause will live in.  */
4146
  compound = c_begin_compound_stmt (true);
4147
 
4148
  /* Create the appropriate declaration for the argument.  */
4149
 if (decl == error_mark_node)
4150
   type = error_mark_node;
4151
 else
4152
   {
4153
     if (decl == NULL_TREE)
4154
       {
4155
         /* If @catch(...) was specified, create a temporary variable of
4156
            type 'id' and use it.  */
4157
         decl = objc_create_temporary_var (objc_object_type, "__objc_generic_catch_var");
4158
         DECL_SOURCE_LOCATION (decl) = input_location;
4159
         /* ... but allow the runtime to differentiate between ellipsis and the
4160
            case of @catch (id xyz).  */
4161
         ellipsis = true;
4162
       }
4163
     else
4164
       {
4165
         /* The parser passed in a PARM_DECL, but what we really want is a VAR_DECL.  */
4166
         decl = build_decl (input_location,
4167
                            VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl));
4168
       }
4169
     lang_hooks.decls.pushdecl (decl);
4170
 
4171
     /* Mark the declaration as used so you never any warnings whether
4172
        you use the exception argument or not.  TODO: Implement a
4173
        -Wunused-exception-parameter flag, which would cause warnings
4174
        if exception parameter is not used.  */
4175
     TREE_USED (decl) = 1;
4176
     DECL_READ_P (decl) = 1;
4177
 
4178
     type = TREE_TYPE (decl);
4179
   }
4180
 
4181
  /* Verify that the type of the catch is valid.  It must be a pointer
4182
     to an Objective-C class, or "id" (which is catch-all).  */
4183
  if (type == error_mark_node)
4184
    {
4185
      ;/* Just keep going.  */
4186
    }
4187
  else if (!objc_type_valid_for_messaging (type, false))
4188
    {
4189
      error ("@catch parameter is not a known Objective-C class type");
4190
      type = error_mark_node;
4191
    }
4192
  else if (TYPE_HAS_OBJC_INFO (TREE_TYPE (type))
4193
           && TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (type)))
4194
    {
4195
      error ("@catch parameter can not be protocol-qualified");
4196
      type = error_mark_node;
4197
    }
4198
  else if (POINTER_TYPE_P (type) && objc_is_object_id (TREE_TYPE (type)))
4199
    /* @catch (id xyz) or @catch (...) but we note this for runtimes that
4200
       identify 'id'.  */
4201
    ;
4202
  else
4203
    {
4204
      /* If 'type' was built using typedefs, we need to get rid of
4205
         them and get a simple pointer to the class.  */
4206
      bool is_typedef = false;
4207
      tree x = TYPE_MAIN_VARIANT (type);
4208
 
4209
      /* Skip from the pointer to the pointee.  */
4210
      if (TREE_CODE (x) == POINTER_TYPE)
4211
        x = TREE_TYPE (x);
4212
 
4213
      /* Traverse typedef aliases */
4214
      while (TREE_CODE (x) == RECORD_TYPE && OBJC_TYPE_NAME (x)
4215
             && TREE_CODE (OBJC_TYPE_NAME (x)) == TYPE_DECL
4216
             && DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (x)))
4217
        {
4218
          is_typedef = true;
4219
          x = DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (x));
4220
        }
4221
 
4222
      /* If it was a typedef, build a pointer to the final, original
4223
         class.  */
4224
      if (is_typedef)
4225
        type = build_pointer_type (x);
4226
 
4227
      if (cur_try_context->catch_list)
4228
        {
4229
          /* Examine previous @catch clauses and see if we've already
4230
             caught the type in question.  */
4231
          tree_stmt_iterator i = tsi_start (cur_try_context->catch_list);
4232
          for (; !tsi_end_p (i); tsi_next (&i))
4233
            {
4234
              tree stmt = tsi_stmt (i);
4235
              t = CATCH_TYPES (stmt);
4236
              if (t == error_mark_node)
4237
                continue;
4238
              if (!t || DERIVED_FROM_P (TREE_TYPE (t), TREE_TYPE (type)))
4239
                {
4240
                  warning (0, "exception of type %<%T%> will be caught",
4241
                           TREE_TYPE (type));
4242
                  warning_at  (EXPR_LOCATION (stmt), 0, "   by earlier handler for %<%T%>",
4243
                               TREE_TYPE (t ? t : objc_object_type));
4244
                  break;
4245
                }
4246
            }
4247
        }
4248
    }
4249
 
4250
  t = (*runtime.begin_catch) (&cur_try_context, type, decl, compound, ellipsis);
4251
  add_stmt (t);
4252
}
4253
 
4254
/* Called just after parsing the closing brace of a @catch clause.  Close
4255
   the open binding level, and record a CATCH_EXPR for it.  */
4256
 
4257
void
4258
objc_finish_catch_clause (void)
4259
{
4260
  tree c = cur_try_context->current_catch;
4261
  cur_try_context->current_catch = NULL;
4262
  cur_try_context->end_catch_locus = input_location;
4263
 
4264
  CATCH_BODY (c) = c_end_compound_stmt (input_location, CATCH_BODY (c), 1);
4265
 
4266
  (*runtime.finish_catch) (&cur_try_context, c);
4267
}
4268
 
4269
/* Called after parsing a @finally clause and its associated BODY.
4270
   Record the body for later placement.  */
4271
 
4272
void
4273
objc_build_finally_clause (location_t finally_locus, tree body)
4274
{
4275
  cur_try_context->finally_body = body;
4276
  cur_try_context->finally_locus = finally_locus;
4277
  cur_try_context->end_finally_locus = input_location;
4278
}
4279
 
4280
/* Called to finalize a @try construct.  */
4281
 
4282
tree
4283
objc_finish_try_stmt (void)
4284
{
4285
  struct objc_try_context *c = cur_try_context;
4286
  tree stmt;
4287
 
4288
  if (c->catch_list == NULL && c->finally_body == NULL)
4289
    error ("%<@try%> without %<@catch%> or %<@finally%>");
4290
 
4291
  stmt = (*runtime.finish_try_stmt) (&cur_try_context);
4292
  add_stmt (stmt);
4293
 
4294
  cur_try_context = c->outer;
4295
  free (c);
4296
  return stmt;
4297
}
4298
 
4299
tree
4300
objc_build_throw_stmt (location_t loc, tree throw_expr)
4301
{
4302
  bool rethrown = false;
4303
 
4304
  objc_maybe_warn_exceptions (loc);
4305
 
4306
  /* Don't waste time trying to build something if we're already dead.  */
4307
  if (throw_expr == error_mark_node)
4308
    return error_mark_node;
4309
 
4310
  if (throw_expr == NULL)
4311
    {
4312
      /* If we're not inside a @catch block, there is no "current
4313
         exception" to be rethrown.  */
4314
      if (cur_try_context == NULL
4315
          || cur_try_context->current_catch == NULL)
4316
        {
4317
          error_at (loc, "%<@throw%> (rethrow) used outside of a @catch block");
4318
          return error_mark_node;
4319
        }
4320
 
4321
      /* Otherwise the object is still sitting in the EXC_PTR_EXPR
4322
         value that we get from the runtime.  */
4323
      throw_expr = (*runtime.build_exc_ptr) (&cur_try_context);
4324
      rethrown = true;
4325
    }
4326
  else
4327
    {
4328
      if (!objc_type_valid_for_messaging (TREE_TYPE (throw_expr), true))
4329
        {
4330
          error_at (loc, "%<@throw%> argument is not an object");
4331
          return error_mark_node;
4332
        }
4333
    }
4334
 
4335
  return (*runtime.build_throw_stmt) (loc, throw_expr, rethrown);
4336
}
4337
 
4338
tree
4339
objc_build_synchronized (location_t start_locus, tree object_expr, tree body)
4340
{
4341
  /* object_expr should never be NULL; but in case it is, convert it to
4342
     error_mark_node.  */
4343
  if (object_expr == NULL)
4344
    object_expr = error_mark_node;
4345
 
4346
  /* Validate object_expr.  If not valid, set it to error_mark_node.  */
4347
  if (object_expr != error_mark_node)
4348
    {
4349
      if (!objc_type_valid_for_messaging (TREE_TYPE (object_expr), true))
4350
        {
4351
          error_at (start_locus, "%<@synchronized%> argument is not an object");
4352
          object_expr = error_mark_node;
4353
        }
4354
    }
4355
 
4356
  if (object_expr == error_mark_node)
4357
    {
4358
      /* If we found an error, we simply ignore the '@synchronized'.
4359
         Compile the body so we can keep going with minimal
4360
         casualties.  */
4361
      return add_stmt (body);
4362
    }
4363
  else
4364
    {
4365
      tree call;
4366
      tree args;
4367
 
4368
      /* objc_sync_enter (object_expr); */
4369
      object_expr = save_expr (object_expr);
4370
      args = tree_cons (NULL, object_expr, NULL);
4371
      call = build_function_call (input_location,
4372
                                  objc_sync_enter_decl, args);
4373
      SET_EXPR_LOCATION (call, start_locus);
4374
      add_stmt (call);
4375
 
4376
      /* Build "objc_sync_exit (object_expr);" but do not add it yet;
4377
         it goes inside the @finalize() clause.  */
4378
      args = tree_cons (NULL, object_expr, NULL);
4379
      call = build_function_call (input_location,
4380
                                  objc_sync_exit_decl, args);
4381
      SET_EXPR_LOCATION (call, input_location);
4382
 
4383
      /* @try { body; } */
4384
      objc_begin_try_stmt (start_locus, body);
4385
 
4386
      /* @finally { objc_sync_exit (object_expr); } */
4387
      objc_build_finally_clause (input_location, call);
4388
 
4389
      /* End of try statement.  */
4390
      return objc_finish_try_stmt ();
4391
    }
4392
}
4393
 
4394
/* Construct a C struct corresponding to ObjC class CLASS, with the same
4395
   name as the class:
4396
 
4397
   struct <classname> {
4398
     struct _objc_class *isa;
4399
     ...
4400
   };  */
4401
 
4402
static void
4403
build_private_template (tree klass)
4404
{
4405
  if (!CLASS_STATIC_TEMPLATE (klass))
4406
    {
4407
      tree record = objc_build_struct (klass,
4408
                                       get_class_ivars (klass, false),
4409
                                       CLASS_SUPER_NAME (klass));
4410
 
4411
      /* Set the TREE_USED bit for this struct, so that stab generator
4412
         can emit stabs for this struct type.  */
4413
      if (flag_debug_only_used_symbols && TYPE_STUB_DECL (record))
4414
        TREE_USED (TYPE_STUB_DECL (record)) = 1;
4415
 
4416
      /* Copy the attributes from the class to the type.  */
4417
      if (TREE_DEPRECATED (klass))
4418
        TREE_DEPRECATED (record) = 1;
4419
    }
4420
}
4421
 
4422
/* Generate either '- .cxx_construct' or '- .cxx_destruct' for the
4423
   current class.  */
4424
#ifdef OBJCPLUS
4425
static void
4426
objc_generate_cxx_ctor_or_dtor (bool dtor)
4427
{
4428
  tree fn, body, compound_stmt, ivar;
4429
 
4430
  /* - (id) .cxx_construct { ... return self; } */
4431
  /* - (void) .cxx_construct { ... }            */
4432
 
4433
  objc_start_method_definition
4434
    (false /* is_class_method */,
4435
     objc_build_method_signature (false /* is_class_method */,
4436
                                  build_tree_list (NULL_TREE,
4437
                                                   dtor
4438
                                                   ? void_type_node
4439
                                                   : objc_object_type),
4440
                                  get_identifier (dtor
4441
                                                  ? TAG_CXX_DESTRUCT
4442
                                                  : TAG_CXX_CONSTRUCT),
4443
                                  make_node (TREE_LIST),
4444
                                  false), NULL, NULL_TREE);
4445
  body = begin_function_body ();
4446
  compound_stmt = begin_compound_stmt (0);
4447
 
4448
  ivar = CLASS_IVARS (implementation_template);
4449
  /* Destroy ivars in reverse order.  */
4450
  if (dtor)
4451
    ivar = nreverse (copy_list (ivar));
4452
 
4453
  for (; ivar; ivar = TREE_CHAIN (ivar))
4454
    {
4455
      if (TREE_CODE (ivar) == FIELD_DECL)
4456
        {
4457
          tree type = TREE_TYPE (ivar);
4458
 
4459
          /* Call the ivar's default constructor or destructor.  Do not
4460
             call the destructor unless a corresponding constructor call
4461
             has also been made (or is not needed).  */
4462
          if (MAYBE_CLASS_TYPE_P (type)
4463
              && (dtor
4464
                  ? (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
4465
                     && (!TYPE_NEEDS_CONSTRUCTING (type)
4466
                         || TYPE_HAS_DEFAULT_CONSTRUCTOR (type)))
4467
                  : (TYPE_NEEDS_CONSTRUCTING (type)
4468
                     && TYPE_HAS_DEFAULT_CONSTRUCTOR (type))))
4469
            finish_expr_stmt
4470
             (build_special_member_call
4471
              (build_ivar_reference (DECL_NAME (ivar)),
4472
               dtor ? complete_dtor_identifier : complete_ctor_identifier,
4473
               NULL, type, LOOKUP_NORMAL, tf_warning_or_error));
4474
        }
4475
    }
4476
 
4477
  /* The constructor returns 'self'.  */
4478
  if (!dtor)
4479
    finish_return_stmt (self_decl);
4480
 
4481
  finish_compound_stmt (compound_stmt);
4482
  finish_function_body (body);
4483
  fn = current_function_decl;
4484
  finish_function ();
4485
  objc_finish_method_definition (fn);
4486
}
4487
 
4488
/* The following routine will examine the current @interface for any
4489
   non-POD C++ ivars requiring non-trivial construction and/or
4490
   destruction, and then synthesize special '- .cxx_construct' and/or
4491
   '- .cxx_destruct' methods which will run the appropriate
4492
   construction or destruction code.  Note that ivars inherited from
4493
   super-classes are _not_ considered.  */
4494
static void
4495
objc_generate_cxx_cdtors (void)
4496
{
4497
  bool need_ctor = false, need_dtor = false;
4498
  tree ivar;
4499
 
4500
  /* Error case, due to possibly an extra @end. */
4501
  if (!objc_implementation_context)
4502
    return;
4503
 
4504
  /* We do not want to do this for categories, since they do not have
4505
     their own ivars.  */
4506
 
4507
  if (TREE_CODE (objc_implementation_context) != CLASS_IMPLEMENTATION_TYPE)
4508
    return;
4509
 
4510
  /* First, determine if we even need a constructor and/or destructor.  */
4511
 
4512
  for (ivar = CLASS_IVARS (implementation_template); ivar;
4513
       ivar = TREE_CHAIN (ivar))
4514
    {
4515
      if (TREE_CODE (ivar) == FIELD_DECL)
4516
        {
4517
          tree type = TREE_TYPE (ivar);
4518
 
4519
          if (MAYBE_CLASS_TYPE_P (type))
4520
            {
4521
              if (TYPE_NEEDS_CONSTRUCTING (type)
4522
                  && TYPE_HAS_DEFAULT_CONSTRUCTOR (type))
4523
                /* NB: If a default constructor is not available, we will not
4524
                   be able to initialize this ivar; the add_instance_variable()
4525
                   routine will already have warned about this.  */
4526
                need_ctor = true;
4527
 
4528
              if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
4529
                  && (!TYPE_NEEDS_CONSTRUCTING (type)
4530
                      || TYPE_HAS_DEFAULT_CONSTRUCTOR (type)))
4531
                /* NB: If a default constructor is not available, we will not
4532
                   call the destructor either, for symmetry.  */
4533
                need_dtor = true;
4534
            }
4535
        }
4536
    }
4537
 
4538
  /* Generate '- .cxx_construct' if needed.  */
4539
 
4540
  if (need_ctor)
4541
    objc_generate_cxx_ctor_or_dtor (false);
4542
 
4543
  /* Generate '- .cxx_destruct' if needed.  */
4544
 
4545
  if (need_dtor)
4546
    objc_generate_cxx_ctor_or_dtor (true);
4547
 
4548
  /* The 'imp_list' variable points at an imp_entry record for the current
4549
     @implementation.  Record the existence of '- .cxx_construct' and/or
4550
     '- .cxx_destruct' methods therein; it will be included in the
4551
     metadata for the class if the runtime needs it.  */
4552
  imp_list->has_cxx_cdtors = (need_ctor || need_dtor);
4553
}
4554
#endif
4555
 
4556
static void
4557
error_with_ivar (const char *message, tree decl)
4558
{
4559
  error_at (DECL_SOURCE_LOCATION (decl), "%s %qs",
4560
            message, identifier_to_locale (gen_declaration (decl)));
4561
 
4562
}
4563
 
4564
static void
4565
check_ivars (tree inter, tree imp)
4566
{
4567
  tree intdecls = CLASS_RAW_IVARS (inter);
4568
  tree impdecls = CLASS_RAW_IVARS (imp);
4569
 
4570
  while (1)
4571
    {
4572
      tree t1, t2;
4573
 
4574
#ifdef OBJCPLUS
4575
      if (intdecls && TREE_CODE (intdecls) == TYPE_DECL)
4576
        intdecls = TREE_CHAIN (intdecls);
4577
#endif
4578
      if (intdecls == 0 && impdecls == 0)
4579
        break;
4580
      if (intdecls == 0 || impdecls == 0)
4581
        {
4582
          error ("inconsistent instance variable specification");
4583
          break;
4584
        }
4585
 
4586
      t1 = TREE_TYPE (intdecls); t2 = TREE_TYPE (impdecls);
4587
 
4588
      if (!comptypes (t1, t2)
4589
          || !tree_int_cst_equal (DECL_INITIAL (intdecls),
4590
                                  DECL_INITIAL (impdecls)))
4591
        {
4592
          if (DECL_NAME (intdecls) == DECL_NAME (impdecls))
4593
            {
4594
              error_with_ivar ("conflicting instance variable type",
4595
                               impdecls);
4596
              error_with_ivar ("previous declaration of",
4597
                               intdecls);
4598
            }
4599
          else                  /* both the type and the name don't match */
4600
            {
4601
              error ("inconsistent instance variable specification");
4602
              break;
4603
            }
4604
        }
4605
 
4606
      else if (DECL_NAME (intdecls) != DECL_NAME (impdecls))
4607
        {
4608
          error_with_ivar ("conflicting instance variable name",
4609
                           impdecls);
4610
          error_with_ivar ("previous declaration of",
4611
                           intdecls);
4612
        }
4613
 
4614
      intdecls = DECL_CHAIN (intdecls);
4615
      impdecls = DECL_CHAIN (impdecls);
4616
    }
4617
}
4618
 
4619
 
4620
static void
4621
mark_referenced_methods (void)
4622
{
4623
  struct imp_entry *impent;
4624
  tree chain;
4625
 
4626
  for (impent = imp_list; impent; impent = impent->next)
4627
    {
4628
      chain = CLASS_CLS_METHODS (impent->imp_context);
4629
      while (chain)
4630
        {
4631
          cgraph_mark_needed_node (
4632
                           cgraph_get_create_node (METHOD_DEFINITION (chain)));
4633
          chain = DECL_CHAIN (chain);
4634
        }
4635
 
4636
      chain = CLASS_NST_METHODS (impent->imp_context);
4637
      while (chain)
4638
        {
4639
          cgraph_mark_needed_node (
4640
                           cgraph_get_create_node (METHOD_DEFINITION (chain)));
4641
          chain = DECL_CHAIN (chain);
4642
        }
4643
    }
4644
}
4645
 
4646
/* If type is empty or only type qualifiers are present, add default
4647
   type of id (otherwise grokdeclarator will default to int).  */
4648
static inline tree
4649
adjust_type_for_id_default (tree type)
4650
{
4651
  if (!type)
4652
    type = make_node (TREE_LIST);
4653
 
4654
  if (!TREE_VALUE (type))
4655
    TREE_VALUE (type) = objc_object_type;
4656
  else if (TREE_CODE (TREE_VALUE (type)) == RECORD_TYPE
4657
           && TYPED_OBJECT (TREE_VALUE (type)))
4658
    error ("can not use an object as parameter to a method");
4659
 
4660
  return type;
4661
}
4662
 
4663
/* Return a KEYWORD_DECL built using the specified key_name, arg_type,
4664
   arg_name and attributes. (TODO: Rename KEYWORD_DECL to
4665
   OBJC_METHOD_PARM_DECL ?)
4666
 
4667
   A KEYWORD_DECL is a tree representing the declaration of a
4668
   parameter of an Objective-C method.  It is produced when parsing a
4669
   fragment of Objective-C method declaration of the form
4670
 
4671
   keyworddecl:
4672
     selector ':' '(' typename ')' identifier
4673
 
4674
   For example, take the Objective-C method
4675
 
4676
   -(NSString *)pathForResource:(NSString *)resource ofType:(NSString *)type;
4677
 
4678
   the two fragments "pathForResource:(NSString *)resource" and
4679
   "ofType:(NSString *)type" will generate a KEYWORD_DECL each.  The
4680
   KEYWORD_DECL stores the 'key_name' (eg, identifier for
4681
   "pathForResource"), the 'arg_type' (eg, tree representing a
4682
   NSString *), the 'arg_name' (eg identifier for "resource") and
4683
   potentially some attributes (for example, a tree representing
4684
   __attribute__ ((unused)) if such an attribute was attached to a
4685
   certain parameter).  You can access this information using the
4686
   TREE_TYPE (for arg_type), KEYWORD_ARG_NAME (for arg_name),
4687
   KEYWORD_KEY_NAME (for key_name), DECL_ATTRIBUTES (for attributes).
4688
 
4689
   'key_name' is an identifier node (and is optional as you can omit
4690
   it in Objective-C methods).
4691
   'arg_type' is a tree list (and is optional too if no parameter type
4692
   was specified).
4693
   'arg_name' is an identifier node and is required.
4694
   'attributes' is an optional tree containing parameter attributes.  */
4695
tree
4696
objc_build_keyword_decl (tree key_name, tree arg_type,
4697
                         tree arg_name, tree attributes)
4698
{
4699
  tree keyword_decl;
4700
 
4701
  if (flag_objc1_only && attributes)
4702
    error_at (input_location, "method argument attributes are not available in Objective-C 1.0");
4703
 
4704
  /* If no type is specified, default to "id".  */
4705
  arg_type = adjust_type_for_id_default (arg_type);
4706
 
4707
  keyword_decl = make_node (KEYWORD_DECL);
4708
 
4709
  TREE_TYPE (keyword_decl) = arg_type;
4710
  KEYWORD_ARG_NAME (keyword_decl) = arg_name;
4711
  KEYWORD_KEY_NAME (keyword_decl) = key_name;
4712
  DECL_ATTRIBUTES (keyword_decl) = attributes;
4713
 
4714
  return keyword_decl;
4715
}
4716
 
4717
/* Given a chain of keyword_decl's, synthesize the full keyword selector.  */
4718
static tree
4719
build_keyword_selector (tree selector)
4720
{
4721
  int len = 0;
4722
  tree key_chain, key_name;
4723
  char *buf;
4724
 
4725
  /* Scan the selector to see how much space we'll need.  */
4726
  for (key_chain = selector; key_chain; key_chain = TREE_CHAIN (key_chain))
4727
    {
4728
      switch (TREE_CODE (selector))
4729
        {
4730
        case KEYWORD_DECL:
4731
          key_name = KEYWORD_KEY_NAME (key_chain);
4732
          break;
4733
        case TREE_LIST:
4734
          key_name = TREE_PURPOSE (key_chain);
4735
          break;
4736
        default:
4737
          gcc_unreachable ();
4738
        }
4739
 
4740
      if (key_name)
4741
        len += IDENTIFIER_LENGTH (key_name) + 1;
4742
      else
4743
        /* Just a ':' arg.  */
4744
        len++;
4745
    }
4746
 
4747
  buf = (char *) alloca (len + 1);
4748
  /* Start the buffer out as an empty string.  */
4749
  buf[0] = '\0';
4750
 
4751
  for (key_chain = selector; key_chain; key_chain = TREE_CHAIN (key_chain))
4752
    {
4753
      switch (TREE_CODE (selector))
4754
        {
4755
        case KEYWORD_DECL:
4756
          key_name = KEYWORD_KEY_NAME (key_chain);
4757
          break;
4758
        case TREE_LIST:
4759
          key_name = TREE_PURPOSE (key_chain);
4760
          /* The keyword decl chain will later be used as a function
4761
             argument chain.  Unhook the selector itself so as to not
4762
             confuse other parts of the compiler.  */
4763
          TREE_PURPOSE (key_chain) = NULL_TREE;
4764
          break;
4765
        default:
4766
          gcc_unreachable ();
4767
        }
4768
 
4769
      if (key_name)
4770
        strcat (buf, IDENTIFIER_POINTER (key_name));
4771
      strcat (buf, ":");
4772
    }
4773
 
4774
  return get_identifier_with_length (buf, len);
4775
}
4776
 
4777
/* Used for declarations and definitions.  */
4778
 
4779
static tree
4780
build_method_decl (enum tree_code code, tree ret_type, tree selector,
4781
                   tree add_args, bool ellipsis)
4782
{
4783
  tree method_decl;
4784
 
4785
  /* If no type is specified, default to "id".  */
4786
  ret_type = adjust_type_for_id_default (ret_type);
4787
 
4788
  /* Note how a method_decl has a TREE_TYPE which is not the function
4789
     type of the function implementing the method, but only the return
4790
     type of the method.  We may want to change this, and store the
4791
     entire function type in there (eg, it may be used to simplify
4792
     dealing with attributes below).  */
4793
  method_decl = make_node (code);
4794
  TREE_TYPE (method_decl) = ret_type;
4795
 
4796
  /* If we have a keyword selector, create an identifier_node that
4797
     represents the full selector name (`:' included)...  */
4798
  if (TREE_CODE (selector) == KEYWORD_DECL)
4799
    {
4800
      METHOD_SEL_NAME (method_decl) = build_keyword_selector (selector);
4801
      METHOD_SEL_ARGS (method_decl) = selector;
4802
      METHOD_ADD_ARGS (method_decl) = add_args;
4803
      METHOD_ADD_ARGS_ELLIPSIS_P (method_decl) = ellipsis;
4804
    }
4805
  else
4806
    {
4807
      METHOD_SEL_NAME (method_decl) = selector;
4808
      METHOD_SEL_ARGS (method_decl) = NULL_TREE;
4809
      METHOD_ADD_ARGS (method_decl) = NULL_TREE;
4810
    }
4811
 
4812
  return method_decl;
4813
}
4814
 
4815
/* This routine processes objective-c method attributes. */
4816
 
4817
static void
4818
objc_decl_method_attributes (tree *node, tree attributes, int flags)
4819
{
4820
  /* TODO: Replace the hackery below.  An idea would be to store the
4821
     full function type in the method declaration (for example in
4822
     TREE_TYPE) and then expose ObjC method declarations to c-family
4823
     and they could deal with them by simply treating them as
4824
     functions.  */
4825
 
4826
  /* Because of the dangers in the hackery below, we filter out any
4827
     attribute that we do not know about.  For the ones we know about,
4828
     we know that they work with the hackery.  For the other ones,
4829
     there is no guarantee, so we have to filter them out.  */
4830
  tree filtered_attributes = NULL_TREE;
4831
 
4832
  if (attributes)
4833
    {
4834
      tree attribute;
4835
      for (attribute = attributes; attribute; attribute = TREE_CHAIN (attribute))
4836
        {
4837
          tree name = TREE_PURPOSE (attribute);
4838
 
4839
          if (is_attribute_p  ("deprecated", name)
4840
              || is_attribute_p ("sentinel", name)
4841
              || is_attribute_p ("noreturn", name))
4842
            {
4843
              /* An attribute that we support; add it to the filtered
4844
                 attributes.  */
4845
              filtered_attributes = chainon (filtered_attributes,
4846
                                             copy_node (attribute));
4847
            }
4848
          else if (is_attribute_p ("format", name))
4849
            {
4850
              /* "format" is special because before adding it to the
4851
                 filtered attributes we need to adjust the specified
4852
                 format by adding the hidden function parameters for
4853
                 an Objective-C method (self, _cmd).  */
4854
              tree new_attribute = copy_node (attribute);
4855
 
4856
              /* Check the arguments specified with the attribute, and
4857
                 modify them adding 2 for the two hidden arguments.
4858
                 Note how this differs from C++; according to the
4859
                 specs, C++ does not do it so you have to add the +1
4860
                 yourself.  For Objective-C, instead, the compiler
4861
                 adds the +2 for you.  */
4862
 
4863
              /* The attribute arguments have not been checked yet, so
4864
                 we need to be careful as they could be missing or
4865
                 invalid.  If anything looks wrong, we skip the
4866
                 process and the compiler will complain about it later
4867
                 when it validates the attribute.  */
4868
              /* Check that we have at least three arguments.  */
4869
              if (TREE_VALUE (new_attribute)
4870
                  && TREE_CHAIN (TREE_VALUE (new_attribute))
4871
                  && TREE_CHAIN (TREE_CHAIN (TREE_VALUE (new_attribute))))
4872
                {
4873
                  tree second_argument = TREE_CHAIN (TREE_VALUE (new_attribute));
4874
                  tree third_argument = TREE_CHAIN (second_argument);
4875
                  tree number;
4876
 
4877
                  /* This is the second argument, the "string-index",
4878
                     which specifies the index of the format string
4879
                     argument.  Add 2.  */
4880
                  number = TREE_VALUE (second_argument);
4881
                  if (number
4882
                      && TREE_CODE (number) == INTEGER_CST
4883
                      && TREE_INT_CST_HIGH (number) == 0)
4884
                    {
4885
                      TREE_VALUE (second_argument)
4886
                        = build_int_cst (integer_type_node,
4887
                                         TREE_INT_CST_LOW (number) + 2);
4888
                    }
4889
 
4890
                  /* This is the third argument, the "first-to-check",
4891
                     which specifies the index of the first argument to
4892
                     check.  This could be 0, meaning it is not available,
4893
                     in which case we don't need to add 2.  Add 2 if not
4894
                     0.  */
4895
                  number = TREE_VALUE (third_argument);
4896
                  if (number
4897
                      && TREE_CODE (number) == INTEGER_CST
4898
                      && TREE_INT_CST_HIGH (number) == 0
4899
                      && TREE_INT_CST_LOW (number) != 0)
4900
                    {
4901
                      TREE_VALUE (third_argument)
4902
                        = build_int_cst (integer_type_node,
4903
                                         TREE_INT_CST_LOW (number) + 2);
4904
                    }
4905
                }
4906
              filtered_attributes = chainon (filtered_attributes,
4907
                                             new_attribute);
4908
            }
4909
          else if (is_attribute_p ("nonnull", name))
4910
            {
4911
              /* We need to fixup all the argument indexes by adding 2
4912
                 for the two hidden arguments of an Objective-C method
4913
                 invocation, similat to what we do above for the
4914
                 "format" attribute.  */
4915
              /* FIXME: This works great in terms of implementing the
4916
                 functionality, but the warnings that are produced by
4917
                 nonnull do mention the argument index (while the
4918
                 format ones don't).  For example, you could get
4919
                 "warning: null argument where non-null required
4920
                 (argument 3)".  Now in that message, "argument 3"
4921
                 includes the 2 hidden arguments; it would be much
4922
                 more friendly to call it "argument 1", as that would
4923
                 be consistent with __attribute__ ((nonnnull (1))).
4924
                 To do this, we'd need to have the C family code that
4925
                 checks the arguments know about adding/removing 2 to
4926
                 the argument index ... or alternatively we could
4927
                 maybe store the "printable" argument index in
4928
                 addition to the actual argument index ?  Some
4929
                 refactoring is needed to do this elegantly.  */
4930
              tree new_attribute = copy_node (attribute);
4931
              tree argument = TREE_VALUE (attribute);
4932
              while (argument != NULL_TREE)
4933
                {
4934
                  /* Get the value of the argument and add 2.  */
4935
                  tree number = TREE_VALUE (argument);
4936
                  if (number
4937
                      && TREE_CODE (number) == INTEGER_CST
4938
                      && TREE_INT_CST_HIGH (number) == 0
4939
                      && TREE_INT_CST_LOW (number) != 0)
4940
                    {
4941
                      TREE_VALUE (argument)
4942
                        = build_int_cst (integer_type_node,
4943
                                         TREE_INT_CST_LOW (number) + 2);
4944
                    }
4945
                  argument = TREE_CHAIN (argument);
4946
                }
4947
 
4948
              filtered_attributes = chainon (filtered_attributes,
4949
                                             new_attribute);
4950
            }
4951
          else
4952
            warning (OPT_Wattributes, "%qE attribute directive ignored", name);
4953
        }
4954
    }
4955
 
4956
  if (filtered_attributes)
4957
    {
4958
      /* This hackery changes the TREE_TYPE of the ObjC method
4959
         declaration to be a function type, so that decl_attributes
4960
         will treat the ObjC method as if it was a function.  Some
4961
         attributes (sentinel, format) will be applied to the function
4962
         type, changing it in place; so after calling decl_attributes,
4963
         we extract the function type attributes and store them in
4964
         METHOD_TYPE_ATTRIBUTES.  Some other attributes (noreturn,
4965
         deprecated) are applied directly to the method declaration
4966
         (by setting TREE_DEPRECATED and TREE_THIS_VOLATILE) so there
4967
         is nothing to do.  */
4968
      tree saved_type = TREE_TYPE (*node);
4969
      TREE_TYPE (*node)
4970
        = build_function_type_for_method (TREE_VALUE (saved_type), *node,
4971
                                          METHOD_REF, 0);
4972
      decl_attributes (node, filtered_attributes, flags);
4973
      METHOD_TYPE_ATTRIBUTES (*node) = TYPE_ATTRIBUTES (TREE_TYPE (*node));
4974
      TREE_TYPE (*node) = saved_type;
4975
    }
4976
}
4977
 
4978
bool
4979
objc_method_decl (enum tree_code opcode)
4980
{
4981
  return opcode == INSTANCE_METHOD_DECL || opcode == CLASS_METHOD_DECL;
4982
}
4983
 
4984
/* Return a function type for METHOD with RETURN_TYPE.  CONTEXT is
4985
   either METHOD_DEF or METHOD_REF, indicating whether we are defining a
4986
   method or calling one.  SUPER_FLAG indicates whether this is a send
4987
   to super; this makes a difference for the NeXT calling sequence in
4988
   which the lookup and the method call are done together.  If METHOD is
4989
   NULL, user-defined arguments (i.e., beyond self and _cmd) shall be
4990
   represented as varargs.  */
4991
 
4992
tree
4993
build_function_type_for_method (tree return_type, tree method,
4994
                                int context, bool super_flag)
4995
{
4996
  VEC(tree,gc) *argtypes = make_tree_vector ();
4997
  tree t, ftype;
4998
  bool is_varargs = false;
4999
 
5000
  (*runtime.get_arg_type_list_base) (&argtypes, method, context, super_flag);
5001
 
5002
  /* No actual method prototype given; remaining args passed as varargs.  */
5003
  if (method == NULL_TREE)
5004
    {
5005
      is_varargs = true;
5006
      goto build_ftype;
5007
    }
5008
 
5009
  for (t = METHOD_SEL_ARGS (method); t; t = DECL_CHAIN (t))
5010
    {
5011
      tree arg_type = TREE_VALUE (TREE_TYPE (t));
5012
 
5013
      /* Decay argument types for the underlying C function as
5014
         appropriate.  */
5015
      arg_type = objc_decay_parm_type (arg_type);
5016
 
5017
      VEC_safe_push (tree, gc, argtypes, arg_type);
5018
    }
5019
 
5020
  if (METHOD_ADD_ARGS (method))
5021
    {
5022
      for (t = TREE_CHAIN (METHOD_ADD_ARGS (method));
5023
           t; t = TREE_CHAIN (t))
5024
        {
5025
          tree arg_type = TREE_TYPE (TREE_VALUE (t));
5026
 
5027
          arg_type = objc_decay_parm_type (arg_type);
5028
 
5029
          VEC_safe_push (tree, gc, argtypes, arg_type);
5030
        }
5031
 
5032
      if (METHOD_ADD_ARGS_ELLIPSIS_P (method))
5033
        is_varargs = true;
5034
    }
5035
 
5036
 build_ftype:
5037
  if (is_varargs)
5038
    ftype = build_varargs_function_type_vec (return_type, argtypes);
5039
  else
5040
    ftype = build_function_type_vec (return_type, argtypes);
5041
 
5042
  release_tree_vector (argtypes);
5043
  return ftype;
5044
}
5045
 
5046
/* The 'method' argument is a tree; this tree could either be a single
5047
   method, which is returned, or could be a TREE_VEC containing a list
5048
   of methods.  In that case, the first one is returned, and warnings
5049
   are issued as appropriate.  */
5050
static tree
5051
check_duplicates (tree method, int methods, int is_class)
5052
{
5053
  tree first_method;
5054
  size_t i;
5055
 
5056
  if (method == NULL_TREE)
5057
    return NULL_TREE;
5058
 
5059
  if (TREE_CODE (method) != TREE_VEC)
5060
    return method;
5061
 
5062
  /* We have two or more methods with the same name but different
5063
     types.  */
5064
  first_method = TREE_VEC_ELT (method, 0);
5065
 
5066
  /* But just how different are those types?  If
5067
     -Wno-strict-selector-match is specified, we shall not complain if
5068
     the differences are solely among types with identical size and
5069
     alignment.  */
5070
  if (!warn_strict_selector_match)
5071
    {
5072
      for (i = 0; i < (size_t) TREE_VEC_LENGTH (method); i++)
5073
        if (!comp_proto_with_proto (first_method, TREE_VEC_ELT (method, i), 0))
5074
          goto issue_warning;
5075
 
5076
      return first_method;
5077
    }
5078
 
5079
 issue_warning:
5080
  if (methods)
5081
    {
5082
      bool type = TREE_CODE (first_method) == INSTANCE_METHOD_DECL;
5083
 
5084
      warning_at (input_location, 0,
5085
                  "multiple methods named %<%c%E%> found",
5086
                  (is_class ? '+' : '-'),
5087
                  METHOD_SEL_NAME (first_method));
5088
      inform (DECL_SOURCE_LOCATION (first_method), "using %<%c%s%>",
5089
              (type ? '-' : '+'),
5090
              identifier_to_locale (gen_method_decl (first_method)));
5091
    }
5092
  else
5093
    {
5094
      bool type = TREE_CODE (first_method) == INSTANCE_METHOD_DECL;
5095
 
5096
      warning_at (input_location, 0,
5097
                  "multiple selectors named %<%c%E%> found",
5098
                  (is_class ? '+' : '-'),
5099
                  METHOD_SEL_NAME (first_method));
5100
      inform (DECL_SOURCE_LOCATION (first_method), "found %<%c%s%>",
5101
              (type ? '-' : '+'),
5102
              identifier_to_locale (gen_method_decl (first_method)));
5103
    }
5104
 
5105
  for (i = 0; i < (size_t) TREE_VEC_LENGTH (method); i++)
5106
    {
5107
      bool type = TREE_CODE (TREE_VEC_ELT (method, i)) == INSTANCE_METHOD_DECL;
5108
 
5109
      inform (DECL_SOURCE_LOCATION (TREE_VEC_ELT (method, i)), "also found %<%c%s%>",
5110
              (type ? '-' : '+'),
5111
              identifier_to_locale (gen_method_decl (TREE_VEC_ELT (method, i))));
5112
    }
5113
 
5114
  return first_method;
5115
}
5116
 
5117
/* If RECEIVER is a class reference, return the identifier node for
5118
   the referenced class.  RECEIVER is created by objc_get_class_reference,
5119
   so we check the exact form created depending on which runtimes are
5120
   used.  */
5121
 
5122
static tree
5123
receiver_is_class_object (tree receiver, int self, int super)
5124
{
5125
  tree exp, arg;
5126
 
5127
  /* The receiver is 'self' or 'super' in the context of a class method.  */
5128
  if (objc_method_context
5129
      && TREE_CODE (objc_method_context) == CLASS_METHOD_DECL
5130
      && (self || super))
5131
    return (super
5132
            ? CLASS_SUPER_NAME (implementation_template)
5133
            : CLASS_NAME (implementation_template));
5134
 
5135
  /* The runtime might encapsulate things its own way.  */
5136
  exp = (*runtime.receiver_is_class_object) (receiver);
5137
  if (exp)
5138
    return exp;
5139
 
5140
  /* The receiver is a function call that returns an id.  Check if
5141
     it is a call to objc_getClass, if so, pick up the class name.
5142
 
5143
     This is required by the GNU runtime, which compiles
5144
 
5145
       [NSObject alloc]
5146
 
5147
     into
5148
 
5149
       [objc_get_class ("NSObject") alloc];
5150
 
5151
     and then, to check that the receiver responds to the +alloc
5152
     method, needs to be able to determine that the objc_get_class()
5153
     call returns the NSObject class and not just a generic Class
5154
     pointer.
5155
 
5156
     But, traditionally this is enabled for all runtimes, not just the
5157
     GNU one, which means that the compiler is smarter than you'd
5158
     expect when dealing with objc_getClass().  For example, with the
5159
     Apple runtime, in the code
5160
 
5161
       [objc_getClass ("NSObject")  alloc];
5162
 
5163
     the compiler will recognize the objc_getClass() call as special
5164
     (due to the code below) and so will know that +alloc is called on
5165
     the 'NSObject' class, and can perform the corresponding checks.
5166
 
5167
     Programmers can disable this behaviour by casting the results of
5168
     objc_getClass() to 'Class' (this may seem weird because
5169
     objc_getClass() is already declared to return 'Class', but the
5170
     compiler treats it as a special function).  This may be useful if
5171
     the class is never declared, and the compiler would complain
5172
     about a missing @interface for it.  Then, you can do
5173
 
5174
       [(Class)objc_getClass ("MyClassNeverDeclared")  alloc];
5175
 
5176
     to silence the warnings.  */
5177
  if (TREE_CODE (receiver) == CALL_EXPR
5178
      && (exp = CALL_EXPR_FN (receiver))
5179
      && TREE_CODE (exp) == ADDR_EXPR
5180
      && (exp = TREE_OPERAND (exp, 0))
5181
      && TREE_CODE (exp) == FUNCTION_DECL
5182
      /* For some reason, we sometimes wind up with multiple FUNCTION_DECL
5183
         prototypes for objc_get_class().  Thankfully, they seem to share the
5184
         same function type.  */
5185
      && TREE_TYPE (exp) == TREE_TYPE (objc_get_class_decl)
5186
      && !strcmp (IDENTIFIER_POINTER (DECL_NAME (exp)), runtime.tag_getclass)
5187
      /* We have a call to objc_get_class/objc_getClass!  */
5188
      && (arg = CALL_EXPR_ARG (receiver, 0)))
5189
    {
5190
      STRIP_NOPS (arg);
5191
      if (TREE_CODE (arg) == ADDR_EXPR
5192
          && (arg = TREE_OPERAND (arg, 0))
5193
          && TREE_CODE (arg) == STRING_CST)
5194
        /* Finally, we have the class name.  */
5195
        return get_identifier (TREE_STRING_POINTER (arg));
5196
    }
5197
  return 0;
5198
}
5199
 
5200
/* If we are currently building a message expr, this holds
5201
   the identifier of the selector of the message.  This is
5202
   used when printing warnings about argument mismatches.  */
5203
 
5204
static tree current_objc_message_selector = 0;
5205
 
5206
tree
5207
objc_message_selector (void)
5208
{
5209
  return current_objc_message_selector;
5210
}
5211
 
5212
/* Construct an expression for sending a message.
5213
   MESS has the object to send to in TREE_PURPOSE
5214
   and the argument list (including selector) in TREE_VALUE.
5215
 
5216
   (*(<abstract_decl>(*)())_msg)(receiver, selTransTbl[n], ...);
5217
   (*(<abstract_decl>(*)())_msgSuper)(receiver, selTransTbl[n], ...);  */
5218
 
5219
tree
5220
objc_build_message_expr (tree receiver, tree message_args)
5221
{
5222
  tree sel_name;
5223
#ifdef OBJCPLUS
5224
  tree args = TREE_PURPOSE (message_args);
5225
#else
5226
  tree args = message_args;
5227
#endif
5228
  tree method_params = NULL_TREE;
5229
 
5230
  if (TREE_CODE (receiver) == ERROR_MARK || TREE_CODE (args) == ERROR_MARK)
5231
    return error_mark_node;
5232
 
5233
  /* Obtain the full selector name.  */
5234
  switch (TREE_CODE (args))
5235
    {
5236
    case IDENTIFIER_NODE:
5237
      /* A unary selector.  */
5238
      sel_name = args;
5239
      break;
5240
    case TREE_LIST:
5241
      sel_name = build_keyword_selector (args);
5242
      break;
5243
    default:
5244
      gcc_unreachable ();
5245
    }
5246
 
5247
  /* Build the parameter list to give to the method.  */
5248
  if (TREE_CODE (args) == TREE_LIST)
5249
#ifdef OBJCPLUS
5250
    method_params = chainon (args, TREE_VALUE (message_args));
5251
#else
5252
    {
5253
      tree chain = args, prev = NULL_TREE;
5254
 
5255
      /* We have a keyword selector--check for comma expressions.  */
5256
      while (chain)
5257
        {
5258
          tree element = TREE_VALUE (chain);
5259
 
5260
          /* We have a comma expression, must collapse...  */
5261
          if (TREE_CODE (element) == TREE_LIST)
5262
            {
5263
              if (prev)
5264
                TREE_CHAIN (prev) = element;
5265
              else
5266
                args = element;
5267
            }
5268
          prev = chain;
5269
          chain = TREE_CHAIN (chain);
5270
        }
5271
      method_params = args;
5272
    }
5273
#endif
5274
 
5275
#ifdef OBJCPLUS
5276
  if (processing_template_decl)
5277
    /* Must wait until template instantiation time.  */
5278
    return build_min_nt (MESSAGE_SEND_EXPR, receiver, sel_name,
5279
                         method_params);
5280
#endif
5281
 
5282
  return objc_finish_message_expr (receiver, sel_name, method_params, NULL);
5283
}
5284
 
5285
/* Look up method SEL_NAME that would be suitable for receiver
5286
   of type 'id' (if IS_CLASS is zero) or 'Class' (if IS_CLASS is
5287
   nonzero), and report on any duplicates.  */
5288
 
5289
static tree
5290
lookup_method_in_hash_lists (tree sel_name, int is_class)
5291
{
5292
  tree method_prototype = OBJC_MAP_NOT_FOUND;
5293
 
5294
  if (!is_class)
5295
    method_prototype = objc_map_get (instance_method_map, sel_name);
5296
 
5297
  if (method_prototype == OBJC_MAP_NOT_FOUND)
5298
    {
5299
      method_prototype = objc_map_get (class_method_map, sel_name);
5300
      is_class = 1;
5301
 
5302
      if (method_prototype == OBJC_MAP_NOT_FOUND)
5303
        return NULL_TREE;
5304
    }
5305
 
5306
  return check_duplicates (method_prototype, 1, is_class);
5307
}
5308
 
5309
/* The 'objc_finish_message_expr' routine is called from within
5310
   'objc_build_message_expr' for non-template functions.  In the case of
5311
   C++ template functions, it is called from 'build_expr_from_tree'
5312
   (in decl2.c) after RECEIVER and METHOD_PARAMS have been expanded.
5313
 
5314
   If the DEPRECATED_METHOD_PROTOTYPE argument is NULL, then we warn
5315
   if the method being used is deprecated.  If it is not NULL, instead
5316
   of deprecating, we set *DEPRECATED_METHOD_PROTOTYPE to the method
5317
   prototype that was used and is deprecated.  This is useful for
5318
   getter calls that are always generated when compiling dot-syntax
5319
   expressions, even if they may not be used.  In that case, we don't
5320
   want the warning immediately; we produce it (if needed) at gimplify
5321
   stage when we are sure that the deprecated getter is being
5322
   used.  */
5323
tree
5324
objc_finish_message_expr (tree receiver, tree sel_name, tree method_params,
5325
                          tree *deprecated_method_prototype)
5326
{
5327
  tree method_prototype = NULL_TREE, rprotos = NULL_TREE, rtype;
5328
  tree retval, class_tree;
5329
  int self, super, have_cast;
5330
 
5331
  /* We have used the receiver, so mark it as read.  */
5332
  mark_exp_read (receiver);
5333
 
5334
  /* Extract the receiver of the message, as well as its type
5335
     (where the latter may take the form of a cast or be inferred
5336
     from the implementation context).  */
5337
  rtype = receiver;
5338
  while (TREE_CODE (rtype) == COMPOUND_EXPR
5339
         || TREE_CODE (rtype) == MODIFY_EXPR
5340
         || CONVERT_EXPR_P (rtype)
5341
         || TREE_CODE (rtype) == COMPONENT_REF)
5342
    rtype = TREE_OPERAND (rtype, 0);
5343
 
5344
  /* self is 1 if this is a message to self, 0 otherwise  */
5345
  self = (rtype == self_decl);
5346
 
5347
  /* super is 1 if this is a message to super, 0 otherwise.  */
5348
  super = (rtype == UOBJC_SUPER_decl);
5349
 
5350
  /* rtype is the type of the receiver.  */
5351
  rtype = TREE_TYPE (receiver);
5352
 
5353
  /* have_cast is 1 if the receiver is casted.  */
5354
  have_cast = (TREE_CODE (receiver) == NOP_EXPR
5355
               || (TREE_CODE (receiver) == COMPOUND_EXPR
5356
                   && !IS_SUPER (rtype)));
5357
 
5358
  /* If we are calling [super dealloc], reset our warning flag.  */
5359
  if (super && !strcmp ("dealloc", IDENTIFIER_POINTER (sel_name)))
5360
    should_call_super_dealloc = 0;
5361
 
5362
  /* If the receiver is a class object, retrieve the corresponding
5363
     @interface, if one exists.  class_tree is the class name
5364
     identifier, or NULL_TREE if this is not a class method or the
5365
     class name could not be determined (as in the case "Class c; [c
5366
     method];").  */
5367
  class_tree = receiver_is_class_object (receiver, self, super);
5368
 
5369
  /* Now determine the receiver type (if an explicit cast has not been
5370
     provided).  */
5371
  if (!have_cast)
5372
    {
5373
      if (class_tree)
5374
        {
5375
          /* We are here when we have no cast, and we have a class
5376
             name.  So, this is a plain method to a class object, as
5377
             in [NSObject alloc].  Find the interface corresponding to
5378
             the class name.  */
5379
          rtype = lookup_interface (class_tree);
5380
 
5381
          if (rtype == NULL_TREE)
5382
            {
5383
              /* If 'rtype' is NULL_TREE at this point it means that
5384
                 we have seen no @interface corresponding to that
5385
                 class name, only a @class declaration (alternatively,
5386
                 this was a call such as [objc_getClass("SomeClass")
5387
                 alloc], where we've never seen the @interface of
5388
                 SomeClass).  So, we have a class name (class_tree)
5389
                 but no actual details of the class methods.  We won't
5390
                 be able to check that the class responds to the
5391
                 method, and we will have to guess the method
5392
                 prototype.  Emit a warning, then keep going (this
5393
                 will use any method with a matching name, as if the
5394
                 receiver was of type 'Class').  */
5395
              warning (0, "@interface of class %qE not found", class_tree);
5396
            }
5397
        }
5398
      /* Handle `self' and `super'.  */
5399
      else if (super)
5400
        {
5401
          if (!CLASS_SUPER_NAME (implementation_template))
5402
            {
5403
              error ("no super class declared in @interface for %qE",
5404
                     CLASS_NAME (implementation_template));
5405
              return error_mark_node;
5406
            }
5407
          rtype = lookup_interface (CLASS_SUPER_NAME (implementation_template));
5408
        }
5409
      else if (self)
5410
        rtype = lookup_interface (CLASS_NAME (implementation_template));
5411
    }
5412
 
5413
  if (objc_is_id (rtype))
5414
    {
5415
      /* The receiver is of type 'id' or 'Class' (with or without some
5416
         protocols attached to it).  */
5417
 
5418
      /* We set class_tree to the identifier for 'Class' if this is a
5419
         class method, and to NULL_TREE if not.  */
5420
      class_tree = (IS_CLASS (rtype) ? objc_class_name : NULL_TREE);
5421
 
5422
      /* 'rprotos' is the list of protocols that the receiver
5423
         supports.  */
5424
      rprotos = (TYPE_HAS_OBJC_INFO (TREE_TYPE (rtype))
5425
                 ? TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (rtype))
5426
                 : NULL_TREE);
5427
 
5428
      /* We have no information on the type, and we set it to
5429
         NULL_TREE.  */
5430
      rtype = NULL_TREE;
5431
 
5432
      /* If there are any protocols, check that the method we are
5433
         calling appears in the protocol list.  If there are no
5434
         protocols, this is a message to 'id' or 'Class' and we accept
5435
         any method that exists.  */
5436
      if (rprotos)
5437
        {
5438
          /* If messaging 'id <Protos>' or 'Class <Proto>', first
5439
             search in protocols themselves for the method
5440
             prototype.  */
5441
          method_prototype
5442
            = lookup_method_in_protocol_list (rprotos, sel_name,
5443
                                              class_tree != NULL_TREE);
5444
 
5445
          /* If messaging 'Class <Proto>' but did not find a class
5446
             method prototype, search for an instance method instead,
5447
             and warn about having done so.  */
5448
          if (!method_prototype && !rtype && class_tree != NULL_TREE)
5449
            {
5450
              method_prototype
5451
                = lookup_method_in_protocol_list (rprotos, sel_name, 0);
5452
 
5453
              if (method_prototype)
5454
                warning (0, "found %<-%E%> instead of %<+%E%> in protocol(s)",
5455
                         sel_name, sel_name);
5456
            }
5457
        }
5458
    }
5459
  else if (rtype)
5460
    {
5461
      /* We have a receiver type which is more specific than 'id' or
5462
         'Class'.  */
5463
      tree orig_rtype = rtype;
5464
 
5465
      if (TREE_CODE (rtype) == POINTER_TYPE)
5466
        rtype = TREE_TYPE (rtype);
5467
      /* Traverse typedef aliases */
5468
      while (TREE_CODE (rtype) == RECORD_TYPE && OBJC_TYPE_NAME (rtype)
5469
             && TREE_CODE (OBJC_TYPE_NAME (rtype)) == TYPE_DECL
5470
             && DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (rtype)))
5471
        rtype = DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (rtype));
5472
      if (TYPED_OBJECT (rtype))
5473
        {
5474
          rprotos = TYPE_OBJC_PROTOCOL_LIST (rtype);
5475
          rtype = TYPE_OBJC_INTERFACE (rtype);
5476
        }
5477
      if (!rtype || TREE_CODE (rtype) == IDENTIFIER_NODE)
5478
        {
5479
          /* If we could not find an @interface declaration, we must
5480
             have only seen a @class declaration; so, we cannot say
5481
             anything more intelligent about which methods the
5482
             receiver will understand.  Note that this only happens
5483
             for instance methods; for class methods to a class where
5484
             we have only seen a @class declaration,
5485
             lookup_interface() above would have set rtype to
5486
             NULL_TREE.  */
5487
          if (rprotos)
5488
            {
5489
              /* We could not find an @interface declaration, yet, if
5490
                 there are protocols attached to the type, we can
5491
                 still look up the method in the protocols.  Ie, we
5492
                 are in the following case:
5493
 
5494
                 @class MyClass;
5495
                 MyClass<MyProtocol> *x;
5496
                 [x method];
5497
 
5498
                 If 'MyProtocol' has the method 'method', we can check
5499
                 and retrieve the method prototype.  */
5500
              method_prototype
5501
                = lookup_method_in_protocol_list (rprotos, sel_name, 0);
5502
 
5503
              /* At this point, if we have found the method_prototype,
5504
                 we are quite happy.  The details of the class are
5505
                 irrelevant.  If we haven't found it, a warning will
5506
                 have been produced that the method could not be found
5507
                 in the protocol, and we won't produce further
5508
                 warnings (please note that this means that "@class
5509
                 MyClass; MyClass <MyProtocol> *x;" is exactly
5510
                 equivalent to "id <MyProtocol> x", which isn't too
5511
                 satisfactory but it's not easy to see how to do
5512
                 better).  */
5513
            }
5514
          else
5515
            {
5516
              if (rtype)
5517
                {
5518
                  /* We could not find an @interface declaration, and
5519
                     there are no protocols attached to the receiver,
5520
                     so we can't complete the check that the receiver
5521
                     responds to the method, and we can't retrieve the
5522
                     method prototype.  But, because the receiver has
5523
                     a well-specified class, the programmer did want
5524
                     this check to be performed.  Emit a warning, then
5525
                     keep going as if it was an 'id'.  To remove the
5526
                     warning, either include an @interface for the
5527
                     class, or cast the receiver to 'id'.  Note that
5528
                     rtype is an IDENTIFIER_NODE at this point.  */
5529
                  warning (0, "@interface of class %qE not found", rtype);
5530
                }
5531
            }
5532
 
5533
          rtype = NULL_TREE;
5534
        }
5535
      else if (TREE_CODE (rtype) == CLASS_INTERFACE_TYPE
5536
          || TREE_CODE (rtype) == CLASS_IMPLEMENTATION_TYPE)
5537
        {
5538
          /* We have a valid ObjC class name with an associated
5539
             @interface.  Look up the method name in the published
5540
             @interface for the class (and its superclasses).  */
5541
          method_prototype
5542
            = lookup_method_static (rtype, sel_name, class_tree != NULL_TREE);
5543
 
5544
          /* If the method was not found in the @interface, it may still
5545
             exist locally as part of the @implementation.  */
5546
          if (!method_prototype && objc_implementation_context
5547
             && CLASS_NAME (objc_implementation_context)
5548
                == OBJC_TYPE_NAME (rtype))
5549
            method_prototype
5550
              = lookup_method
5551
                ((class_tree
5552
                  ? CLASS_CLS_METHODS (objc_implementation_context)
5553
                  : CLASS_NST_METHODS (objc_implementation_context)),
5554
                  sel_name);
5555
 
5556
          /* If we haven't found a candidate method by now, try looking for
5557
             it in the protocol list.  */
5558
          if (!method_prototype && rprotos)
5559
            method_prototype
5560
              = lookup_method_in_protocol_list (rprotos, sel_name,
5561
                                                class_tree != NULL_TREE);
5562
        }
5563
      else
5564
        {
5565
          /* We have a type, but it's not an Objective-C type (!).  */
5566
          warning (0, "invalid receiver type %qs",
5567
                   identifier_to_locale (gen_type_name (orig_rtype)));
5568
          /* After issuing the "invalid receiver" warning, perform method
5569
             lookup as if we were messaging 'id'.  */
5570
          rtype = rprotos = NULL_TREE;
5571
        }
5572
    }
5573
  /* Note that rtype could also be NULL_TREE.  This happens if we are
5574
     messaging a class by name, but the class was only
5575
     forward-declared using @class.  */
5576
 
5577
  /* For 'id' or 'Class' receivers, search in the global hash table as
5578
     a last resort.  For all receivers, warn if protocol searches have
5579
     failed.  */
5580
  if (!method_prototype)
5581
    {
5582
      if (rprotos)
5583
        warning (0, "%<%c%E%> not found in protocol(s)",
5584
                 (class_tree ? '+' : '-'),
5585
                 sel_name);
5586
 
5587
      if (!rtype)
5588
        method_prototype
5589
          = lookup_method_in_hash_lists (sel_name, class_tree != NULL_TREE);
5590
    }
5591
 
5592
  if (!method_prototype)
5593
    {
5594
      static bool warn_missing_methods = false;
5595
 
5596
      if (rtype)
5597
        warning (0, "%qE may not respond to %<%c%E%>",
5598
                 OBJC_TYPE_NAME (rtype),
5599
                 (class_tree ? '+' : '-'),
5600
                 sel_name);
5601
      /* If we are messaging an 'id' or 'Class' object and made it here,
5602
         then we have failed to find _any_ instance or class method,
5603
         respectively.  */
5604
      else
5605
        warning (0, "no %<%c%E%> method found",
5606
                 (class_tree ? '+' : '-'),
5607
                 sel_name);
5608
 
5609
      if (!warn_missing_methods)
5610
        {
5611
          warning_at (input_location,
5612
                      0, "(Messages without a matching method signature");
5613
          warning_at (input_location,
5614
                      0, "will be assumed to return %<id%> and accept");
5615
          warning_at (input_location,
5616
                      0, "%<...%> as arguments.)");
5617
          warn_missing_methods = true;
5618
        }
5619
    }
5620
  else
5621
    {
5622
      /* Warn if the method is deprecated, but not if the receiver is
5623
         a generic 'id'.  'id' is used to cast an object to a generic
5624
         object of an unspecified class; in that case, we'll use
5625
         whatever method prototype we can find to get the method
5626
         argument and return types, but it is not appropriate to
5627
         produce deprecation warnings since we don't know the class
5628
         that the object will be of at runtime.  The @interface(s) for
5629
         that class may not even be available to the compiler right
5630
         now, and it is perfectly possible that the method is marked
5631
         as non-deprecated in such @interface(s).
5632
 
5633
         In practice this makes sense since casting an object to 'id'
5634
         is often used precisely to turn off warnings associated with
5635
         the object being of a particular class.  */
5636
      if (TREE_DEPRECATED (method_prototype) && rtype != NULL_TREE)
5637
        {
5638
          if (deprecated_method_prototype)
5639
            *deprecated_method_prototype = method_prototype;
5640
          else
5641
            warn_deprecated_use (method_prototype, NULL_TREE);
5642
        }
5643
    }
5644
 
5645
  /* Save the selector name for printing error messages.  */
5646
  current_objc_message_selector = sel_name;
5647
 
5648
  /* Build the method call.
5649
     TODO: Get the location from somewhere that will work for delayed
5650
           expansion.  */
5651
 
5652
  retval = (*runtime.build_objc_method_call) (input_location, method_prototype,
5653
                                              receiver, rtype, sel_name,
5654
                                              method_params, super);
5655
 
5656
  current_objc_message_selector = 0;
5657
 
5658
  return retval;
5659
}
5660
 
5661
 
5662
/* This routine creates a static variable used to implement @protocol(MyProtocol)
5663
   expression. This variable will be initialized to global protocol_t meta-data
5664
   pointer. */
5665
 
5666
/* This function is called by the parser when (and only when) a
5667
   @protocol() expression is found, in order to compile it.  */
5668
tree
5669
objc_build_protocol_expr (tree protoname)
5670
{
5671
  tree p = lookup_protocol (protoname, /* warn if deprecated */ true,
5672
                            /* definition_required */ false);
5673
 
5674
  if (!p)
5675
    {
5676
      error ("cannot find protocol declaration for %qE", protoname);
5677
      return error_mark_node;
5678
    }
5679
 
5680
  return (*runtime.get_protocol_reference) (input_location, p);
5681
}
5682
 
5683
/* This function is called by the parser when a @selector() expression
5684
   is found, in order to compile it.  It is only called by the parser
5685
   and only to compile a @selector().  LOC is the location of the
5686
   @selector.  */
5687
tree
5688
objc_build_selector_expr (location_t loc, tree selnamelist)
5689
{
5690
  tree selname;
5691
 
5692
  /* Obtain the full selector name.  */
5693
  switch (TREE_CODE (selnamelist))
5694
    {
5695
    case IDENTIFIER_NODE:
5696
      /* A unary selector.  */
5697
      selname = selnamelist;
5698
      break;
5699
    case TREE_LIST:
5700
      selname = build_keyword_selector (selnamelist);
5701
      break;
5702
    default:
5703
      gcc_unreachable ();
5704
    }
5705
 
5706
  /* If we are required to check @selector() expressions as they
5707
     are found, check that the selector has been declared.  */
5708
  if (warn_undeclared_selector)
5709
    {
5710
      /* Look the selector up in the list of all known class and
5711
         instance methods (up to this line) to check that the selector
5712
         exists.  */
5713
      tree method;
5714
 
5715
      /* First try with instance methods.  */
5716
      method = objc_map_get (instance_method_map, selname);
5717
 
5718
      /* If not found, try with class methods.  */
5719
      if (method == OBJC_MAP_NOT_FOUND)
5720
        {
5721
          method = objc_map_get (class_method_map, selname);
5722
 
5723
          /* If still not found, print out a warning.  */
5724
          if (method == OBJC_MAP_NOT_FOUND)
5725
            warning (0, "undeclared selector %qE", selname);
5726
        }
5727
    }
5728
 
5729
  /* The runtimes do this differently, most particularly, GNU has typed
5730
     selectors, whilst NeXT does not.  */
5731
  return (*runtime.build_selector_reference) (loc, selname, NULL_TREE);
5732
}
5733
 
5734
static tree
5735
build_ivar_reference (tree id)
5736
{
5737
  tree base;
5738
  if (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL)
5739
    {
5740
      /* Historically, a class method that produced objects (factory
5741
         method) would assign `self' to the instance that it
5742
         allocated.  This would effectively turn the class method into
5743
         an instance method.  Following this assignment, the instance
5744
         variables could be accessed.  That practice, while safe,
5745
         violates the simple rule that a class method should not refer
5746
         to an instance variable.  It's better to catch the cases
5747
         where this is done unknowingly than to support the above
5748
         paradigm.  */
5749
      warning (0, "instance variable %qE accessed in class method",
5750
               id);
5751
      self_decl = convert (objc_instance_type, self_decl); /* cast */
5752
    }
5753
 
5754
  base = build_indirect_ref (input_location, self_decl, RO_ARROW);
5755
  return (*runtime.build_ivar_reference) (input_location, base, id);
5756
}
5757
 
5758
static void
5759
hash_init (void)
5760
{
5761
  instance_method_map = objc_map_alloc_ggc (1000);
5762
  class_method_map = objc_map_alloc_ggc (1000);
5763
 
5764
  class_name_map = objc_map_alloc_ggc (200);
5765
  alias_name_map = objc_map_alloc_ggc (200);
5766
 
5767
  /* Initialize the hash table used to hold the constant string objects.  */
5768
  string_htab = htab_create_ggc (31, string_hash,
5769
                                   string_eq, NULL);
5770
}
5771
 
5772
/* Use the following to add a method to class_method_map or
5773
   instance_method_map.  It will add the method, keyed by the
5774
   METHOD_SEL_NAME.  If the method already exists, but with one or
5775
   more different prototypes, it will store a TREE_VEC in the map,
5776
   with the method prototypes in the vector.  */
5777
static void
5778
insert_method_into_method_map (bool class_method, tree method)
5779
{
5780
  tree method_name = METHOD_SEL_NAME (method);
5781
  tree existing_entry;
5782
  objc_map_t map;
5783
 
5784
  if (class_method)
5785
    map = class_method_map;
5786
  else
5787
    map = instance_method_map;
5788
 
5789
  /* Check if the method already exists in the map.  */
5790
  existing_entry = objc_map_get (map, method_name);
5791
 
5792
  /* If not, we simply add it to the map.  */
5793
  if (existing_entry == OBJC_MAP_NOT_FOUND)
5794
    objc_map_put (map, method_name, method);
5795
  else
5796
    {
5797
      tree new_entry;
5798
 
5799
      /* If an entry already exists, it's more complicated.  We'll
5800
         have to check whether the method prototype is the same or
5801
         not.  */
5802
      if (TREE_CODE (existing_entry) != TREE_VEC)
5803
        {
5804
          /* If the method prototypes are the same, there is nothing
5805
             to do.  */
5806
          if (comp_proto_with_proto (method, existing_entry, 1))
5807
            return;
5808
 
5809
          /* If not, create a vector to store both the method already
5810
             in the map, and the new one that we are adding.  */
5811
          new_entry = make_tree_vec (2);
5812
 
5813
          TREE_VEC_ELT (new_entry, 0) = existing_entry;
5814
          TREE_VEC_ELT (new_entry, 1) = method;
5815
        }
5816
      else
5817
        {
5818
          /* An entry already exists, and it's already a vector.  This
5819
             means that at least 2 different method prototypes were
5820
             already found, and we're considering registering yet
5821
             another one.  */
5822
          size_t i;
5823
 
5824
          /* Check all the existing prototypes.  If any matches the
5825
             one we need to add, there is nothing to do because it's
5826
             already there.  */
5827
          for (i = 0; i < (size_t) TREE_VEC_LENGTH (existing_entry); i++)
5828
            if (comp_proto_with_proto (method, TREE_VEC_ELT (existing_entry, i), 1))
5829
              return;
5830
 
5831
          /* Else, create a new, bigger vector and add the new method
5832
             at the end of it.  This is inefficient but extremely
5833
             rare; in any sane program most methods have a single
5834
             prototype, and very few, if any, will have more than
5835
             2!  */
5836
          new_entry = make_tree_vec (TREE_VEC_LENGTH (existing_entry) + 1);
5837
 
5838
          /* Copy the methods from the existing vector.  */
5839
          for (i = 0; i < (size_t) TREE_VEC_LENGTH (existing_entry); i++)
5840
            TREE_VEC_ELT (new_entry, i) = TREE_VEC_ELT (existing_entry, i);
5841
 
5842
          /* Add the new method at the end.  */
5843
          TREE_VEC_ELT (new_entry, i) = method;
5844
        }
5845
 
5846
      /* Store the new vector in the map.  */
5847
      objc_map_put (map, method_name, new_entry);
5848
    }
5849
}
5850
 
5851
 
5852
static tree
5853
lookup_method (tree mchain, tree method)
5854
{
5855
  tree key;
5856
 
5857
  if (TREE_CODE (method) == IDENTIFIER_NODE)
5858
    key = method;
5859
  else
5860
    key = METHOD_SEL_NAME (method);
5861
 
5862
  while (mchain)
5863
    {
5864
      if (METHOD_SEL_NAME (mchain) == key)
5865
        return mchain;
5866
 
5867
      mchain = DECL_CHAIN (mchain);
5868
    }
5869
  return NULL_TREE;
5870
}
5871
 
5872
/* Look up a class (if OBJC_LOOKUP_CLASS is set in FLAGS) or instance
5873
   method in INTERFACE, along with any categories and protocols
5874
   attached thereto.  If method is not found, and the
5875
   OBJC_LOOKUP_NO_SUPER is _not_ set in FLAGS, recursively examine the
5876
   INTERFACE's superclass.  If OBJC_LOOKUP_CLASS is set,
5877
   OBJC_LOOKUP_NO_SUPER is clear, and no suitable class method could
5878
   be found in INTERFACE or any of its superclasses, look for an
5879
   _instance_ method of the same name in the root class as a last
5880
   resort.  This behaviour can be turned off by using
5881
   OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS.
5882
 
5883
   If a suitable method cannot be found, return NULL_TREE.  */
5884
 
5885
static tree
5886
lookup_method_static (tree interface, tree ident, int flags)
5887
{
5888
  tree meth = NULL_TREE, root_inter = NULL_TREE;
5889
  tree inter = interface;
5890
  int is_class = (flags & OBJC_LOOKUP_CLASS);
5891
  int no_superclasses = (flags & OBJC_LOOKUP_NO_SUPER);
5892
  int no_instance_methods_of_root_class = (flags & OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS);
5893
 
5894
  while (inter)
5895
    {
5896
      tree chain = is_class ? CLASS_CLS_METHODS (inter) : CLASS_NST_METHODS (inter);
5897
      tree category = inter;
5898
 
5899
      /* First, look up the method in the class itself.  */
5900
      if ((meth = lookup_method (chain, ident)))
5901
        return meth;
5902
 
5903
      /* Failing that, look for the method in each category of the class.  */
5904
      while ((category = CLASS_CATEGORY_LIST (category)))
5905
        {
5906
          chain = is_class ? CLASS_CLS_METHODS (category) : CLASS_NST_METHODS (category);
5907
 
5908
          /* Check directly in each category.  */
5909
          if ((meth = lookup_method (chain, ident)))
5910
            return meth;
5911
 
5912
          /* Failing that, check in each category's protocols.  */
5913
          if (CLASS_PROTOCOL_LIST (category))
5914
            {
5915
              if ((meth = (lookup_method_in_protocol_list
5916
                           (CLASS_PROTOCOL_LIST (category), ident, is_class))))
5917
                return meth;
5918
            }
5919
        }
5920
 
5921
      /* If not found in categories, check in protocols of the main class.  */
5922
      if (CLASS_PROTOCOL_LIST (inter))
5923
        {
5924
          if ((meth = (lookup_method_in_protocol_list
5925
                       (CLASS_PROTOCOL_LIST (inter), ident, is_class))))
5926
            return meth;
5927
        }
5928
 
5929
      /* If we were instructed not to look in superclasses, don't.  */
5930
      if (no_superclasses)
5931
        return NULL_TREE;
5932
 
5933
      /* Failing that, climb up the inheritance hierarchy.  */
5934
      root_inter = inter;
5935
      inter = lookup_interface (CLASS_SUPER_NAME (inter));
5936
    }
5937
  while (inter);
5938
 
5939
  if (is_class && !no_instance_methods_of_root_class)
5940
    {
5941
      /* If no class (factory) method was found, check if an _instance_
5942
         method of the same name exists in the root class.  This is what
5943
         the Objective-C runtime will do.  */
5944
      return lookup_method_static (root_inter, ident, 0);
5945
    }
5946
  else
5947
    {
5948
      /* If an instance method was not found, return 0.  */
5949
      return NULL_TREE;
5950
    }
5951
}
5952
 
5953
static tree
5954
objc_add_method (tree klass, tree method, int is_class, bool is_optional)
5955
{
5956
  tree existing_method = NULL_TREE;
5957
 
5958
  /* The first thing we do is look up the method in the list of
5959
     methods already defined in the interface (or implementation).  */
5960
  if (is_class)
5961
    existing_method = lookup_method (CLASS_CLS_METHODS (klass), method);
5962
  else
5963
    existing_method = lookup_method (CLASS_NST_METHODS (klass), method);
5964
 
5965
  /* In the case of protocols, we have a second list of methods to
5966
     consider, the list of optional ones.  */
5967
  if (TREE_CODE (klass) == PROTOCOL_INTERFACE_TYPE)
5968
    {
5969
      /* @required methods are added to the protocol's normal list.
5970
         @optional methods are added to the protocol's OPTIONAL lists.
5971
         Note that adding the methods to the optional lists disables
5972
         checking that the methods are implemented by classes
5973
         implementing the protocol, since these checks only use the
5974
         CLASS_CLS_METHODS and CLASS_NST_METHODS.  */
5975
 
5976
      /* First of all, if the method to add is @optional, and we found
5977
         it already existing as @required, emit an error.  */
5978
      if (is_optional && existing_method)
5979
        {
5980
          error ("method %<%c%E%> declared %<@optional%> and %<@required%> at the same time",
5981
                 (is_class ? '+' : '-'),
5982
                 METHOD_SEL_NAME (existing_method));
5983
          inform (DECL_SOURCE_LOCATION (existing_method),
5984
                  "previous declaration of %<%c%E%> as %<@required%>",
5985
                  (is_class ? '+' : '-'),
5986
                  METHOD_SEL_NAME (existing_method));
5987
        }
5988
 
5989
      /* Now check the list of @optional methods if we didn't find the
5990
         method in the @required list.  */
5991
      if (!existing_method)
5992
        {
5993
          if (is_class)
5994
            existing_method = lookup_method (PROTOCOL_OPTIONAL_CLS_METHODS (klass), method);
5995
          else
5996
            existing_method = lookup_method (PROTOCOL_OPTIONAL_NST_METHODS (klass), method);
5997
 
5998
          if (!is_optional && existing_method)
5999
            {
6000
              error ("method %<%c%E%> declared %<@optional%> and %<@required%> at the same time",
6001
                     (is_class ? '+' : '-'),
6002
                     METHOD_SEL_NAME (existing_method));
6003
              inform (DECL_SOURCE_LOCATION (existing_method),
6004
                      "previous declaration of %<%c%E%> as %<@optional%>",
6005
                      (is_class ? '+' : '-'),
6006
                      METHOD_SEL_NAME (existing_method));
6007
            }
6008
        }
6009
    }
6010
 
6011
  /* If the method didn't exist already, add it.  */
6012
  if (!existing_method)
6013
    {
6014
      if (is_optional)
6015
        {
6016
          if (is_class)
6017
            {
6018
              /* Put the method on the list in reverse order.  */
6019
              TREE_CHAIN (method) = PROTOCOL_OPTIONAL_CLS_METHODS (klass);
6020
              PROTOCOL_OPTIONAL_CLS_METHODS (klass) = method;
6021
            }
6022
          else
6023
            {
6024
              TREE_CHAIN (method) = PROTOCOL_OPTIONAL_NST_METHODS (klass);
6025
              PROTOCOL_OPTIONAL_NST_METHODS (klass) = method;
6026
            }
6027
        }
6028
      else
6029
        {
6030
          if (is_class)
6031
            {
6032
              DECL_CHAIN (method) = CLASS_CLS_METHODS (klass);
6033
              CLASS_CLS_METHODS (klass) = method;
6034
            }
6035
          else
6036
            {
6037
              DECL_CHAIN (method) = CLASS_NST_METHODS (klass);
6038
              CLASS_NST_METHODS (klass) = method;
6039
            }
6040
        }
6041
    }
6042
  else
6043
    {
6044
      /* The method was already defined.  Check that the types match
6045
         for an @interface for a class or category, or for a
6046
         @protocol.  Give hard errors on methods with identical
6047
         selectors but differing argument and/or return types.  We do
6048
         not do this for @implementations, because C/C++ will do it
6049
         for us (i.e., there will be duplicate function definition
6050
         errors).  */
6051
      if ((TREE_CODE (klass) == CLASS_INTERFACE_TYPE
6052
           || TREE_CODE (klass) == CATEGORY_INTERFACE_TYPE
6053
           /* Starting with GCC 4.6, we emit the same error for
6054
              protocols too.  The situation is identical to
6055
              @interfaces as there is no possible meaningful reason
6056
              for defining the same method with different signatures
6057
              in the very same @protocol.  If that was allowed,
6058
              whenever the protocol is used (both at compile and run
6059
              time) there wouldn't be any meaningful way to decide
6060
              which of the two method signatures should be used.  */
6061
           || TREE_CODE (klass) == PROTOCOL_INTERFACE_TYPE)
6062
          && !comp_proto_with_proto (method, existing_method, 1))
6063
        {
6064
          error ("duplicate declaration of method %<%c%E%> with conflicting types",
6065
                 (is_class ? '+' : '-'),
6066
                 METHOD_SEL_NAME (existing_method));
6067
          inform (DECL_SOURCE_LOCATION (existing_method),
6068
                  "previous declaration of %<%c%E%>",
6069
                  (is_class ? '+' : '-'),
6070
                  METHOD_SEL_NAME (existing_method));
6071
        }
6072
    }
6073
 
6074
  if (is_class)
6075
    insert_method_into_method_map (true, method);
6076
  else
6077
    {
6078
      insert_method_into_method_map (false, method);
6079
 
6080
      /* Instance methods in root classes (and categories thereof)
6081
         may act as class methods as a last resort.  We also add
6082
         instance methods listed in @protocol declarations to
6083
         the class hash table, on the assumption that @protocols
6084
         may be adopted by root classes or categories.  */
6085
      if (TREE_CODE (klass) == CATEGORY_INTERFACE_TYPE
6086
          || TREE_CODE (klass) == CATEGORY_IMPLEMENTATION_TYPE)
6087
        klass = lookup_interface (CLASS_NAME (klass));
6088
 
6089
      if (TREE_CODE (klass) == PROTOCOL_INTERFACE_TYPE
6090
          || !CLASS_SUPER_NAME (klass))
6091
        insert_method_into_method_map (true, method);
6092
    }
6093
 
6094
  return method;
6095
}
6096
 
6097
static void
6098
add_category (tree klass, tree category)
6099
{
6100
  /* Put categories on list in reverse order.  */
6101
  tree cat = lookup_category (klass, CLASS_SUPER_NAME (category));
6102
 
6103
  if (cat)
6104
    {
6105
      warning (0, "duplicate interface declaration for category %<%E(%E)%>",
6106
               CLASS_NAME (klass),
6107
               CLASS_SUPER_NAME (category));
6108
    }
6109
  else
6110
    {
6111
      CLASS_CATEGORY_LIST (category) = CLASS_CATEGORY_LIST (klass);
6112
      CLASS_CATEGORY_LIST (klass) = category;
6113
    }
6114
}
6115
 
6116
#ifndef OBJCPLUS
6117
/* A flexible array member is a C99 extension where you can use
6118
   "type[]" at the end of a struct to mean a variable-length array.
6119
 
6120
   In Objective-C, instance variables are fundamentally members of a
6121
   struct, but the struct can always be extended by subclassing; hence
6122
   we need to detect and forbid all instance variables declared using
6123
   flexible array members.
6124
 
6125
   No check for this is needed in Objective-C++, since C++ does not
6126
   have flexible array members.  */
6127
 
6128
/* Determine whether TYPE is a structure with a flexible array member,
6129
   a union containing such a structure (possibly recursively) or an
6130
   array of such structures or unions.  These are all invalid as
6131
   instance variable.  */
6132
static bool
6133
flexible_array_type_p (tree type)
6134
{
6135
  tree x;
6136
  switch (TREE_CODE (type))
6137
    {
6138
    case RECORD_TYPE:
6139
      x = TYPE_FIELDS (type);
6140
      if (x == NULL_TREE)
6141
        return false;
6142
      while (DECL_CHAIN (x) != NULL_TREE)
6143
        x = DECL_CHAIN (x);
6144
      if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE
6145
          && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE
6146
          && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE
6147
          && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE)
6148
        return true;
6149
      return false;
6150
    case UNION_TYPE:
6151
      for (x = TYPE_FIELDS (type); x != NULL_TREE; x = DECL_CHAIN (x))
6152
        {
6153
          if (flexible_array_type_p (TREE_TYPE (x)))
6154
            return true;
6155
        }
6156
      return false;
6157
    /* Note that we also check for arrays of something that uses a flexible array member.  */
6158
    case ARRAY_TYPE:
6159
      if (flexible_array_type_p (TREE_TYPE (type)))
6160
        return true;
6161
      return false;
6162
    default:
6163
    return false;
6164
  }
6165
}
6166
#endif
6167
 
6168
/* Produce a printable version of an ivar name.  This is only used
6169
   inside add_instance_variable.  */
6170
static const char *
6171
printable_ivar_name (tree field_decl)
6172
{
6173
  if (DECL_NAME (field_decl))
6174
    return identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (field_decl)));
6175
  else
6176
    return _("<unnamed>");
6177
}
6178
 
6179
/* Called after parsing each instance variable declaration. Necessary to
6180
   preserve typedefs and implement public/private...
6181
 
6182
   VISIBILITY is 1 for public, 0 for protected, and 2 for private.  */
6183
 
6184
static tree
6185
add_instance_variable (tree klass, objc_ivar_visibility_kind visibility,
6186
                       tree field_decl)
6187
{
6188
  tree field_type = TREE_TYPE (field_decl);
6189
 
6190
#ifdef OBJCPLUS
6191
  if (TREE_CODE (field_type) == REFERENCE_TYPE)
6192
    {
6193
      error ("illegal reference type specified for instance variable %qs",
6194
             printable_ivar_name (field_decl));
6195
      /* Return class as is without adding this ivar.  */
6196
      return klass;
6197
    }
6198
#endif
6199
 
6200
  if (field_type == error_mark_node || !TYPE_SIZE (field_type)
6201
      || TYPE_SIZE (field_type) == error_mark_node)
6202
      /* 'type[0]' is allowed, but 'type[]' is not! */
6203
    {
6204
      error ("instance variable %qs has unknown size",
6205
             printable_ivar_name (field_decl));
6206
      /* Return class as is without adding this ivar.  */
6207
      return klass;
6208
    }
6209
 
6210
#ifndef OBJCPLUS
6211
  /* Also, in C reject a struct with a flexible array member.  Ie,
6212
 
6213
       struct A { int x; int[] y; };
6214
 
6215
       @interface X
6216
       {
6217
         struct A instance_variable;
6218
       }
6219
       @end
6220
 
6221
       is not valid because if the class is subclassed, we wouldn't be able
6222
       to calculate the offset of the next instance variable.  */
6223
  if (flexible_array_type_p (field_type))
6224
    {
6225
      error ("instance variable %qs uses flexible array member",
6226
             printable_ivar_name (field_decl));
6227
      /* Return class as is without adding this ivar.  */
6228
      return klass;
6229
    }
6230
#endif
6231
 
6232
#ifdef OBJCPLUS
6233
  /* Check if the ivar being added has a non-POD C++ type.   If so, we will
6234
     need to either (1) warn the user about it or (2) generate suitable
6235
     constructor/destructor call from '- .cxx_construct' or '- .cxx_destruct'
6236
     methods (if '-fobjc-call-cxx-cdtors' was specified).  */
6237
  if (MAYBE_CLASS_TYPE_P (field_type)
6238
      && (TYPE_NEEDS_CONSTRUCTING (field_type)
6239
          || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type)
6240
          || TYPE_POLYMORPHIC_P (field_type)))
6241
    {
6242
      tree type_name = OBJC_TYPE_NAME (field_type);
6243
 
6244
      if (flag_objc_call_cxx_cdtors)
6245
        {
6246
          /* Since the ObjC runtime will be calling the constructors and
6247
             destructors for us, the only thing we can't handle is the lack
6248
             of a default constructor.  */
6249
          if (TYPE_NEEDS_CONSTRUCTING (field_type)
6250
              && !TYPE_HAS_DEFAULT_CONSTRUCTOR (field_type))
6251
            {
6252
              warning (0, "type %qE has no default constructor to call",
6253
                       type_name);
6254
 
6255
              /* If we cannot call a constructor, we should also avoid
6256
                 calling the destructor, for symmetry.  */
6257
              if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type))
6258
                warning (0, "destructor for %qE shall not be run either",
6259
                         type_name);
6260
            }
6261
        }
6262
      else
6263
        {
6264
          static bool warn_cxx_ivars = false;
6265
 
6266
          if (TYPE_POLYMORPHIC_P (field_type))
6267
            {
6268
              /* Vtable pointers are Real Bad(tm), since Obj-C cannot
6269
                 initialize them.  */
6270
              error ("type %qE has virtual member functions", type_name);
6271
              error ("illegal aggregate type %qE specified "
6272
                     "for instance variable %qs",
6273
                     type_name, printable_ivar_name (field_decl));
6274
              /* Return class as is without adding this ivar.  */
6275
              return klass;
6276
            }
6277
 
6278
          /* User-defined constructors and destructors are not known to Obj-C
6279
             and hence will not be called.  This may or may not be a problem. */
6280
          if (TYPE_NEEDS_CONSTRUCTING (field_type))
6281
            warning (0, "type %qE has a user-defined constructor", type_name);
6282
          if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type))
6283
            warning (0, "type %qE has a user-defined destructor", type_name);
6284
 
6285
          if (!warn_cxx_ivars)
6286
            {
6287
              warning (0, "C++ constructors and destructors will not "
6288
                       "be invoked for Objective-C fields");
6289
              warn_cxx_ivars = true;
6290
            }
6291
        }
6292
    }
6293
#endif
6294
 
6295
  /* Overload the public attribute, it is not used for FIELD_DECLs.  */
6296
  switch (visibility)
6297
    {
6298
    case OBJC_IVAR_VIS_PROTECTED:
6299
      TREE_PUBLIC (field_decl) = 0;
6300
      TREE_PRIVATE (field_decl) = 0;
6301
      TREE_PROTECTED (field_decl) = 1;
6302
      break;
6303
 
6304
    case OBJC_IVAR_VIS_PACKAGE:
6305
    /* TODO: Implement the package variant.  */
6306
    case OBJC_IVAR_VIS_PUBLIC:
6307
      TREE_PUBLIC (field_decl) = 1;
6308
      TREE_PRIVATE (field_decl) = 0;
6309
      TREE_PROTECTED (field_decl) = 0;
6310
      break;
6311
 
6312
    case OBJC_IVAR_VIS_PRIVATE:
6313
      TREE_PUBLIC (field_decl) = 0;
6314
      TREE_PRIVATE (field_decl) = 1;
6315
      TREE_PROTECTED (field_decl) = 0;
6316
      break;
6317
 
6318
    }
6319
 
6320
  CLASS_RAW_IVARS (klass) = chainon (CLASS_RAW_IVARS (klass), field_decl);
6321
 
6322
  return klass;
6323
}
6324
 
6325
/* True if the ivar is private and we are not in its implementation.  */
6326
 
6327
static int
6328
is_private (tree decl)
6329
{
6330
  return (TREE_PRIVATE (decl)
6331
          && ! is_ivar (CLASS_IVARS (implementation_template),
6332
                        DECL_NAME (decl)));
6333
}
6334
 
6335
/* Searches all the instance variables of 'klass' and of its
6336
   superclasses for an instance variable whose name (identifier) is
6337
   'ivar_name_ident'.  Return the declaration (DECL) of the instance
6338
   variable, if found, or NULL_TREE, if not found.  */
6339
static inline tree
6340
ivar_of_class (tree klass, tree ivar_name_ident)
6341
{
6342
  /* First, look up the ivar in CLASS_RAW_IVARS.  */
6343
  tree decl_chain = CLASS_RAW_IVARS (klass);
6344
 
6345
  for ( ; decl_chain; decl_chain = DECL_CHAIN (decl_chain))
6346
    if (DECL_NAME (decl_chain) == ivar_name_ident)
6347
      return decl_chain;
6348
 
6349
  /* If not found, search up the class hierarchy.  */
6350
  while (CLASS_SUPER_NAME (klass))
6351
    {
6352
      klass = lookup_interface (CLASS_SUPER_NAME (klass));
6353
 
6354
      decl_chain = CLASS_RAW_IVARS (klass);
6355
 
6356
      for ( ; decl_chain; decl_chain = DECL_CHAIN (decl_chain))
6357
        if (DECL_NAME (decl_chain) == ivar_name_ident)
6358
          return decl_chain;
6359
    }
6360
 
6361
  return NULL_TREE;
6362
}
6363
 
6364
/* We have an instance variable reference;, check to see if it is public.  */
6365
 
6366
int
6367
objc_is_public (tree expr, tree identifier)
6368
{
6369
  tree basetype, decl;
6370
 
6371
#ifdef OBJCPLUS
6372
  if (processing_template_decl)
6373
    return 1;
6374
#endif
6375
 
6376
  if (TREE_TYPE (expr) == error_mark_node)
6377
    return 1;
6378
 
6379
  basetype = TYPE_MAIN_VARIANT (TREE_TYPE (expr));
6380
 
6381
  if (basetype && TREE_CODE (basetype) == RECORD_TYPE)
6382
    {
6383
      if (TYPE_HAS_OBJC_INFO (basetype) && TYPE_OBJC_INTERFACE (basetype))
6384
        {
6385
          tree klass = lookup_interface (OBJC_TYPE_NAME (basetype));
6386
 
6387
          if (!klass)
6388
            {
6389
              error ("cannot find interface declaration for %qE",
6390
                     OBJC_TYPE_NAME (basetype));
6391
              return 0;
6392
            }
6393
 
6394
          if ((decl = ivar_of_class (klass, identifier)))
6395
            {
6396
              if (TREE_PUBLIC (decl))
6397
                return 1;
6398
 
6399
              /* Important difference between the Stepstone translator:
6400
                 all instance variables should be public within the context
6401
                 of the implementation.  */
6402
              if (objc_implementation_context
6403
                 && ((TREE_CODE (objc_implementation_context)
6404
                      == CLASS_IMPLEMENTATION_TYPE)
6405
                     || (TREE_CODE (objc_implementation_context)
6406
                         == CATEGORY_IMPLEMENTATION_TYPE)))
6407
                {
6408
                  tree curtype = TYPE_MAIN_VARIANT
6409
                                 (CLASS_STATIC_TEMPLATE
6410
                                  (implementation_template));
6411
 
6412
                  if (basetype == curtype
6413
                      || DERIVED_FROM_P (basetype, curtype))
6414
                    {
6415
                      int priv = is_private (decl);
6416
 
6417
                      if (priv)
6418
                        error ("instance variable %qE is declared private",
6419
                               DECL_NAME (decl));
6420
 
6421
                      return !priv;
6422
                    }
6423
                }
6424
 
6425
              /* The 2.95.2 compiler sometimes allowed C functions to access
6426
                 non-@public ivars.  We will let this slide for now...  */
6427
              if (!objc_method_context)
6428
              {
6429
                warning (0, "instance variable %qE is %s; "
6430
                         "this will be a hard error in the future",
6431
                         identifier,
6432
                         TREE_PRIVATE (decl) ? "@private" : "@protected");
6433
                return 1;
6434
              }
6435
 
6436
              error ("instance variable %qE is declared %s",
6437
                     identifier,
6438
                     TREE_PRIVATE (decl) ? "private" : "protected");
6439
              return 0;
6440
            }
6441
        }
6442
    }
6443
 
6444
  return 1;
6445
}
6446
 
6447
/* Make sure all methods in CHAIN (a list of method declarations from
6448
   an @interface or a @protocol) are in IMPLEMENTATION (the
6449
   implementation context).  This is used to check for example that
6450
   all methods declared in an @interface were implemented in an
6451
   @implementation.
6452
 
6453
   Some special methods (property setters/getters) are special and if
6454
   they are not found in IMPLEMENTATION, we look them up in its
6455
   superclasses.  */
6456
 
6457
static int
6458
check_methods (tree chain, tree implementation, int mtype)
6459
{
6460
  int first = 1;
6461
  tree list;
6462
 
6463
  if (mtype == (int)'+')
6464
    list = CLASS_CLS_METHODS (implementation);
6465
  else
6466
    list = CLASS_NST_METHODS (implementation);
6467
 
6468
  while (chain)
6469
    {
6470
      /* If the method is associated with a dynamic property, then it
6471
         is Ok not to have the method implementation, as it will be
6472
         generated dynamically at runtime.  To decide if the method is
6473
         associated with a @dynamic property, we search the list of
6474
         @synthesize and @dynamic for this implementation, and look
6475
         for any @dynamic property with the same setter or getter name
6476
         as this method.  */
6477
      tree x;
6478
      for (x = IMPL_PROPERTY_DECL (implementation); x; x = TREE_CHAIN (x))
6479
        if (PROPERTY_DYNAMIC (x)
6480
            && (PROPERTY_GETTER_NAME (x) == METHOD_SEL_NAME (chain)
6481
                || PROPERTY_SETTER_NAME (x) == METHOD_SEL_NAME (chain)))
6482
          break;
6483
 
6484
      if (x != NULL_TREE)
6485
        {
6486
          chain = TREE_CHAIN (chain); /* next method...  */
6487
          continue;
6488
        }
6489
 
6490
      if (!lookup_method (list, chain))
6491
        {
6492
          /* If the method is a property setter/getter, we'll still
6493
             allow it to be missing if it is implemented by
6494
             'interface' or any of its superclasses.  */
6495
          tree property = METHOD_PROPERTY_CONTEXT (chain);
6496
          if (property)
6497
            {
6498
              /* Note that since this is a property getter/setter, it
6499
                 is obviously an instance method.  */
6500
              tree interface = NULL_TREE;
6501
 
6502
              /* For a category, first check the main class
6503
                 @interface.  */
6504
              if (TREE_CODE (implementation) == CATEGORY_IMPLEMENTATION_TYPE)
6505
                {
6506
                  interface = lookup_interface (CLASS_NAME (implementation));
6507
 
6508
                  /* If the method is found in the main class, it's Ok.  */
6509
                  if (lookup_method (CLASS_NST_METHODS (interface), chain))
6510
                    {
6511
                      chain = DECL_CHAIN (chain);
6512
                      continue;
6513
                    }
6514
 
6515
                  /* Else, get the superclass.  */
6516
                  if (CLASS_SUPER_NAME (interface))
6517
                    interface = lookup_interface (CLASS_SUPER_NAME (interface));
6518
                  else
6519
                    interface = NULL_TREE;
6520
                }
6521
 
6522
              /* Get the superclass for classes.  */
6523
              if (TREE_CODE (implementation) == CLASS_IMPLEMENTATION_TYPE)
6524
                {
6525
                  if (CLASS_SUPER_NAME (implementation))
6526
                    interface = lookup_interface (CLASS_SUPER_NAME (implementation));
6527
                  else
6528
                    interface = NULL_TREE;
6529
                }
6530
 
6531
              /* Now, interface is the superclass, if any; go check it.  */
6532
              if (interface)
6533
                {
6534
                  if (lookup_method_static (interface, chain, 0))
6535
                    {
6536
                      chain = DECL_CHAIN (chain);
6537
                      continue;
6538
                    }
6539
                }
6540
              /* Else, fall through - warn.  */
6541
            }
6542
          if (first)
6543
            {
6544
              switch (TREE_CODE (implementation))
6545
                {
6546
                case CLASS_IMPLEMENTATION_TYPE:
6547
                  warning (0, "incomplete implementation of class %qE",
6548
                           CLASS_NAME (implementation));
6549
                  break;
6550
                case CATEGORY_IMPLEMENTATION_TYPE:
6551
                  warning (0, "incomplete implementation of category %qE",
6552
                           CLASS_SUPER_NAME (implementation));
6553
                  break;
6554
                default:
6555
                  gcc_unreachable ();
6556
                }
6557
              first = 0;
6558
            }
6559
 
6560
          warning (0, "method definition for %<%c%E%> not found",
6561
                   mtype, METHOD_SEL_NAME (chain));
6562
        }
6563
 
6564
      chain = DECL_CHAIN (chain);
6565
    }
6566
 
6567
    return first;
6568
}
6569
 
6570
/* Check if KLASS, or its superclasses, explicitly conforms to PROTOCOL.  */
6571
 
6572
static int
6573
conforms_to_protocol (tree klass, tree protocol)
6574
{
6575
   if (TREE_CODE (protocol) == PROTOCOL_INTERFACE_TYPE)
6576
     {
6577
       tree p = CLASS_PROTOCOL_LIST (klass);
6578
       while (p && TREE_VALUE (p) != protocol)
6579
         p = TREE_CHAIN (p);
6580
 
6581
       if (!p)
6582
         {
6583
           tree super = (CLASS_SUPER_NAME (klass)
6584
                         ? lookup_interface (CLASS_SUPER_NAME (klass))
6585
                         : NULL_TREE);
6586
           int tmp = super ? conforms_to_protocol (super, protocol) : 0;
6587
           if (!tmp)
6588
             return 0;
6589
         }
6590
     }
6591
 
6592
   return 1;
6593
}
6594
 
6595
/* Make sure all methods in CHAIN are accessible as MTYPE methods in
6596
   CONTEXT.  This is one of two mechanisms to check protocol integrity.  */
6597
 
6598
static int
6599
check_methods_accessible (tree chain, tree context, int mtype)
6600
{
6601
  int first = 1;
6602
  tree list;
6603
  tree base_context = context;
6604
 
6605
  while (chain)
6606
    {
6607
      /* If the method is associated with a dynamic property, then it
6608
         is Ok not to have the method implementation, as it will be
6609
         generated dynamically at runtime.  Search for any @dynamic
6610
         property with the same setter or getter name as this
6611
         method.  TODO: Use a hashtable lookup.  */
6612
      tree x;
6613
      for (x = IMPL_PROPERTY_DECL (base_context); x; x = TREE_CHAIN (x))
6614
        if (PROPERTY_DYNAMIC (x)
6615
            && (PROPERTY_GETTER_NAME (x) == METHOD_SEL_NAME (chain)
6616
                || PROPERTY_SETTER_NAME (x) == METHOD_SEL_NAME (chain)))
6617
          break;
6618
 
6619
      if (x != NULL_TREE)
6620
        {
6621
          chain = TREE_CHAIN (chain); /* next method...  */
6622
          continue;
6623
        }
6624
 
6625
      context = base_context;
6626
      while (context)
6627
        {
6628
          if (mtype == '+')
6629
            list = CLASS_CLS_METHODS (context);
6630
          else
6631
            list = CLASS_NST_METHODS (context);
6632
 
6633
          if (lookup_method (list, chain))
6634
              break;
6635
 
6636
          switch (TREE_CODE (context))
6637
            {
6638
            case CLASS_IMPLEMENTATION_TYPE:
6639
            case CLASS_INTERFACE_TYPE:
6640
              context = (CLASS_SUPER_NAME (context)
6641
                         ? lookup_interface (CLASS_SUPER_NAME (context))
6642
                         : NULL_TREE);
6643
              break;
6644
            case CATEGORY_IMPLEMENTATION_TYPE:
6645
            case CATEGORY_INTERFACE_TYPE:
6646
              context = (CLASS_NAME (context)
6647
                         ? lookup_interface (CLASS_NAME (context))
6648
                         : NULL_TREE);
6649
              break;
6650
            default:
6651
              gcc_unreachable ();
6652
            }
6653
        }
6654
 
6655
      if (context == NULL_TREE)
6656
        {
6657
          if (first)
6658
            {
6659
              switch (TREE_CODE (objc_implementation_context))
6660
                {
6661
                case CLASS_IMPLEMENTATION_TYPE:
6662
                  warning (0, "incomplete implementation of class %qE",
6663
                           CLASS_NAME (objc_implementation_context));
6664
                  break;
6665
                case CATEGORY_IMPLEMENTATION_TYPE:
6666
                  warning (0, "incomplete implementation of category %qE",
6667
                           CLASS_SUPER_NAME (objc_implementation_context));
6668
                  break;
6669
                default:
6670
                  gcc_unreachable ();
6671
                }
6672
              first = 0;
6673
            }
6674
          warning (0, "method definition for %<%c%E%> not found",
6675
                   mtype, METHOD_SEL_NAME (chain));
6676
        }
6677
 
6678
      chain = TREE_CHAIN (chain); /* next method...  */
6679
    }
6680
  return first;
6681
}
6682
 
6683
/* Check whether the current interface (accessible via
6684
   'objc_implementation_context') actually implements protocol P, along
6685
   with any protocols that P inherits.  */
6686
 
6687
static void
6688
check_protocol (tree p, const char *type, tree name)
6689
{
6690
  if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
6691
    {
6692
      int f1, f2;
6693
 
6694
      /* Ensure that all protocols have bodies!  */
6695
      if (warn_protocol)
6696
        {
6697
          f1 = check_methods (PROTOCOL_CLS_METHODS (p),
6698
                              objc_implementation_context,
6699
                              '+');
6700
          f2 = check_methods (PROTOCOL_NST_METHODS (p),
6701
                              objc_implementation_context,
6702
                              '-');
6703
        }
6704
      else
6705
        {
6706
          f1 = check_methods_accessible (PROTOCOL_CLS_METHODS (p),
6707
                                         objc_implementation_context,
6708
                                         '+');
6709
          f2 = check_methods_accessible (PROTOCOL_NST_METHODS (p),
6710
                                         objc_implementation_context,
6711
                                         '-');
6712
        }
6713
 
6714
      if (!f1 || !f2)
6715
        warning (0, "%s %qE does not fully implement the %qE protocol",
6716
                 type, name, PROTOCOL_NAME (p));
6717
    }
6718
 
6719
  /* Check protocols recursively.  */
6720
  if (PROTOCOL_LIST (p))
6721
    {
6722
      tree subs = PROTOCOL_LIST (p);
6723
      tree super_class =
6724
        lookup_interface (CLASS_SUPER_NAME (implementation_template));
6725
 
6726
      while (subs)
6727
        {
6728
          tree sub = TREE_VALUE (subs);
6729
 
6730
          /* If the superclass does not conform to the protocols
6731
             inherited by P, then we must!  */
6732
          if (!super_class || !conforms_to_protocol (super_class, sub))
6733
            check_protocol (sub, type, name);
6734
          subs = TREE_CHAIN (subs);
6735
        }
6736
    }
6737
}
6738
 
6739
/* Check whether the current interface (accessible via
6740
   'objc_implementation_context') actually implements the protocols listed
6741
   in PROTO_LIST.  */
6742
 
6743
static void
6744
check_protocols (tree proto_list, const char *type, tree name)
6745
{
6746
  for ( ; proto_list; proto_list = TREE_CHAIN (proto_list))
6747
    {
6748
      tree p = TREE_VALUE (proto_list);
6749
 
6750
      check_protocol (p, type, name);
6751
    }
6752
}
6753
 
6754
/* Make sure that the class CLASS_NAME is defined CODE says which kind
6755
   of thing CLASS_NAME ought to be.  It can be CLASS_INTERFACE_TYPE,
6756
   CLASS_IMPLEMENTATION_TYPE, CATEGORY_INTERFACE_TYPE, or
6757
   CATEGORY_IMPLEMENTATION_TYPE.  For a CATEGORY_INTERFACE_TYPE,
6758
   SUPER_NAME is the name of the category.  For a class extension,
6759
   CODE is CATEGORY_INTERFACE_TYPE and SUPER_NAME is NULL_TREE.  */
6760
static tree
6761
start_class (enum tree_code code, tree class_name, tree super_name,
6762
             tree protocol_list, tree attributes)
6763
{
6764
  tree klass = NULL_TREE;
6765
  tree decl;
6766
 
6767
#ifdef OBJCPLUS
6768
  if (current_namespace != global_namespace)
6769
    {
6770
      error ("Objective-C declarations may only appear in global scope");
6771
    }
6772
#endif /* OBJCPLUS */
6773
 
6774
  if (objc_implementation_context)
6775
    {
6776
      warning (0, "%<@end%> missing in implementation context");
6777
      finish_class (objc_implementation_context);
6778
      objc_ivar_chain = NULL_TREE;
6779
      objc_implementation_context = NULL_TREE;
6780
    }
6781
 
6782
  /* If this is a class extension, we'll be "reopening" the existing
6783
     CLASS_INTERFACE_TYPE, so in that case there is no need to create
6784
     a new node.  */
6785
  if (code != CATEGORY_INTERFACE_TYPE || super_name != NULL_TREE)
6786
    {
6787
      klass = make_node (code);
6788
      TYPE_LANG_SLOT_1 (klass) = make_tree_vec (CLASS_LANG_SLOT_ELTS);
6789
    }
6790
 
6791
  /* Check for existence of the super class, if one was specified.  Note
6792
     that we must have seen an @interface, not just a @class.  If we
6793
     are looking at a @compatibility_alias, traverse it first.  */
6794
  if ((code == CLASS_INTERFACE_TYPE || code == CLASS_IMPLEMENTATION_TYPE)
6795
      && super_name)
6796
    {
6797
      tree super = objc_is_class_name (super_name);
6798
      tree super_interface = NULL_TREE;
6799
 
6800
      if (super)
6801
        super_interface = lookup_interface (super);
6802
 
6803
      if (!super_interface)
6804
        {
6805
          error ("cannot find interface declaration for %qE, superclass of %qE",
6806
                 super ? super : super_name,
6807
                 class_name);
6808
          super_name = NULL_TREE;
6809
        }
6810
      else
6811
        {
6812
          if (TREE_DEPRECATED (super_interface))
6813
            warning (OPT_Wdeprecated_declarations, "class %qE is deprecated",
6814
                     super);
6815
          super_name = super;
6816
        }
6817
    }
6818
 
6819
  if (code != CATEGORY_INTERFACE_TYPE || super_name != NULL_TREE)
6820
    {
6821
      CLASS_NAME (klass) = class_name;
6822
      CLASS_SUPER_NAME (klass) = super_name;
6823
      CLASS_CLS_METHODS (klass) = NULL_TREE;
6824
    }
6825
 
6826
  if (! objc_is_class_name (class_name)
6827
      && (decl = lookup_name (class_name)))
6828
    {
6829
      error ("%qE redeclared as different kind of symbol",
6830
             class_name);
6831
      error ("previous declaration of %q+D",
6832
             decl);
6833
    }
6834
 
6835
  switch (code)
6836
    {
6837
    case CLASS_IMPLEMENTATION_TYPE:
6838
      {
6839
        tree chain;
6840
 
6841
        for (chain = implemented_classes; chain; chain = TREE_CHAIN (chain))
6842
          if (TREE_VALUE (chain) == class_name)
6843
            {
6844
              error ("reimplementation of class %qE",
6845
                     class_name);
6846
              /* TODO: error message saying where it was previously
6847
                 implemented.  */
6848
              break;
6849
            }
6850
        if (chain == NULL_TREE)
6851
          implemented_classes = tree_cons (NULL_TREE, class_name,
6852
                                           implemented_classes);
6853
      }
6854
 
6855
      /* Reset for multiple classes per file.  */
6856
      method_slot = 0;
6857
 
6858
      objc_implementation_context = klass;
6859
 
6860
      /* Lookup the interface for this implementation.  */
6861
 
6862
      if (!(implementation_template = lookup_interface (class_name)))
6863
        {
6864
          warning (0, "cannot find interface declaration for %qE",
6865
                   class_name);
6866
          add_interface (implementation_template = objc_implementation_context,
6867
                         class_name);
6868
        }
6869
 
6870
      /* If a super class has been specified in the implementation,
6871
         insure it conforms to the one specified in the interface.  */
6872
 
6873
      if (super_name
6874
          && (super_name != CLASS_SUPER_NAME (implementation_template)))
6875
        {
6876
          tree previous_name = CLASS_SUPER_NAME (implementation_template);
6877
          error ("conflicting super class name %qE",
6878
                 super_name);
6879
          if (previous_name)
6880
            error ("previous declaration of %qE", previous_name);
6881
          else
6882
            error ("previous declaration");
6883
        }
6884
 
6885
      else if (! super_name)
6886
        {
6887
          CLASS_SUPER_NAME (objc_implementation_context)
6888
            = CLASS_SUPER_NAME (implementation_template);
6889
        }
6890
      break;
6891
 
6892
    case CLASS_INTERFACE_TYPE:
6893
      if (lookup_interface (class_name))
6894
#ifdef OBJCPLUS
6895
        error ("duplicate interface declaration for class %qE", class_name);
6896
#else
6897
        warning (0, "duplicate interface declaration for class %qE", class_name);
6898
#endif
6899
      else
6900
        add_interface (klass, class_name);
6901
 
6902
      if (protocol_list)
6903
        CLASS_PROTOCOL_LIST (klass)
6904
          = lookup_and_install_protocols (protocol_list, /* definition_required */ true);
6905
 
6906
      if (attributes)
6907
        {
6908
          tree attribute;
6909
          for (attribute = attributes; attribute; attribute = TREE_CHAIN (attribute))
6910
            {
6911
              tree name = TREE_PURPOSE (attribute);
6912
 
6913
              /* TODO: Document what the objc_exception attribute is/does.  */
6914
              /* We handle the 'deprecated' and (undocumented) 'objc_exception'
6915
                 attributes.  */
6916
              if (is_attribute_p  ("deprecated", name))
6917
                TREE_DEPRECATED (klass) = 1;
6918
              else if (is_attribute_p  ("objc_exception", name))
6919
                CLASS_HAS_EXCEPTION_ATTR (klass) = 1;
6920
              else
6921
                /* Warn about and ignore all others for now, but store them.  */
6922
                warning (OPT_Wattributes, "%qE attribute directive ignored", name);
6923
            }
6924
          TYPE_ATTRIBUTES (klass) = attributes;
6925
        }
6926
      break;
6927
 
6928
    case CATEGORY_INTERFACE_TYPE:
6929
      {
6930
        tree class_category_is_assoc_with;
6931
 
6932
        /* For a category, class_name is really the name of the class that
6933
           the following set of methods will be associated with. We must
6934
           find the interface so that can derive the objects template.  */
6935
        if (!(class_category_is_assoc_with = lookup_interface (class_name)))
6936
          {
6937
            error ("cannot find interface declaration for %qE",
6938
                   class_name);
6939
            exit (FATAL_EXIT_CODE);
6940
          }
6941
        else
6942
          {
6943
            if (TREE_DEPRECATED (class_category_is_assoc_with))
6944
              warning (OPT_Wdeprecated_declarations, "class %qE is deprecated",
6945
                       class_name);
6946
 
6947
            if (super_name == NULL_TREE)
6948
              {
6949
                /* This is a class extension.  Get the original
6950
                   interface, and continue working on it.  */
6951
                objc_in_class_extension = true;
6952
                klass = class_category_is_assoc_with;
6953
 
6954
                if (protocol_list)
6955
                  {
6956
                    /* Append protocols to the original protocol
6957
                       list.  */
6958
                    CLASS_PROTOCOL_LIST (klass)
6959
                      = chainon (CLASS_PROTOCOL_LIST (klass),
6960
                                 lookup_and_install_protocols
6961
                                 (protocol_list,
6962
                                  /* definition_required */ true));
6963
                  }
6964
              }
6965
            else
6966
              {
6967
                add_category (class_category_is_assoc_with, klass);
6968
 
6969
                if (protocol_list)
6970
                  CLASS_PROTOCOL_LIST (klass)
6971
                    = lookup_and_install_protocols
6972
                    (protocol_list, /* definition_required */ true);
6973
              }
6974
          }
6975
      }
6976
      break;
6977
 
6978
    case CATEGORY_IMPLEMENTATION_TYPE:
6979
      /* Reset for multiple classes per file.  */
6980
      method_slot = 0;
6981
 
6982
      objc_implementation_context = klass;
6983
 
6984
      /* For a category, class_name is really the name of the class that
6985
         the following set of methods will be associated with.  We must
6986
         find the interface so that can derive the objects template.  */
6987
 
6988
      if (!(implementation_template = lookup_interface (class_name)))
6989
        {
6990
          error ("cannot find interface declaration for %qE",
6991
                 class_name);
6992
          exit (FATAL_EXIT_CODE);
6993
        }
6994
      break;
6995
    default:
6996
      gcc_unreachable ();
6997
    }
6998
  return klass;
6999
}
7000
 
7001
static tree
7002
continue_class (tree klass)
7003
{
7004
  switch (TREE_CODE (klass))
7005
    {
7006
    case CLASS_IMPLEMENTATION_TYPE:
7007
    case CATEGORY_IMPLEMENTATION_TYPE:
7008
      {
7009
        struct imp_entry *imp_entry;
7010
 
7011
        /* Check consistency of the instance variables.  */
7012
 
7013
        if (CLASS_RAW_IVARS (klass))
7014
          check_ivars (implementation_template, klass);
7015
 
7016
        /* code generation */
7017
#ifdef OBJCPLUS
7018
        push_lang_context (lang_name_c);
7019
#endif
7020
        build_private_template (implementation_template);
7021
        uprivate_record = CLASS_STATIC_TEMPLATE (implementation_template);
7022
        objc_instance_type = build_pointer_type (uprivate_record);
7023
 
7024
        imp_entry = ggc_alloc_imp_entry ();
7025
 
7026
        imp_entry->next = imp_list;
7027
        imp_entry->imp_context = klass;
7028
        imp_entry->imp_template = implementation_template;
7029
        ucls_super_ref = uucls_super_ref = NULL;
7030
        if (TREE_CODE (klass) == CLASS_IMPLEMENTATION_TYPE)
7031
          {
7032
            imp_entry->class_decl = (*runtime.class_decl) (klass);
7033
            imp_entry->meta_decl = (*runtime.metaclass_decl) (klass);
7034
          }
7035
        else
7036
          {
7037
            imp_entry->class_decl = (*runtime.category_decl) (klass);
7038
            imp_entry->meta_decl = NULL;
7039
          }
7040
        imp_entry->has_cxx_cdtors = 0;
7041
 
7042
        /* Append to front and increment count.  */
7043
        imp_list = imp_entry;
7044
        if (TREE_CODE (klass) == CLASS_IMPLEMENTATION_TYPE)
7045
          imp_count++;
7046
        else
7047
          cat_count++;
7048
#ifdef OBJCPLUS
7049
        pop_lang_context ();
7050
#endif /* OBJCPLUS */
7051
 
7052
        return get_class_ivars (implementation_template, true);
7053
        break;
7054
      }
7055
    case CLASS_INTERFACE_TYPE:
7056
      {
7057
        if (objc_in_class_extension)
7058
          return NULL_TREE;
7059
#ifdef OBJCPLUS
7060
        push_lang_context (lang_name_c);
7061
#endif /* OBJCPLUS */
7062
        objc_collecting_ivars = 1;
7063
        build_private_template (klass);
7064
        objc_collecting_ivars = 0;
7065
#ifdef OBJCPLUS
7066
        pop_lang_context ();
7067
#endif /* OBJCPLUS */
7068
        return NULL_TREE;
7069
        break;
7070
      }
7071
    default:
7072
      return error_mark_node;
7073
    }
7074
}
7075
 
7076
/* This routine builds name of the setter synthesized function. */
7077
char *
7078
objc_build_property_setter_name (tree ident)
7079
{
7080
  /* TODO: Use alloca to allocate buffer of appropriate size.  */
7081
  static char string[BUFSIZE];
7082
  sprintf (string, "set%s:", IDENTIFIER_POINTER (ident));
7083
  string[3] = TOUPPER (string[3]);
7084
  return string;
7085
}
7086
 
7087
/* This routine prepares the declarations of the property accessor
7088
   helper functions (objc_getProperty(), etc) that are used when
7089
   @synthesize is used.
7090
 
7091
   runtime-specific routines are built in the respective runtime
7092
   initialize functions.  */
7093
static void
7094
build_common_objc_property_accessor_helpers (void)
7095
{
7096
  tree type;
7097
 
7098
  /* Declare the following function:
7099
     id
7100
     objc_getProperty (id self, SEL _cmd,
7101
                       ptrdiff_t offset, BOOL is_atomic);  */
7102
  type = build_function_type_list (objc_object_type,
7103
                                   objc_object_type,
7104
                                   objc_selector_type,
7105
                                   ptrdiff_type_node,
7106
                                   boolean_type_node,
7107
                                   NULL_TREE);
7108
  objc_getProperty_decl = add_builtin_function ("objc_getProperty",
7109
                                                type, 0, NOT_BUILT_IN,
7110
                                                NULL, NULL_TREE);
7111
  TREE_NOTHROW (objc_getProperty_decl) = 0;
7112
 
7113
  /* Declare the following function:
7114
     void
7115
     objc_setProperty (id self, SEL _cmd,
7116
                       ptrdiff_t offset, id new_value,
7117
                       BOOL is_atomic, BOOL should_copy);  */
7118
  type = build_function_type_list (void_type_node,
7119
                                   objc_object_type,
7120
                                   objc_selector_type,
7121
                                   ptrdiff_type_node,
7122
                                   objc_object_type,
7123
                                   boolean_type_node,
7124
                                   boolean_type_node,
7125
                                   NULL_TREE);
7126
  objc_setProperty_decl = add_builtin_function ("objc_setProperty",
7127
                                                type, 0, NOT_BUILT_IN,
7128
                                                NULL, NULL_TREE);
7129
  TREE_NOTHROW (objc_setProperty_decl) = 0;
7130
}
7131
 
7132
/* This looks up an ivar in a class (including superclasses).  */
7133
static tree
7134
lookup_ivar (tree interface, tree instance_variable_name)
7135
{
7136
  while (interface)
7137
    {
7138
      tree decl_chain;
7139
 
7140
      for (decl_chain = CLASS_IVARS (interface); decl_chain; decl_chain = DECL_CHAIN (decl_chain))
7141
        if (DECL_NAME (decl_chain) == instance_variable_name)
7142
          return decl_chain;
7143
 
7144
      /* Not found.  Search superclass if any.  */
7145
      if (CLASS_SUPER_NAME (interface))
7146
        interface = lookup_interface (CLASS_SUPER_NAME (interface));
7147
    }
7148
 
7149
  return NULL_TREE;
7150
}
7151
 
7152
/* This routine synthesizes a 'getter' method.  This is only called
7153
   for @synthesize properties.  */
7154
static void
7155
objc_synthesize_getter (tree klass, tree class_methods ATTRIBUTE_UNUSED, tree property)
7156
{
7157
  location_t location = DECL_SOURCE_LOCATION (property);
7158
  tree fn, decl;
7159
  tree body;
7160
  tree ret_val;
7161
 
7162
  /* If user has implemented a getter with same name then do nothing.  */
7163
  if (lookup_method (CLASS_NST_METHODS (objc_implementation_context),
7164
                     PROPERTY_GETTER_NAME (property)))
7165
    return;
7166
 
7167
  /* Find declaration of the property getter in the interface (or
7168
     superclass, or protocol). There must be one.  */
7169
  decl = lookup_method_static (klass, PROPERTY_GETTER_NAME (property), 0);
7170
 
7171
  /* If one not declared in the interface, this condition has already
7172
     been reported as user error (because property was not declared in
7173
     the interface).  */
7174
  if (!decl)
7175
    return;
7176
 
7177
  /* Adapt the 'decl'.  Use the source location of the @synthesize
7178
     statement for error messages.  */
7179
  decl = copy_node (decl);
7180
  DECL_SOURCE_LOCATION (decl) = location;
7181
 
7182
  objc_start_method_definition (false /* is_class_method */, decl, NULL_TREE,
7183
                                NULL_TREE);
7184
  body = c_begin_compound_stmt (true);
7185
 
7186
  /* Now we need to decide how we build the getter.  There are three
7187
     cases:
7188
 
7189
     for 'copy' or 'retain' properties we need to use the
7190
     objc_getProperty() accessor helper which knows about retain and
7191
     copy.  It supports both 'nonatomic' and 'atomic' access.
7192
 
7193
     for 'nonatomic, assign' properties we can access the instance
7194
     variable directly.  'nonatomic' means we don't have to use locks,
7195
     and 'assign' means we don't have to worry about retain or copy.
7196
     If you combine the two, it means we can just access the instance
7197
     variable directly.
7198
 
7199
     for 'atomic, assign' properties we use objc_copyStruct() (for the
7200
     next runtime) or objc_getPropertyStruct() (for the GNU runtime).  */
7201
  switch (PROPERTY_ASSIGN_SEMANTICS (property))
7202
    {
7203
    case OBJC_PROPERTY_RETAIN:
7204
    case OBJC_PROPERTY_COPY:
7205
      {
7206
        /* We build "return objc_getProperty (self, _cmd, offset, is_atomic);"  */
7207
        tree cmd, ivar, offset, is_atomic;
7208
        cmd = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl));
7209
 
7210
        /* Find the ivar to compute the offset.  */
7211
        ivar = lookup_ivar (klass, PROPERTY_IVAR_NAME (property));
7212
        if (!ivar || is_private (ivar))
7213
          {
7214
            /* This should never happen.  */
7215
            error_at (location,
7216
                      "can not find instance variable associated with property");
7217
            ret_val = error_mark_node;
7218
            break;
7219
          }
7220
        offset = byte_position (ivar);
7221
 
7222
        if (PROPERTY_NONATOMIC (property))
7223
          is_atomic = boolean_false_node;
7224
        else
7225
          is_atomic = boolean_true_node;
7226
 
7227
        ret_val = build_function_call
7228
          (location,
7229
           /* Function prototype.  */
7230
           objc_getProperty_decl,
7231
           /* Parameters.  */
7232
           tree_cons    /* self */
7233
           (NULL_TREE, self_decl,
7234
            tree_cons   /* _cmd */
7235
            (NULL_TREE, cmd,
7236
             tree_cons  /* offset */
7237
             (NULL_TREE, offset,
7238
              tree_cons /* is_atomic */
7239
              (NULL_TREE, is_atomic, NULL_TREE)))));
7240
      }
7241
      break;
7242
    case OBJC_PROPERTY_ASSIGN:
7243
      if (PROPERTY_NONATOMIC (property))
7244
        {
7245
          /* We build "return self->PROPERTY_IVAR_NAME;"  */
7246
          ret_val = objc_lookup_ivar (NULL_TREE, PROPERTY_IVAR_NAME (property));
7247
          break;
7248
        }
7249
      else
7250
        {
7251
          /* We build
7252
               <property type> __objc_property_temp;
7253
               objc_getPropertyStruct (&__objc_property_temp,
7254
                                       &(self->PROPERTY_IVAR_NAME),
7255
                                       sizeof (type of self->PROPERTY_IVAR_NAME),
7256
                                       is_atomic,
7257
                                       false)
7258
               return __objc_property_temp;
7259
 
7260
             For the NeXT runtime, we need to use objc_copyStruct
7261
             instead of objc_getPropertyStruct.  */
7262
          tree objc_property_temp_decl, function_decl, function_call;
7263
          tree size_of, is_atomic;
7264
 
7265
          objc_property_temp_decl = objc_create_temporary_var (TREE_TYPE (property), "__objc_property_temp");
7266
          DECL_SOURCE_LOCATION (objc_property_temp_decl) = location;
7267
          objc_property_temp_decl = lang_hooks.decls.pushdecl (objc_property_temp_decl);
7268
 
7269
          /* sizeof (ivar type).  Since the ivar and the property have
7270
             the same type, there is no need to lookup the ivar.  */
7271
          size_of = c_sizeof_or_alignof_type (location, TREE_TYPE (property),
7272
                                              true /* is_sizeof */,
7273
                                              false /* complain */);
7274
 
7275
          if (PROPERTY_NONATOMIC (property))
7276
            is_atomic = boolean_false_node;
7277
          else
7278
            is_atomic = boolean_true_node;
7279
 
7280
          if (objc_copyStruct_decl)
7281
            function_decl = objc_copyStruct_decl;
7282
          else
7283
            function_decl = objc_getPropertyStruct_decl;
7284
 
7285
          function_call = build_function_call
7286
            (location,
7287
             /* Function prototype.  */
7288
             function_decl,
7289
             /* Parameters.  */
7290
             tree_cons /* &__objc_property_temp_decl */
7291
             /* Warning: note that using build_fold_addr_expr_loc()
7292
                here causes invalid code to be generated.  */
7293
             (NULL_TREE, build_unary_op (location, ADDR_EXPR, objc_property_temp_decl, 0),
7294
              tree_cons /* &(self->PROPERTY_IVAR_NAME); */
7295
              (NULL_TREE, build_fold_addr_expr_loc (location,
7296
                                                    objc_lookup_ivar
7297
                                                    (NULL_TREE, PROPERTY_IVAR_NAME (property))),
7298
               tree_cons /* sizeof (PROPERTY_IVAR) */
7299
               (NULL_TREE, size_of,
7300
                tree_cons /* is_atomic */
7301
                (NULL_TREE, is_atomic,
7302
                 /* TODO: This is currently ignored by the GNU
7303
                    runtime, but what about the next one ? */
7304
                 tree_cons /* has_strong */
7305
                 (NULL_TREE, boolean_true_node, NULL_TREE))))));
7306
 
7307
          add_stmt (function_call);
7308
 
7309
          ret_val = objc_property_temp_decl;
7310
        }
7311
      break;
7312
    default:
7313
      gcc_unreachable ();
7314
    }
7315
 
7316
  gcc_assert (ret_val);
7317
 
7318
#ifdef OBJCPLUS
7319
  finish_return_stmt (ret_val);
7320
#else
7321
  c_finish_return (location, ret_val, NULL_TREE);
7322
#endif
7323
 
7324
  add_stmt (c_end_compound_stmt (location, body, true));
7325
  fn = current_function_decl;
7326
#ifdef OBJCPLUS
7327
  finish_function ();
7328
#endif
7329
  objc_finish_method_definition (fn);
7330
}
7331
 
7332
/* This routine synthesizes a 'setter' method.  */
7333
 
7334
static void
7335
objc_synthesize_setter (tree klass, tree class_methods ATTRIBUTE_UNUSED, tree property)
7336
{
7337
  location_t location = DECL_SOURCE_LOCATION (property);
7338
  tree fn, decl;
7339
  tree body;
7340
  tree new_value, statement;
7341
 
7342
  /* If user has implemented a setter with same name then do nothing.  */
7343
  if (lookup_method (CLASS_NST_METHODS (objc_implementation_context),
7344
                     PROPERTY_SETTER_NAME (property)))
7345
    return;
7346
 
7347
  /* Find declaration of the property setter in the interface (or
7348
     superclass, or protocol). There must be one.  */
7349
  decl = lookup_method_static (klass, PROPERTY_SETTER_NAME (property), 0);
7350
 
7351
  /* If one not declared in the interface, this condition has already
7352
     been reported as user error (because property was not declared in
7353
     the interface).  */
7354
  if (!decl)
7355
    return;
7356
 
7357
  /* Adapt the 'decl'.  Use the source location of the @synthesize
7358
     statement for error messages.  */
7359
  decl = copy_node (decl);
7360
  DECL_SOURCE_LOCATION (decl) = DECL_SOURCE_LOCATION (property);
7361
 
7362
  objc_start_method_definition (false /* is_class_method */, decl, NULL_TREE,
7363
                                NULL_TREE);
7364
 
7365
  body = c_begin_compound_stmt (true);
7366
 
7367
  /* The 'new_value' is the only argument to the method, which is the
7368
     3rd argument of the function, after self and _cmd.  We use twice
7369
     TREE_CHAIN to move forward two arguments.  */
7370
  new_value = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (current_function_decl)));
7371
 
7372
  /* This would presumably happen if the user has specified a
7373
     prototype for the setter that does not have an argument!  */
7374
  if (new_value == NULL_TREE)
7375
    {
7376
      /* TODO: This should be caught much earlier than this.  */
7377
      error_at (DECL_SOURCE_LOCATION (decl), "invalid setter, it must have one argument");
7378
      /* Try to recover somehow.  */
7379
      new_value = error_mark_node;
7380
    }
7381
 
7382
  /* Now we need to decide how we build the setter.  There are three
7383
     cases:
7384
 
7385
     for 'copy' or 'retain' properties we need to use the
7386
     objc_setProperty() accessor helper which knows about retain and
7387
     copy.  It supports both 'nonatomic' and 'atomic' access.
7388
 
7389
     for 'nonatomic, assign' properties we can access the instance
7390
     variable directly.  'nonatomic' means we don't have to use locks,
7391
     and 'assign' means we don't have to worry about retain or copy.
7392
     If you combine the two, it means we can just access the instance
7393
     variable directly.
7394
 
7395
     for 'atomic, assign' properties we use objc_copyStruct() (for the
7396
     next runtime) or objc_setPropertyStruct() (for the GNU runtime).  */
7397
  switch (PROPERTY_ASSIGN_SEMANTICS (property))
7398
    {
7399
    case OBJC_PROPERTY_RETAIN:
7400
    case OBJC_PROPERTY_COPY:
7401
      {
7402
        /* We build "objc_setProperty (self, _cmd, new_value, offset, is_atomic, should_copy);"  */
7403
        tree cmd, ivar, offset, is_atomic, should_copy;
7404
        cmd = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl));
7405
 
7406
        /* Find the ivar to compute the offset.  */
7407
        ivar = lookup_ivar (klass, PROPERTY_IVAR_NAME (property));
7408
        if (!ivar || is_private (ivar))
7409
          {
7410
            error_at (location,
7411
                      "can not find instance variable associated with property");
7412
            statement = error_mark_node;
7413
            break;
7414
          }
7415
        offset = byte_position (ivar);
7416
 
7417
        if (PROPERTY_NONATOMIC (property))
7418
          is_atomic = boolean_false_node;
7419
        else
7420
          is_atomic = boolean_true_node;
7421
 
7422
        if (PROPERTY_ASSIGN_SEMANTICS (property) == OBJC_PROPERTY_COPY)
7423
          should_copy = boolean_true_node;
7424
        else
7425
          should_copy = boolean_false_node;
7426
 
7427
        statement = build_function_call
7428
          (location,
7429
           /* Function prototype.  */
7430
           objc_setProperty_decl,
7431
           /* Parameters.  */
7432
           tree_cons    /* self */
7433
           (NULL_TREE, self_decl,
7434
            tree_cons   /* _cmd */
7435
            (NULL_TREE, cmd,
7436
             tree_cons  /* offset */
7437
             (NULL_TREE, offset,
7438
              tree_cons /* new_value */
7439
              (NULL_TREE, new_value,
7440
               tree_cons /* is_atomic */
7441
               (NULL_TREE, is_atomic,
7442
                tree_cons /* should_copy */
7443
                (NULL_TREE, should_copy, NULL_TREE)))))));
7444
      }
7445
      break;
7446
    case OBJC_PROPERTY_ASSIGN:
7447
      if (PROPERTY_NONATOMIC (property))
7448
        {
7449
          /* We build "self->PROPERTY_IVAR_NAME = new_value;"  */
7450
          statement = build_modify_expr
7451
            (location,
7452
             objc_lookup_ivar (NULL_TREE, PROPERTY_IVAR_NAME (property)),
7453
             NULL_TREE, NOP_EXPR,
7454
             location, new_value, NULL_TREE);
7455
          break;
7456
        }
7457
      else
7458
        {
7459
          /* We build
7460
               objc_setPropertyStruct (&(self->PROPERTY_IVAR_NAME),
7461
                                       &new_value,
7462
                                       sizeof (type of self->PROPERTY_IVAR_NAME),
7463
                                       is_atomic,
7464
                                       false)
7465
 
7466
             For the NeXT runtime, we need to use objc_copyStruct
7467
             instead of objc_getPropertyStruct.  */
7468
          tree function_decl, size_of, is_atomic;
7469
 
7470
          /* sizeof (ivar type).  Since the ivar and the property have
7471
             the same type, there is no need to lookup the ivar.  */
7472
          size_of = c_sizeof_or_alignof_type (location, TREE_TYPE (property),
7473
                                              true /* is_sizeof */,
7474
                                              false /* complain */);
7475
 
7476
          if (PROPERTY_NONATOMIC (property))
7477
            is_atomic = boolean_false_node;
7478
          else
7479
            is_atomic = boolean_true_node;
7480
 
7481
          if (objc_copyStruct_decl)
7482
            function_decl = objc_copyStruct_decl;
7483
          else
7484
            function_decl = objc_setPropertyStruct_decl;
7485
 
7486
          statement = build_function_call
7487
            (location,
7488
             /* Function prototype.  */
7489
             function_decl,
7490
             /* Parameters.  */
7491
             tree_cons /* &(self->PROPERTY_IVAR_NAME); */
7492
             (NULL_TREE, build_fold_addr_expr_loc (location,
7493
                                                   objc_lookup_ivar
7494
                                                   (NULL_TREE, PROPERTY_IVAR_NAME (property))),
7495
              tree_cons /* &new_value */
7496
              (NULL_TREE, build_fold_addr_expr_loc (location, new_value),
7497
               tree_cons /* sizeof (PROPERTY_IVAR) */
7498
               (NULL_TREE, size_of,
7499
                tree_cons /* is_atomic */
7500
                (NULL_TREE, is_atomic,
7501
                 /* TODO: This is currently ignored by the GNU
7502
                    runtime, but what about the next one ? */
7503
                 tree_cons /* has_strong */
7504
                 (NULL_TREE, boolean_true_node, NULL_TREE))))));
7505
        }
7506
      break;
7507
    default:
7508
      gcc_unreachable ();
7509
    }
7510
  gcc_assert (statement);
7511
 
7512
  add_stmt (statement);
7513
  add_stmt (c_end_compound_stmt (location, body, true));
7514
  fn = current_function_decl;
7515
#ifdef OBJCPLUS
7516
  finish_function ();
7517
#endif
7518
  objc_finish_method_definition (fn);
7519
}
7520
 
7521
/* This function is a sub-routine of objc_add_synthesize_declaration.
7522
   It is called for each property to synthesize once we have
7523
   determined that the context is Ok.  */
7524
static void
7525
objc_add_synthesize_declaration_for_property (location_t location, tree interface,
7526
                                              tree property_name, tree ivar_name)
7527
{
7528
  /* Find the @property declaration.  */
7529
  tree property;
7530
  tree x;
7531
 
7532
  /* Check that synthesize or dynamic has not already been used for
7533
     the same property.  */
7534
  for (property = IMPL_PROPERTY_DECL (objc_implementation_context); property; property = TREE_CHAIN (property))
7535
    if (PROPERTY_NAME (property) == property_name)
7536
      {
7537
        location_t original_location = DECL_SOURCE_LOCATION (property);
7538
 
7539
        if (PROPERTY_DYNAMIC (property))
7540
          error_at (location, "property %qs already specified in %<@dynamic%>",
7541
                    IDENTIFIER_POINTER (property_name));
7542
        else
7543
          error_at (location, "property %qs already specified in %<@synthesize%>",
7544
                    IDENTIFIER_POINTER (property_name));
7545
 
7546
        if (original_location != UNKNOWN_LOCATION)
7547
          inform (original_location, "originally specified here");
7548
        return;
7549
      }
7550
 
7551
  /* Check that the property is declared in the interface.  It could
7552
     also be declared in a superclass or protocol.  */
7553
  property = lookup_property (interface, property_name);
7554
 
7555
  if (!property)
7556
    {
7557
      error_at (location, "no declaration of property %qs found in the interface",
7558
                IDENTIFIER_POINTER (property_name));
7559
      return;
7560
    }
7561
  else
7562
    {
7563
      /* We have to copy the property, because we want to chain it to
7564
         the implementation context, and we want to store the source
7565
         location of the @synthesize, not of the original
7566
         @property.  */
7567
      property = copy_node (property);
7568
      DECL_SOURCE_LOCATION (property) = location;
7569
    }
7570
 
7571
  /* Determine PROPERTY_IVAR_NAME.  */
7572
  if (ivar_name == NULL_TREE)
7573
    ivar_name = property_name;
7574
 
7575
  /* Check that the instance variable exists.  You can only use an
7576
     instance variable from the same class, not one from the
7577
     superclass (this makes sense as it allows us to check that an
7578
     instance variable is only used in one synthesized property).  */
7579
  {
7580
    tree ivar = is_ivar (CLASS_IVARS (interface), ivar_name);
7581
    tree type_of_ivar;
7582
    if (!ivar)
7583
      {
7584
        error_at (location, "ivar %qs used by %<@synthesize%> declaration must be an existing ivar",
7585
                  IDENTIFIER_POINTER (property_name));
7586
        return;
7587
      }
7588
 
7589
    if (DECL_BIT_FIELD_TYPE (ivar))
7590
      type_of_ivar = DECL_BIT_FIELD_TYPE (ivar);
7591
    else
7592
      type_of_ivar = TREE_TYPE (ivar);
7593
 
7594
    /* If the instance variable has a different C type, we throw an error ...  */
7595
    if (!comptypes (TREE_TYPE (property), type_of_ivar)
7596
        /* ... unless the property is readonly, in which case we allow
7597
           the instance variable to be more specialized (this means we
7598
           can generate the getter all right and it works).  */
7599
        && (!PROPERTY_READONLY (property)
7600
            || !objc_compare_types (TREE_TYPE (property),
7601
                                    type_of_ivar, -5, NULL_TREE)))
7602
      {
7603
        location_t original_location = DECL_SOURCE_LOCATION (ivar);
7604
 
7605
        error_at (location, "property %qs is using instance variable %qs of incompatible type",
7606
                  IDENTIFIER_POINTER (property_name),
7607
                  IDENTIFIER_POINTER (ivar_name));
7608
 
7609
        if (original_location != UNKNOWN_LOCATION)
7610
          inform (original_location, "originally specified here");
7611
      }
7612
 
7613
    /* If the instance variable is a bitfield, the property must be
7614
       'assign', 'nonatomic' because the runtime getter/setter helper
7615
       do not work with bitfield instance variables.  */
7616
    if (DECL_BIT_FIELD_TYPE (ivar))
7617
      {
7618
        /* If there is an error, we return and not generate any
7619
           getter/setter because trying to set up the runtime
7620
           getter/setter helper calls with bitfields is at high risk
7621
           of ICE.  */
7622
 
7623
        if (PROPERTY_ASSIGN_SEMANTICS (property) != OBJC_PROPERTY_ASSIGN)
7624
          {
7625
            location_t original_location = DECL_SOURCE_LOCATION (ivar);
7626
 
7627
            error_at (location, "'assign' property %qs is using bit-field instance variable %qs",
7628
                      IDENTIFIER_POINTER (property_name),
7629
                      IDENTIFIER_POINTER (ivar_name));
7630
 
7631
            if (original_location != UNKNOWN_LOCATION)
7632
              inform (original_location, "originally specified here");
7633
            return;
7634
          }
7635
 
7636
        if (!PROPERTY_NONATOMIC (property))
7637
          {
7638
            location_t original_location = DECL_SOURCE_LOCATION (ivar);
7639
 
7640
            error_at (location, "'atomic' property %qs is using bit-field instance variable %qs",
7641
                      IDENTIFIER_POINTER (property_name),
7642
                      IDENTIFIER_POINTER (ivar_name));
7643
 
7644
            if (original_location != UNKNOWN_LOCATION)
7645
              inform (original_location, "originally specified here");
7646
            return;
7647
          }
7648
      }
7649
  }
7650
 
7651
  /* Check that no other property is using the same instance
7652
     variable.  */
7653
  for (x = IMPL_PROPERTY_DECL (objc_implementation_context); x; x = TREE_CHAIN (x))
7654
    if (PROPERTY_IVAR_NAME (x) == ivar_name)
7655
      {
7656
        location_t original_location = DECL_SOURCE_LOCATION (x);
7657
 
7658
        error_at (location, "property %qs is using the same instance variable as property %qs",
7659
                  IDENTIFIER_POINTER (property_name),
7660
                  IDENTIFIER_POINTER (PROPERTY_NAME (x)));
7661
 
7662
        if (original_location != UNKNOWN_LOCATION)
7663
          inform (original_location, "originally specified here");
7664
 
7665
        /* We keep going on.  This won't cause the compiler to fail;
7666
           the failure would most likely be at runtime.  */
7667
      }
7668
 
7669
  /* Note that a @synthesize (and only a @synthesize) always sets
7670
     PROPERTY_IVAR_NAME to a non-NULL_TREE.  You can recognize a
7671
     @synthesize by that.  */
7672
  PROPERTY_IVAR_NAME (property) = ivar_name;
7673
 
7674
  /* PROPERTY_SETTER_NAME and PROPERTY_GETTER_NAME are copied from the
7675
     original declaration; they are always set (with the exception of
7676
     PROPERTY_SETTER_NAME not being set if PROPERTY_READONLY == 1).  */
7677
 
7678
  /* Add the property to the list of properties for current implementation. */
7679
  TREE_CHAIN (property) = IMPL_PROPERTY_DECL (objc_implementation_context);
7680
  IMPL_PROPERTY_DECL (objc_implementation_context) = property;
7681
 
7682
  /* Note how we don't actually synthesize the getter/setter here; it
7683
     would be very natural, but we may miss the fact that the user has
7684
     implemented his own getter/setter later on in the @implementation
7685
     (in which case we shouldn't generate getter/setter).  We wait
7686
     until we have parsed it all before generating the code.  */
7687
}
7688
 
7689
/* This function is called by the parser after a @synthesize
7690
   expression is parsed.  'location' is the location of the
7691
   @synthesize expression, and 'property_and_ivar_list' is a chained
7692
   list of the property and ivar names.  */
7693
void
7694
objc_add_synthesize_declaration (location_t location, tree property_and_ivar_list)
7695
{
7696
  tree interface, chain;
7697
 
7698
  if (flag_objc1_only)
7699
    error_at (input_location, "%<@synthesize%> is not available in Objective-C 1.0");
7700
 
7701
  if (property_and_ivar_list == error_mark_node)
7702
    return;
7703
 
7704
  if (!objc_implementation_context)
7705
    {
7706
      /* We can get here only in Objective-C; the Objective-C++ parser
7707
         detects the problem while parsing, outputs the error
7708
         "misplaced '@synthesize' Objective-C++ construct" and skips
7709
         the declaration.  */
7710
      error_at (location, "%<@synthesize%> not in @implementation context");
7711
      return;
7712
    }
7713
 
7714
  if (TREE_CODE (objc_implementation_context) == CATEGORY_IMPLEMENTATION_TYPE)
7715
    {
7716
      error_at (location, "%<@synthesize%> can not be used in categories");
7717
      return;
7718
    }
7719
 
7720
  interface = lookup_interface (CLASS_NAME (objc_implementation_context));
7721
  if (!interface)
7722
    {
7723
      /* I can't see how this could happen, but it is good as a safety check.  */
7724
      error_at (location,
7725
                "%<@synthesize%> requires the @interface of the class to be available");
7726
      return;
7727
    }
7728
 
7729
  /* Now, iterate over the properties and do each of them.  */
7730
  for (chain = property_and_ivar_list; chain; chain = TREE_CHAIN (chain))
7731
    {
7732
      objc_add_synthesize_declaration_for_property (location, interface, TREE_VALUE (chain),
7733
                                                    TREE_PURPOSE (chain));
7734
    }
7735
}
7736
 
7737
/* This function is a sub-routine of objc_add_dynamic_declaration.  It
7738
   is called for each property to mark as dynamic once we have
7739
   determined that the context is Ok.  */
7740
static void
7741
objc_add_dynamic_declaration_for_property (location_t location, tree interface,
7742
                                           tree property_name)
7743
{
7744
  /* Find the @property declaration.  */
7745
  tree property;
7746
 
7747
  /* Check that synthesize or dynamic has not already been used for
7748
     the same property.  */
7749
  for (property = IMPL_PROPERTY_DECL (objc_implementation_context); property; property = TREE_CHAIN (property))
7750
    if (PROPERTY_NAME (property) == property_name)
7751
      {
7752
        location_t original_location = DECL_SOURCE_LOCATION (property);
7753
 
7754
        if (PROPERTY_DYNAMIC (property))
7755
          error_at (location, "property %qs already specified in %<@dynamic%>",
7756
                    IDENTIFIER_POINTER (property_name));
7757
        else
7758
          error_at (location, "property %qs already specified in %<@synthesize%>",
7759
                    IDENTIFIER_POINTER (property_name));
7760
 
7761
        if (original_location != UNKNOWN_LOCATION)
7762
          inform (original_location, "originally specified here");
7763
        return;
7764
      }
7765
 
7766
  /* Check that the property is declared in the interface.  It could
7767
     also be declared in a superclass or protocol.  */
7768
  property = lookup_property (interface, property_name);
7769
 
7770
  if (!property)
7771
    {
7772
      error_at (location, "no declaration of property %qs found in the interface",
7773
                IDENTIFIER_POINTER (property_name));
7774
      return;
7775
    }
7776
  else
7777
    {
7778
      /* We have to copy the property, because we want to chain it to
7779
         the implementation context, and we want to store the source
7780
         location of the @synthesize, not of the original
7781
         @property.  */
7782
      property = copy_node (property);
7783
      DECL_SOURCE_LOCATION (property) = location;
7784
    }
7785
 
7786
  /* Note that a @dynamic (and only a @dynamic) always sets
7787
     PROPERTY_DYNAMIC to 1.  You can recognize a @dynamic by that.
7788
     (actually, as explained above, PROPERTY_DECL generated by
7789
     @property and associated with a @dynamic property are also marked
7790
     as PROPERTY_DYNAMIC).  */
7791
  PROPERTY_DYNAMIC (property) = 1;
7792
 
7793
  /* Add the property to the list of properties for current implementation. */
7794
  TREE_CHAIN (property) = IMPL_PROPERTY_DECL (objc_implementation_context);
7795
  IMPL_PROPERTY_DECL (objc_implementation_context) = property;
7796
}
7797
 
7798
/* This function is called by the parser after a @dynamic expression
7799
   is parsed.  'location' is the location of the @dynamic expression,
7800
   and 'property_list' is a chained list of all the property
7801
   names.  */
7802
void
7803
objc_add_dynamic_declaration (location_t location, tree property_list)
7804
{
7805
  tree interface, chain;
7806
 
7807
  if (flag_objc1_only)
7808
    error_at (input_location, "%<@dynamic%> is not available in Objective-C 1.0");
7809
 
7810
  if (property_list == error_mark_node)
7811
    return;
7812
 
7813
  if (!objc_implementation_context)
7814
    {
7815
      /* We can get here only in Objective-C; the Objective-C++ parser
7816
         detects the problem while parsing, outputs the error
7817
         "misplaced '@dynamic' Objective-C++ construct" and skips the
7818
         declaration.  */
7819
      error_at (location, "%<@dynamic%> not in @implementation context");
7820
      return;
7821
    }
7822
 
7823
  /* @dynamic is allowed in categories.  */
7824
  switch (TREE_CODE (objc_implementation_context))
7825
    {
7826
    case CLASS_IMPLEMENTATION_TYPE:
7827
      interface = lookup_interface (CLASS_NAME (objc_implementation_context));
7828
      break;
7829
    case CATEGORY_IMPLEMENTATION_TYPE:
7830
      interface = lookup_category (implementation_template,
7831
                                   CLASS_SUPER_NAME (objc_implementation_context));
7832
      break;
7833
    default:
7834
      gcc_unreachable ();
7835
    }
7836
 
7837
  if (!interface)
7838
    {
7839
      /* I can't see how this could happen, but it is good as a safety check.  */
7840
      error_at (location,
7841
                "%<@dynamic%> requires the @interface of the class to be available");
7842
      return;
7843
    }
7844
 
7845
  /* Now, iterate over the properties and do each of them.  */
7846
  for (chain = property_list; chain; chain = TREE_CHAIN (chain))
7847
    {
7848
      objc_add_dynamic_declaration_for_property (location, interface, TREE_VALUE (chain));
7849
    }
7850
}
7851
 
7852
/* Main routine to generate code/data for all the property information for
7853
   current implementation (class or category). CLASS is the interface where
7854
   ivars are declared.  CLASS_METHODS is where methods are found which
7855
   could be a class or a category depending on whether we are implementing
7856
   property of a class or a category.  */
7857
 
7858
static void
7859
objc_gen_property_data (tree klass, tree class_methods)
7860
{
7861
  tree x;
7862
 
7863
  for (x = IMPL_PROPERTY_DECL (objc_implementation_context); x; x = TREE_CHAIN (x))
7864
    {
7865
      /* @dynamic property - nothing to check or synthesize.  */
7866
      if (PROPERTY_DYNAMIC (x))
7867
        continue;
7868
 
7869
      /* @synthesize property - need to synthesize the accessors.  */
7870
      if (PROPERTY_IVAR_NAME (x))
7871
        {
7872
          objc_synthesize_getter (klass, class_methods, x);
7873
 
7874
          if (PROPERTY_READONLY (x) == 0)
7875
            objc_synthesize_setter (klass, class_methods, x);
7876
 
7877
          continue;
7878
        }
7879
 
7880
      gcc_unreachable ();
7881
    }
7882
}
7883
 
7884
/* This is called once we see the "@end" in an interface/implementation.  */
7885
 
7886
static void
7887
finish_class (tree klass)
7888
{
7889
  switch (TREE_CODE (klass))
7890
    {
7891
    case CLASS_IMPLEMENTATION_TYPE:
7892
      {
7893
        /* All metadata generation is done in runtime.generate_metadata().  */
7894
 
7895
        /* Generate what needed for property; setters, getters, etc. */
7896
        objc_gen_property_data (implementation_template, implementation_template);
7897
 
7898
        if (implementation_template != objc_implementation_context)
7899
          {
7900
            /* Ensure that all method listed in the interface contain bodies.  */
7901
            check_methods (CLASS_CLS_METHODS (implementation_template),
7902
                           objc_implementation_context, '+');
7903
            check_methods (CLASS_NST_METHODS (implementation_template),
7904
                           objc_implementation_context, '-');
7905
 
7906
            if (CLASS_PROTOCOL_LIST (implementation_template))
7907
              check_protocols (CLASS_PROTOCOL_LIST (implementation_template),
7908
                               "class",
7909
                               CLASS_NAME (objc_implementation_context));
7910
          }
7911
        break;
7912
      }
7913
    case CATEGORY_IMPLEMENTATION_TYPE:
7914
      {
7915
        tree category = lookup_category (implementation_template, CLASS_SUPER_NAME (klass));
7916
 
7917
        if (category)
7918
          {
7919
            /* Generate what needed for property; setters, getters, etc. */
7920
            objc_gen_property_data (implementation_template, category);
7921
 
7922
            /* Ensure all method listed in the interface contain bodies.  */
7923
            check_methods (CLASS_CLS_METHODS (category),
7924
                           objc_implementation_context, '+');
7925
            check_methods (CLASS_NST_METHODS (category),
7926
                           objc_implementation_context, '-');
7927
 
7928
            if (CLASS_PROTOCOL_LIST (category))
7929
              check_protocols (CLASS_PROTOCOL_LIST (category),
7930
                               "category",
7931
                               CLASS_SUPER_NAME (objc_implementation_context));
7932
          }
7933
        break;
7934
      }
7935
    case CLASS_INTERFACE_TYPE:
7936
    case CATEGORY_INTERFACE_TYPE:
7937
    case PROTOCOL_INTERFACE_TYPE:
7938
      {
7939
        /* Process properties of the class. */
7940
        tree x;
7941
        for (x = CLASS_PROPERTY_DECL (objc_interface_context); x; x = TREE_CHAIN (x))
7942
          {
7943
            /* Now we check that the appropriate getter is declared,
7944
               and if not, we declare one ourselves.  */
7945
            tree getter_decl = lookup_method (CLASS_NST_METHODS (klass),
7946
                                              PROPERTY_GETTER_NAME (x));
7947
 
7948
            if (getter_decl)
7949
              {
7950
                /* TODO: Check that the declaration is consistent with the property.  */
7951
                ;
7952
              }
7953
            else
7954
              {
7955
                /* Generate an instance method declaration for the
7956
                   getter; for example "- (id) name;".  In general it
7957
                   will be of the form
7958
                   -(type)property_getter_name;  */
7959
                tree rettype = build_tree_list (NULL_TREE, TREE_TYPE (x));
7960
                getter_decl = build_method_decl (INSTANCE_METHOD_DECL,
7961
                                                 rettype, PROPERTY_GETTER_NAME (x),
7962
                                                 NULL_TREE, false);
7963
                if (PROPERTY_OPTIONAL (x))
7964
                  objc_add_method (objc_interface_context, getter_decl, false, true);
7965
                else
7966
                  objc_add_method (objc_interface_context, getter_decl, false, false);
7967
                TREE_DEPRECATED (getter_decl) = TREE_DEPRECATED (x);
7968
                METHOD_PROPERTY_CONTEXT (getter_decl) = x;
7969
              }
7970
 
7971
            if (PROPERTY_READONLY (x) == 0)
7972
              {
7973
                /* Now we check that the appropriate setter is declared,
7974
                   and if not, we declare on ourselves.  */
7975
                tree setter_decl = lookup_method (CLASS_NST_METHODS (klass),
7976
                                                  PROPERTY_SETTER_NAME (x));
7977
 
7978
                if (setter_decl)
7979
                  {
7980
                    /* TODO: Check that the declaration is consistent with the property.  */
7981
                    ;
7982
                  }
7983
                else
7984
                  {
7985
                    /* The setter name is something like 'setName:'.
7986
                       We need the substring 'setName' to build the
7987
                       method declaration due to how the declaration
7988
                       works.  TODO: build_method_decl() will then
7989
                       generate back 'setName:' from 'setName'; it
7990
                       would be more efficient to hook into there.  */
7991
                    const char *full_setter_name = IDENTIFIER_POINTER (PROPERTY_SETTER_NAME (x));
7992
                    size_t length = strlen (full_setter_name);
7993
                    char *setter_name = (char *) alloca (length);
7994
                    tree ret_type, selector, arg_type, arg_name;
7995
 
7996
                    strcpy (setter_name, full_setter_name);
7997
                    setter_name[length - 1] = '\0';
7998
                    ret_type = build_tree_list (NULL_TREE, void_type_node);
7999
                    arg_type = build_tree_list (NULL_TREE, TREE_TYPE (x));
8000
                    arg_name = get_identifier ("_value");
8001
                    selector = objc_build_keyword_decl (get_identifier (setter_name),
8002
                                                        arg_type, arg_name, NULL);
8003
                    setter_decl = build_method_decl (INSTANCE_METHOD_DECL,
8004
                                                     ret_type, selector,
8005
                                                     build_tree_list (NULL_TREE, NULL_TREE),
8006
                                                     false);
8007
                    if (PROPERTY_OPTIONAL (x))
8008
                      objc_add_method (objc_interface_context, setter_decl, false, true);
8009
                    else
8010
                      objc_add_method (objc_interface_context, setter_decl, false, false);
8011
                    TREE_DEPRECATED (setter_decl) = TREE_DEPRECATED (x);
8012
                    METHOD_PROPERTY_CONTEXT (setter_decl) = x;
8013
                  }
8014
              }
8015
          }
8016
        break;
8017
      }
8018
    default:
8019
      gcc_unreachable ();
8020
      break;
8021
    }
8022
}
8023
 
8024
static tree
8025
add_protocol (tree protocol)
8026
{
8027
  /* Put protocol on list in reverse order.  */
8028
  TREE_CHAIN (protocol) = protocol_chain;
8029
  protocol_chain = protocol;
8030
  return protocol_chain;
8031
}
8032
 
8033
/* Check that a protocol is defined, and, recursively, that all
8034
   protocols that this protocol conforms to are defined too.  */
8035
static void
8036
check_that_protocol_is_defined (tree protocol)
8037
{
8038
  if (!PROTOCOL_DEFINED (protocol))
8039
    warning (0, "definition of protocol %qE not found",
8040
             PROTOCOL_NAME (protocol));
8041
 
8042
  /* If the protocol itself conforms to other protocols, check them
8043
     too, recursively.  */
8044
  if (PROTOCOL_LIST (protocol))
8045
    {
8046
      tree p;
8047
 
8048
      for (p = PROTOCOL_LIST (protocol); p; p = TREE_CHAIN (p))
8049
        check_that_protocol_is_defined (TREE_VALUE (p));
8050
    }
8051
}
8052
 
8053
/* Looks up a protocol.  If 'warn_if_deprecated' is true, a warning is
8054
   emitted if the protocol is deprecated.  If 'definition_required' is
8055
   true, a warning is emitted if a full @protocol definition has not
8056
   been seen.  */
8057
static tree
8058
lookup_protocol (tree ident, bool warn_if_deprecated, bool definition_required)
8059
{
8060
  tree chain;
8061
 
8062
  for (chain = protocol_chain; chain; chain = TREE_CHAIN (chain))
8063
    if (ident == PROTOCOL_NAME (chain))
8064
      {
8065
        if (warn_if_deprecated && TREE_DEPRECATED (chain))
8066
          {
8067
            /* It would be nice to use warn_deprecated_use() here, but
8068
               we are using TREE_CHAIN (which is supposed to be the
8069
               TYPE_STUB_DECL for a TYPE) for something different.  */
8070
            warning (OPT_Wdeprecated_declarations, "protocol %qE is deprecated",
8071
                     PROTOCOL_NAME (chain));
8072
          }
8073
 
8074
        if (definition_required)
8075
          check_that_protocol_is_defined (chain);
8076
 
8077
        return chain;
8078
      }
8079
 
8080
  return NULL_TREE;
8081
}
8082
 
8083
/* This function forward declares the protocols named by NAMES.  If
8084
   they are already declared or defined, the function has no effect.  */
8085
 
8086
void
8087
objc_declare_protocol (tree name, tree attributes)
8088
{
8089
  bool deprecated = false;
8090
 
8091
#ifdef OBJCPLUS
8092
  if (current_namespace != global_namespace) {
8093
    error ("Objective-C declarations may only appear in global scope");
8094
  }
8095
#endif /* OBJCPLUS */
8096
 
8097
  /* Determine if 'deprecated', the only attribute we recognize for
8098
     protocols, was used.  Ignore all other attributes.  */
8099
  if (attributes)
8100
    {
8101
      tree attribute;
8102
      for (attribute = attributes; attribute; attribute = TREE_CHAIN (attribute))
8103
        {
8104
          tree name = TREE_PURPOSE (attribute);
8105
 
8106
          if (is_attribute_p  ("deprecated", name))
8107
            deprecated = true;
8108
          else
8109
            warning (OPT_Wattributes, "%qE attribute directive ignored", name);
8110
        }
8111
    }
8112
 
8113
  if (lookup_protocol (name, /* warn if deprecated */ false,
8114
                       /* definition_required */ false) == NULL_TREE)
8115
    {
8116
      tree protocol = make_node (PROTOCOL_INTERFACE_TYPE);
8117
 
8118
      TYPE_LANG_SLOT_1 (protocol)
8119
        = make_tree_vec (PROTOCOL_LANG_SLOT_ELTS);
8120
      PROTOCOL_NAME (protocol) = name;
8121
      PROTOCOL_LIST (protocol) = NULL_TREE;
8122
      add_protocol (protocol);
8123
      PROTOCOL_DEFINED (protocol) = 0;
8124
      PROTOCOL_FORWARD_DECL (protocol) = NULL_TREE;
8125
 
8126
      if (attributes)
8127
        {
8128
          /* TODO: Do we need to store the attributes here ? */
8129
          TYPE_ATTRIBUTES (protocol) = attributes;
8130
          if (deprecated)
8131
            TREE_DEPRECATED (protocol) = 1;
8132
        }
8133
    }
8134
}
8135
 
8136
static tree
8137
start_protocol (enum tree_code code, tree name, tree list, tree attributes)
8138
{
8139
  tree protocol;
8140
  bool deprecated = false;
8141
 
8142
#ifdef OBJCPLUS
8143
  if (current_namespace != global_namespace) {
8144
    error ("Objective-C declarations may only appear in global scope");
8145
  }
8146
#endif /* OBJCPLUS */
8147
 
8148
  /* Determine if 'deprecated', the only attribute we recognize for
8149
     protocols, was used.  Ignore all other attributes.  */
8150
  if (attributes)
8151
    {
8152
      tree attribute;
8153
      for (attribute = attributes; attribute; attribute = TREE_CHAIN (attribute))
8154
        {
8155
          tree name = TREE_PURPOSE (attribute);
8156
 
8157
          if (is_attribute_p  ("deprecated", name))
8158
            deprecated = true;
8159
          else
8160
            warning (OPT_Wattributes, "%qE attribute directive ignored", name);
8161
        }
8162
    }
8163
 
8164
  protocol = lookup_protocol (name, /* warn_if_deprecated */ false,
8165
                              /* definition_required */ false);
8166
 
8167
  if (!protocol)
8168
    {
8169
      protocol = make_node (code);
8170
      TYPE_LANG_SLOT_1 (protocol) = make_tree_vec (PROTOCOL_LANG_SLOT_ELTS);
8171
 
8172
      PROTOCOL_NAME (protocol) = name;
8173
      PROTOCOL_LIST (protocol) = lookup_and_install_protocols (list, /* definition_required */ false);
8174
      add_protocol (protocol);
8175
      PROTOCOL_DEFINED (protocol) = 1;
8176
      PROTOCOL_FORWARD_DECL (protocol) = NULL_TREE;
8177
 
8178
      check_protocol_recursively (protocol, list);
8179
    }
8180
  else if (! PROTOCOL_DEFINED (protocol))
8181
    {
8182
      PROTOCOL_DEFINED (protocol) = 1;
8183
      PROTOCOL_LIST (protocol) = lookup_and_install_protocols (list, /* definition_required */ false);
8184
 
8185
      check_protocol_recursively (protocol, list);
8186
    }
8187
  else
8188
    {
8189
      warning (0, "duplicate declaration for protocol %qE",
8190
               name);
8191
    }
8192
 
8193
  if (attributes)
8194
    {
8195
      TYPE_ATTRIBUTES (protocol) = attributes;
8196
      if (deprecated)
8197
        TREE_DEPRECATED (protocol) = 1;
8198
    }
8199
 
8200
  return protocol;
8201
}
8202
 
8203
/* Decay array and function parameters into pointers.  */
8204
 
8205
static tree
8206
objc_decay_parm_type (tree type)
8207
{
8208
  if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == FUNCTION_TYPE)
8209
    type = build_pointer_type (TREE_CODE (type) == ARRAY_TYPE
8210
                               ? TREE_TYPE (type)
8211
                               : type);
8212
 
8213
  return type;
8214
}
8215
 
8216
static GTY(()) tree objc_parmlist = NULL_TREE;
8217
 
8218
/* Append PARM to a list of formal parameters of a method, making a necessary
8219
   array-to-pointer adjustment along the way.  */
8220
 
8221
void
8222
objc_push_parm (tree parm)
8223
{
8224
  tree type;
8225
 
8226
  if (TREE_TYPE (parm) == error_mark_node)
8227
    {
8228
      objc_parmlist = chainon (objc_parmlist, parm);
8229
      return;
8230
    }
8231
 
8232
  /* Decay arrays and functions into pointers.  */
8233
  type = objc_decay_parm_type (TREE_TYPE (parm));
8234
 
8235
  /* If the parameter type has been decayed, a new PARM_DECL needs to be
8236
     built as well.  */
8237
  if (type != TREE_TYPE (parm))
8238
    parm = build_decl (input_location, PARM_DECL, DECL_NAME (parm), type);
8239
 
8240
  DECL_ARG_TYPE (parm)
8241
    = lang_hooks.types.type_promotes_to (TREE_TYPE (parm));
8242
 
8243
  /* Record constancy and volatility.  */
8244
  c_apply_type_quals_to_decl
8245
  ((TYPE_READONLY (TREE_TYPE (parm)) ? TYPE_QUAL_CONST : 0)
8246
   | (TYPE_RESTRICT (TREE_TYPE (parm)) ? TYPE_QUAL_RESTRICT : 0)
8247
   | (TYPE_VOLATILE (TREE_TYPE (parm)) ? TYPE_QUAL_VOLATILE : 0), parm);
8248
 
8249
  objc_parmlist = chainon (objc_parmlist, parm);
8250
}
8251
 
8252
/* Retrieve the formal parameter list constructed via preceding calls to
8253
   objc_push_parm().  */
8254
 
8255
#ifdef OBJCPLUS
8256
tree
8257
objc_get_parm_info (int have_ellipsis ATTRIBUTE_UNUSED,
8258
                    tree expr ATTRIBUTE_UNUSED)
8259
{
8260
  tree parm_info = objc_parmlist;
8261
  objc_parmlist = NULL_TREE;
8262
 
8263
  return parm_info;
8264
}
8265
#else
8266
struct c_arg_info *
8267
objc_get_parm_info (int have_ellipsis, tree expr)
8268
{
8269
  tree parm_info = objc_parmlist;
8270
  struct c_arg_info *arg_info;
8271
  /* The C front-end requires an elaborate song and dance at
8272
     this point.  */
8273
  push_scope ();
8274
  declare_parm_level ();
8275
  while (parm_info)
8276
    {
8277
      tree next = DECL_CHAIN (parm_info);
8278
 
8279
      DECL_CHAIN (parm_info) = NULL_TREE;
8280
      parm_info = pushdecl (parm_info);
8281
      finish_decl (parm_info, input_location, NULL_TREE, NULL_TREE, NULL_TREE);
8282
      parm_info = next;
8283
    }
8284
  arg_info = get_parm_info (have_ellipsis, expr);
8285
  pop_scope ();
8286
  objc_parmlist = NULL_TREE;
8287
  return arg_info;
8288
}
8289
#endif
8290
 
8291
/* Synthesize the formal parameters 'id self' and 'SEL _cmd' needed for ObjC
8292
   method definitions.  In the case of instance methods, we can be more
8293
   specific as to the type of 'self'.  */
8294
 
8295
static void
8296
synth_self_and_ucmd_args (void)
8297
{
8298
  tree self_type;
8299
 
8300
  if (objc_method_context
8301
      && TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL)
8302
    self_type = objc_instance_type;
8303
  else
8304
    /* Really a `struct objc_class *'. However, we allow people to
8305
       assign to self, which changes its type midstream.  */
8306
    self_type = objc_object_type;
8307
 
8308
  /* id self; */
8309
  objc_push_parm (build_decl (input_location,
8310
                              PARM_DECL, self_id, self_type));
8311
 
8312
  /* SEL _cmd; */
8313
  objc_push_parm (build_decl (input_location,
8314
                              PARM_DECL, ucmd_id, objc_selector_type));
8315
}
8316
 
8317
/* Transform an Objective-C method definition into a static C function
8318
   definition, synthesizing the first two arguments, "self" and "_cmd",
8319
   in the process.  EXPR is NULL or an expression that needs to be
8320
   evaluated for the side effects of array size expressions in the
8321
   parameters.  */
8322
 
8323
static void
8324
start_method_def (tree method, tree expr)
8325
{
8326
  tree parmlist;
8327
#ifdef OBJCPLUS
8328
  tree parm_info;
8329
#else
8330
  struct c_arg_info *parm_info;
8331
#endif
8332
  int have_ellipsis = 0;
8333
 
8334
  /* If we are defining a "dealloc" method in a non-root class, we
8335
     will need to check if a [super dealloc] is missing, and warn if
8336
     it is.  */
8337
  if(CLASS_SUPER_NAME (objc_implementation_context)
8338
     && !strcmp ("dealloc", IDENTIFIER_POINTER (METHOD_SEL_NAME (method))))
8339
    should_call_super_dealloc = 1;
8340
  else
8341
    should_call_super_dealloc = 0;
8342
 
8343
  /* Required to implement _msgSuper.  */
8344
  objc_method_context = method;
8345
  UOBJC_SUPER_decl = NULL_TREE;
8346
 
8347
  /* Generate prototype declarations for arguments..."new-style".  */
8348
  synth_self_and_ucmd_args ();
8349
 
8350
  /* Generate argument declarations if a keyword_decl.  */
8351
  parmlist = METHOD_SEL_ARGS (method);
8352
  while (parmlist)
8353
    {
8354
      /* parmlist is a KEYWORD_DECL.  */
8355
      tree type = TREE_VALUE (TREE_TYPE (parmlist));
8356
      tree parm;
8357
 
8358
      parm = build_decl (input_location,
8359
                         PARM_DECL, KEYWORD_ARG_NAME (parmlist), type);
8360
      decl_attributes (&parm, DECL_ATTRIBUTES (parmlist), 0);
8361
      objc_push_parm (parm);
8362
      parmlist = DECL_CHAIN (parmlist);
8363
    }
8364
 
8365
  if (METHOD_ADD_ARGS (method))
8366
    {
8367
      tree akey;
8368
 
8369
      for (akey = TREE_CHAIN (METHOD_ADD_ARGS (method));
8370
           akey; akey = TREE_CHAIN (akey))
8371
        {
8372
          objc_push_parm (TREE_VALUE (akey));
8373
        }
8374
 
8375
      if (METHOD_ADD_ARGS_ELLIPSIS_P (method))
8376
        have_ellipsis = 1;
8377
    }
8378
 
8379
  parm_info = objc_get_parm_info (have_ellipsis, expr);
8380
 
8381
  really_start_method (objc_method_context, parm_info);
8382
}
8383
 
8384
/* Return 1 if TYPE1 is equivalent to TYPE2 for purposes of method
8385
   overloading.  */
8386
static int
8387
objc_types_are_equivalent (tree type1, tree type2)
8388
{
8389
  if (type1 == type2)
8390
    return 1;
8391
 
8392
  /* Strip away indirections.  */
8393
  while ((TREE_CODE (type1) == ARRAY_TYPE || TREE_CODE (type1) == POINTER_TYPE)
8394
         && (TREE_CODE (type1) == TREE_CODE (type2)))
8395
    type1 = TREE_TYPE (type1), type2 = TREE_TYPE (type2);
8396
  if (TYPE_MAIN_VARIANT (type1) != TYPE_MAIN_VARIANT (type2))
8397
    return 0;
8398
 
8399
  /* Compare the protocol lists.  */
8400
  type1 = (TYPE_HAS_OBJC_INFO (type1)
8401
           ? TYPE_OBJC_PROTOCOL_LIST (type1)
8402
           : NULL_TREE);
8403
  type2 = (TYPE_HAS_OBJC_INFO (type2)
8404
           ? TYPE_OBJC_PROTOCOL_LIST (type2)
8405
           : NULL_TREE);
8406
 
8407
  /* If there are no protocols (most common case), the types are
8408
     identical.  */
8409
  if (type1 == NULL_TREE && type2 == NULL_TREE)
8410
    return 1;
8411
 
8412
  /* If one has protocols, and the other one hasn't, they are not
8413
     identical.  */
8414
  if ((type1 == NULL_TREE && type2 != NULL_TREE)
8415
      || (type1 != NULL_TREE && type2 == NULL_TREE))
8416
    return 0;
8417
  else
8418
    {
8419
      /* Else, both have protocols, and we need to do the full
8420
         comparison.  It is possible that either type1 or type2
8421
         contain some duplicate protocols in the list, so we can't
8422
         even just compare list_length as a first check.  */
8423
      tree t;
8424
 
8425
      for (t = type2; t; t = TREE_CHAIN (t))
8426
        if (!lookup_protocol_in_reflist (type1, TREE_VALUE (t)))
8427
          return 0;
8428
 
8429
      for (t = type1; t; t = TREE_CHAIN (t))
8430
        if (!lookup_protocol_in_reflist (type2, TREE_VALUE (t)))
8431
          return 0;
8432
 
8433
      return 1;
8434
    }
8435
}
8436
 
8437
/* Return 1 if TYPE1 has the same size and alignment as TYPE2.  */
8438
 
8439
static int
8440
objc_types_share_size_and_alignment (tree type1, tree type2)
8441
{
8442
  return (simple_cst_equal (TYPE_SIZE (type1), TYPE_SIZE (type2))
8443
          && TYPE_ALIGN (type1) == TYPE_ALIGN (type2));
8444
}
8445
 
8446
/* Return 1 if PROTO1 is equivalent to PROTO2
8447
   for purposes of method overloading.  Ordinarily, the type signatures
8448
   should match up exactly, unless STRICT is zero, in which case we
8449
   shall allow differences in which the size and alignment of a type
8450
   is the same.  */
8451
 
8452
static int
8453
comp_proto_with_proto (tree proto1, tree proto2, int strict)
8454
{
8455
  tree type1, type2;
8456
 
8457
  /* The following test is needed in case there are hashing
8458
     collisions.  */
8459
  if (METHOD_SEL_NAME (proto1) != METHOD_SEL_NAME (proto2))
8460
    return 0;
8461
 
8462
  /* Compare return types.  */
8463
  type1 = TREE_VALUE (TREE_TYPE (proto1));
8464
  type2 = TREE_VALUE (TREE_TYPE (proto2));
8465
 
8466
  if (!objc_types_are_equivalent (type1, type2)
8467
      && (strict || !objc_types_share_size_and_alignment (type1, type2)))
8468
    return 0;
8469
 
8470
  /* Compare argument types.  */
8471
 
8472
  /* The first argument (objc_object_type) is always the same, no need
8473
     to compare.  */
8474
 
8475
  /* The second argument (objc_selector_type) is always the same, no
8476
     need to compare.  */
8477
 
8478
  /* Compare the other arguments.  */
8479
  {
8480
    tree arg1, arg2;
8481
 
8482
    /* Compare METHOD_SEL_ARGS.  */
8483
    for (arg1 = METHOD_SEL_ARGS (proto1), arg2 = METHOD_SEL_ARGS (proto2);
8484
         arg1 && arg2;
8485
         arg1 = DECL_CHAIN (arg1), arg2 = DECL_CHAIN (arg2))
8486
      {
8487
        type1 = TREE_VALUE (TREE_TYPE (arg1));
8488
        type2 = TREE_VALUE (TREE_TYPE (arg2));
8489
 
8490
        /* FIXME: Do we need to decay argument types to compare them ?  */
8491
        type1 = objc_decay_parm_type (type1);
8492
        type2 = objc_decay_parm_type (type2);
8493
 
8494
        if (!objc_types_are_equivalent (type1, type2)
8495
            && (strict || !objc_types_share_size_and_alignment (type1, type2)))
8496
          return 0;
8497
      }
8498
 
8499
    /* The loop ends when arg1 or arg2 are NULL.  Make sure they are
8500
       both NULL.  */
8501
    if (arg1 != arg2)
8502
      return 0;
8503
 
8504
    /* Compare METHOD_ADD_ARGS.  */
8505
    if ((METHOD_ADD_ARGS (proto1) && !METHOD_ADD_ARGS (proto2))
8506
        || (METHOD_ADD_ARGS (proto2) && !METHOD_ADD_ARGS (proto1)))
8507
      return 0;
8508
 
8509
    if (METHOD_ADD_ARGS (proto1))
8510
      {
8511
        for (arg1 = TREE_CHAIN (METHOD_ADD_ARGS (proto1)), arg2 = TREE_CHAIN (METHOD_ADD_ARGS (proto2));
8512
             arg1 && arg2;
8513
             arg1 = TREE_CHAIN (arg1), arg2 = TREE_CHAIN (arg2))
8514
          {
8515
            type1 = TREE_TYPE (TREE_VALUE (arg1));
8516
            type2 = TREE_TYPE (TREE_VALUE (arg2));
8517
 
8518
            /* FIXME: Do we need to decay argument types to compare them ?  */
8519
            type1 = objc_decay_parm_type (type1);
8520
            type2 = objc_decay_parm_type (type2);
8521
 
8522
            if (!objc_types_are_equivalent (type1, type2)
8523
                && (strict || !objc_types_share_size_and_alignment (type1, type2)))
8524
              return 0;
8525
          }
8526
      }
8527
 
8528
    /* The loop ends when arg1 or arg2 are NULL.  Make sure they are
8529
       both NULL.  */
8530
    if (arg1 != arg2)
8531
      return 0;
8532
 
8533
    /* Compare METHOD_ADD_ARGS_ELLIPSIS_P.  */
8534
    if (METHOD_ADD_ARGS_ELLIPSIS_P (proto1) != METHOD_ADD_ARGS_ELLIPSIS_P (proto2))
8535
      return 0;
8536
  }
8537
 
8538
  /* Success.  */
8539
  return 1;
8540
}
8541
 
8542
/* This routine returns true if TYPE is a valid objc object type,
8543
   suitable for messaging; false otherwise.  If 'accept_class' is
8544
   'true', then a Class object is considered valid for messaging and
8545
   'true' is returned if 'type' refers to a Class.  If 'accept_class'
8546
   is 'false', then a Class object is not considered valid for
8547
   messaging and 'false' is returned in that case.  */
8548
 
8549
static bool
8550
objc_type_valid_for_messaging (tree type, bool accept_classes)
8551
{
8552
  if (!POINTER_TYPE_P (type))
8553
    return false;
8554
 
8555
  /* Remove the pointer indirection; don't remove more than one
8556
     otherwise we'd consider "NSObject **" a valid type for messaging,
8557
     which it isn't.  */
8558
  type = TREE_TYPE (type);
8559
 
8560
  if (TREE_CODE (type) != RECORD_TYPE)
8561
    return false;
8562
 
8563
  if (objc_is_object_id (type))
8564
    return true;
8565
 
8566
  if (objc_is_class_id (type))
8567
    return accept_classes;
8568
 
8569
  if (TYPE_HAS_OBJC_INFO (type))
8570
    return true;
8571
 
8572
  return false;
8573
}
8574
 
8575
void
8576
objc_start_function (tree name, tree type, tree attrs,
8577
#ifdef OBJCPLUS
8578
                     tree params
8579
#else
8580
                     struct c_arg_info *params
8581
#endif
8582
                     )
8583
{
8584
  tree fndecl = build_decl (input_location,
8585
                            FUNCTION_DECL, name, type);
8586
 
8587
#ifdef OBJCPLUS
8588
  DECL_ARGUMENTS (fndecl) = params;
8589
  DECL_INITIAL (fndecl) = error_mark_node;
8590
  DECL_EXTERNAL (fndecl) = 0;
8591
  TREE_STATIC (fndecl) = 1;
8592
  retrofit_lang_decl (fndecl);
8593
  cplus_decl_attributes (&fndecl, attrs, 0);
8594
  start_preparsed_function (fndecl, attrs, /*flags=*/SF_DEFAULT);
8595
#else
8596
  current_function_returns_value = 0;  /* Assume, until we see it does.  */
8597
  current_function_returns_null = 0;
8598
  decl_attributes (&fndecl, attrs, 0);
8599
  announce_function (fndecl);
8600
  DECL_INITIAL (fndecl) = error_mark_node;
8601
  DECL_EXTERNAL (fndecl) = 0;
8602
  TREE_STATIC (fndecl) = 1;
8603
  current_function_decl = pushdecl (fndecl);
8604
  push_scope ();
8605
  declare_parm_level ();
8606
  DECL_RESULT (current_function_decl)
8607
    = build_decl (input_location,
8608
                  RESULT_DECL, NULL_TREE,
8609
                  TREE_TYPE (TREE_TYPE (current_function_decl)));
8610
  DECL_ARTIFICIAL (DECL_RESULT (current_function_decl)) = 1;
8611
  DECL_IGNORED_P (DECL_RESULT (current_function_decl)) = 1;
8612
  start_fname_decls ();
8613
  store_parm_decls_from (params);
8614
#endif
8615
 
8616
  TREE_USED (current_function_decl) = 1;
8617
}
8618
 
8619
/* - Generate an identifier for the function. the format is "_n_cls",
8620
     where 1 <= n <= nMethods, and cls is the name the implementation we
8621
     are processing.
8622
   - Install the return type from the method declaration.
8623
   - If we have a prototype, check for type consistency.  */
8624
 
8625
static void
8626
really_start_method (tree method,
8627
#ifdef OBJCPLUS
8628
                     tree parmlist
8629
#else
8630
                     struct c_arg_info *parmlist
8631
#endif
8632
                     )
8633
{
8634
  tree ret_type, meth_type;
8635
  tree method_id;
8636
  const char *sel_name, *class_name, *cat_name;
8637
  char *buf;
8638
 
8639
  /* Synth the storage class & assemble the return type.  */
8640
  ret_type = TREE_VALUE (TREE_TYPE (method));
8641
 
8642
  sel_name = IDENTIFIER_POINTER (METHOD_SEL_NAME (method));
8643
  class_name = IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context));
8644
  cat_name = ((TREE_CODE (objc_implementation_context)
8645
               == CLASS_IMPLEMENTATION_TYPE)
8646
              ? NULL
8647
              : IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context)));
8648
  method_slot++;
8649
 
8650
  /* Make sure this is big enough for any plausible method label.  */
8651
  buf = (char *) alloca (50 + strlen (sel_name) + strlen (class_name)
8652
                         + (cat_name ? strlen (cat_name) : 0));
8653
 
8654
  OBJC_GEN_METHOD_LABEL (buf, TREE_CODE (method) == INSTANCE_METHOD_DECL,
8655
                         class_name, cat_name, sel_name, method_slot);
8656
 
8657
  method_id = get_identifier (buf);
8658
 
8659
#ifdef OBJCPLUS
8660
  /* Objective-C methods cannot be overloaded, so we don't need
8661
     the type encoding appended.  It looks bad anyway... */
8662
  push_lang_context (lang_name_c);
8663
#endif
8664
 
8665
  meth_type = build_function_type_for_method (ret_type, method, METHOD_DEF, 0);
8666
  objc_start_function (method_id, meth_type, NULL_TREE, parmlist);
8667
 
8668
  /* Set self_decl from the first argument.  */
8669
  self_decl = DECL_ARGUMENTS (current_function_decl);
8670
 
8671
  /* Suppress unused warnings.  */
8672
  TREE_USED (self_decl) = 1;
8673
  DECL_READ_P (self_decl) = 1;
8674
  TREE_USED (DECL_CHAIN (self_decl)) = 1;
8675
  DECL_READ_P (DECL_CHAIN (self_decl)) = 1;
8676
#ifdef OBJCPLUS
8677
  pop_lang_context ();
8678
#endif
8679
 
8680
  METHOD_DEFINITION (method) = current_function_decl;
8681
 
8682
  /* Check consistency...start_function, pushdecl, duplicate_decls.  */
8683
 
8684
  if (implementation_template != objc_implementation_context)
8685
    {
8686
      tree proto
8687
        = lookup_method_static (implementation_template,
8688
                                METHOD_SEL_NAME (method),
8689
                                ((TREE_CODE (method) == CLASS_METHOD_DECL)
8690
                                 | OBJC_LOOKUP_NO_SUPER));
8691
 
8692
      if (proto)
8693
        {
8694
          if (!comp_proto_with_proto (method, proto, 1))
8695
            {
8696
              bool type = TREE_CODE (method) == INSTANCE_METHOD_DECL;
8697
 
8698
              warning_at (DECL_SOURCE_LOCATION (method), 0,
8699
                          "conflicting types for %<%c%s%>",
8700
                          (type ? '-' : '+'),
8701
                          identifier_to_locale (gen_method_decl (method)));
8702
              inform (DECL_SOURCE_LOCATION (proto),
8703
                      "previous declaration of %<%c%s%>",
8704
                      (type ? '-' : '+'),
8705
                      identifier_to_locale (gen_method_decl (proto)));
8706
            }
8707
          else
8708
            {
8709
              /* If the method in the @interface was deprecated, mark
8710
                 the implemented method as deprecated too.  It should
8711
                 never be used for messaging (when the deprecation
8712
                 warnings are produced), but just in case.  */
8713
              if (TREE_DEPRECATED (proto))
8714
                TREE_DEPRECATED (method) = 1;
8715
 
8716
              /* If the method in the @interface was marked as
8717
                 'noreturn', mark the function implementing the method
8718
                 as 'noreturn' too.  */
8719
              TREE_THIS_VOLATILE (current_function_decl) = TREE_THIS_VOLATILE (proto);
8720
            }
8721
        }
8722
      else
8723
        {
8724
          /* We have a method @implementation even though we did not
8725
             see a corresponding @interface declaration (which is allowed
8726
             by Objective-C rules).  Go ahead and place the method in
8727
             the @interface anyway, so that message dispatch lookups
8728
             will see it.  */
8729
          tree interface = implementation_template;
8730
 
8731
          if (TREE_CODE (objc_implementation_context)
8732
              == CATEGORY_IMPLEMENTATION_TYPE)
8733
            interface = lookup_category
8734
                        (interface,
8735
                         CLASS_SUPER_NAME (objc_implementation_context));
8736
 
8737
          if (interface)
8738
            objc_add_method (interface, copy_node (method),
8739
                             TREE_CODE (method) == CLASS_METHOD_DECL,
8740
                             /* is_optional= */ false);
8741
        }
8742
    }
8743
}
8744
 
8745
static void *UOBJC_SUPER_scope = 0;
8746
 
8747
/* _n_Method (id self, SEL sel, ...)
8748
     {
8749
       struct objc_super _S;
8750
       _msgSuper ((_S.self = self, _S.class = _cls, &_S), ...);
8751
     }  */
8752
 
8753
static tree
8754
get_super_receiver (void)
8755
{
8756
  if (objc_method_context)
8757
    {
8758
      tree super_expr, super_expr_list, class_expr;
8759
      bool inst_meth;
8760
      if (!UOBJC_SUPER_decl)
8761
      {
8762
        UOBJC_SUPER_decl = build_decl (input_location,
8763
                                       VAR_DECL, get_identifier (TAG_SUPER),
8764
                                       objc_super_template);
8765
        /* This prevents `unused variable' warnings when compiling with -Wall.  */
8766
        TREE_USED (UOBJC_SUPER_decl) = 1;
8767
        DECL_READ_P (UOBJC_SUPER_decl) = 1;
8768
        lang_hooks.decls.pushdecl (UOBJC_SUPER_decl);
8769
        finish_decl (UOBJC_SUPER_decl, input_location, NULL_TREE, NULL_TREE,
8770
                     NULL_TREE);
8771
        UOBJC_SUPER_scope = objc_get_current_scope ();
8772
      }
8773
 
8774
      /* Set receiver to self.  */
8775
      super_expr = objc_build_component_ref (UOBJC_SUPER_decl, self_id);
8776
      super_expr = build_modify_expr (input_location, super_expr, NULL_TREE,
8777
                                      NOP_EXPR, input_location, self_decl,
8778
                                      NULL_TREE);
8779
      super_expr_list = super_expr;
8780
 
8781
      /* Set class to begin searching.  */
8782
      /* Get the ident for the superclass class field & build a ref to it.
8783
         ??? maybe we should just name the field the same for all runtimes.  */
8784
      super_expr = (*runtime.super_superclassfield_ident) ();
8785
      super_expr = objc_build_component_ref (UOBJC_SUPER_decl, super_expr);
8786
 
8787
      gcc_assert (imp_list->imp_context == objc_implementation_context
8788
                  && imp_list->imp_template == implementation_template);
8789
      inst_meth = (TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL);
8790
 
8791
      if (TREE_CODE (objc_implementation_context) == CLASS_IMPLEMENTATION_TYPE)
8792
        class_expr =  (*runtime.get_class_super_ref) (input_location,
8793
                                                      imp_list, inst_meth);
8794
      else
8795
        /* We have a category.  */
8796
        {
8797
          tree super_name = CLASS_SUPER_NAME (imp_list->imp_template);
8798
          tree super_class;
8799
 
8800
          /* Barf if super used in a category of a root object.  */
8801
          if (!super_name)
8802
            {
8803
              error ("no super class declared in interface for %qE",
8804
                     CLASS_NAME (imp_list->imp_template));
8805
              return error_mark_node;
8806
            }
8807
 
8808
          super_class = (*runtime.get_category_super_ref) (input_location,
8809
                                                           imp_list, inst_meth);
8810
          class_expr = build_c_cast (input_location,
8811
                                     TREE_TYPE (super_expr), super_class);
8812
        }
8813
 
8814
      super_expr = build_modify_expr (input_location, super_expr, NULL_TREE,
8815
                                      NOP_EXPR,
8816
                                      input_location, class_expr, NULL_TREE);
8817
 
8818
      super_expr_list = build_compound_expr (input_location,
8819
                                             super_expr_list, super_expr);
8820
 
8821
      super_expr = build_unary_op (input_location,
8822
                                   ADDR_EXPR, UOBJC_SUPER_decl, 0);
8823
      super_expr_list = build_compound_expr (input_location,
8824
                                             super_expr_list, super_expr);
8825
 
8826
      return super_expr_list;
8827
    }
8828
  else
8829
    {
8830
      error ("[super ...] must appear in a method context");
8831
      return error_mark_node;
8832
    }
8833
}
8834
 
8835
/* When exiting a scope, sever links to a 'super' declaration (if any)
8836
   therein contained.  */
8837
 
8838
void
8839
objc_clear_super_receiver (void)
8840
{
8841
  if (objc_method_context
8842
      && UOBJC_SUPER_scope == objc_get_current_scope ())
8843
    {
8844
      UOBJC_SUPER_decl = 0;
8845
      UOBJC_SUPER_scope = 0;
8846
    }
8847
}
8848
 
8849
void
8850
objc_finish_method_definition (tree fndecl)
8851
{
8852
  /* We cannot validly inline ObjC methods, at least not without a language
8853
     extension to declare that a method need not be dynamically
8854
     dispatched, so suppress all thoughts of doing so.  */
8855
  DECL_UNINLINABLE (fndecl) = 1;
8856
 
8857
#ifndef OBJCPLUS
8858
  /* The C++ front-end will have called finish_function() for us.  */
8859
  finish_function ();
8860
#endif
8861
 
8862
  METHOD_ENCODING (objc_method_context)
8863
    = encode_method_prototype (objc_method_context);
8864
 
8865
  /* Required to implement _msgSuper. This must be done AFTER finish_function,
8866
     since the optimizer may find "may be used before set" errors.  */
8867
  objc_method_context = NULL_TREE;
8868
 
8869
  if (should_call_super_dealloc)
8870
    warning (0, "method possibly missing a [super dealloc] call");
8871
}
8872
 
8873
/* Given a tree DECL node, produce a printable description of it in the given
8874
   buffer, overwriting the buffer.  */
8875
 
8876
static char *
8877
gen_declaration (tree decl)
8878
{
8879
  errbuf[0] = '\0';
8880
 
8881
  if (DECL_P (decl))
8882
    {
8883
      gen_type_name_0 (TREE_TYPE (decl));
8884
 
8885
      if (DECL_NAME (decl))
8886
        {
8887
          if (!POINTER_TYPE_P (TREE_TYPE (decl)))
8888
            strcat (errbuf, " ");
8889
 
8890
          strcat (errbuf, IDENTIFIER_POINTER (DECL_NAME (decl)));
8891
        }
8892
 
8893
      if (DECL_INITIAL (decl)
8894
          && TREE_CODE (DECL_INITIAL (decl)) == INTEGER_CST)
8895
        sprintf (errbuf + strlen (errbuf), ": " HOST_WIDE_INT_PRINT_DEC,
8896
                 TREE_INT_CST_LOW (DECL_INITIAL (decl)));
8897
    }
8898
 
8899
  return errbuf;
8900
}
8901
 
8902
/* Given a tree TYPE node, produce a printable description of it in the given
8903
   buffer, overwriting the buffer.  */
8904
 
8905
static char *
8906
gen_type_name_0 (tree type)
8907
{
8908
  tree orig = type, proto;
8909
 
8910
  if (TYPE_P (type) && TYPE_NAME (type))
8911
    type = TYPE_NAME (type);
8912
  else if (POINTER_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
8913
    {
8914
      tree inner = TREE_TYPE (type);
8915
 
8916
      while (TREE_CODE (inner) == ARRAY_TYPE)
8917
        inner = TREE_TYPE (inner);
8918
 
8919
      gen_type_name_0 (inner);
8920
 
8921
      if (!POINTER_TYPE_P (inner))
8922
        strcat (errbuf, " ");
8923
 
8924
      if (POINTER_TYPE_P (type))
8925
        strcat (errbuf, "*");
8926
      else
8927
        while (type != inner)
8928
          {
8929
            strcat (errbuf, "[");
8930
 
8931
            if (TYPE_DOMAIN (type))
8932
              {
8933
                char sz[20];
8934
 
8935
                sprintf (sz, HOST_WIDE_INT_PRINT_DEC,
8936
                         (TREE_INT_CST_LOW
8937
                          (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) + 1));
8938
                strcat (errbuf, sz);
8939
              }
8940
 
8941
            strcat (errbuf, "]");
8942
            type = TREE_TYPE (type);
8943
          }
8944
 
8945
      goto exit_function;
8946
    }
8947
 
8948
  if (TREE_CODE (type) == TYPE_DECL && DECL_NAME (type))
8949
    type = DECL_NAME (type);
8950
 
8951
  strcat (errbuf, TREE_CODE (type) == IDENTIFIER_NODE
8952
                  ? IDENTIFIER_POINTER (type)
8953
                  : "");
8954
 
8955
  /* For 'id' and 'Class', adopted protocols are stored in the pointee.  */
8956
  if (objc_is_id (orig))
8957
    orig = TREE_TYPE (orig);
8958
 
8959
  proto = TYPE_HAS_OBJC_INFO (orig) ? TYPE_OBJC_PROTOCOL_LIST (orig) : NULL_TREE;
8960
 
8961
  if (proto)
8962
    {
8963
      strcat (errbuf, " <");
8964
 
8965
      while (proto) {
8966
        strcat (errbuf,
8967
                IDENTIFIER_POINTER (PROTOCOL_NAME (TREE_VALUE (proto))));
8968
        proto = TREE_CHAIN (proto);
8969
        strcat (errbuf, proto ? ", " : ">");
8970
      }
8971
    }
8972
 
8973
 exit_function:
8974
  return errbuf;
8975
}
8976
 
8977
static char *
8978
gen_type_name (tree type)
8979
{
8980
  errbuf[0] = '\0';
8981
 
8982
  return gen_type_name_0 (type);
8983
}
8984
 
8985
/* Given a method tree, put a printable description into the given
8986
   buffer (overwriting) and return a pointer to the buffer.  */
8987
 
8988
static char *
8989
gen_method_decl (tree method)
8990
{
8991
  tree chain;
8992
 
8993
  strcpy (errbuf, "(");  /* NB: Do _not_ call strcat() here.  */
8994
  gen_type_name_0 (TREE_VALUE (TREE_TYPE (method)));
8995
  strcat (errbuf, ")");
8996
  chain = METHOD_SEL_ARGS (method);
8997
 
8998
  if (chain)
8999
    {
9000
      /* We have a chain of keyword_decls.  */
9001
      do
9002
        {
9003
          if (KEYWORD_KEY_NAME (chain))
9004
            strcat (errbuf, IDENTIFIER_POINTER (KEYWORD_KEY_NAME (chain)));
9005
 
9006
          strcat (errbuf, ":(");
9007
          gen_type_name_0 (TREE_VALUE (TREE_TYPE (chain)));
9008
          strcat (errbuf, ")");
9009
 
9010
          strcat (errbuf, IDENTIFIER_POINTER (KEYWORD_ARG_NAME (chain)));
9011
          if ((chain = DECL_CHAIN (chain)))
9012
            strcat (errbuf, " ");
9013
        }
9014
      while (chain);
9015
 
9016
      if (METHOD_ADD_ARGS (method))
9017
        {
9018
          chain = TREE_CHAIN (METHOD_ADD_ARGS (method));
9019
 
9020
          /* Know we have a chain of parm_decls.  */
9021
          while (chain)
9022
            {
9023
              strcat (errbuf, ", ");
9024
              gen_type_name_0 (TREE_TYPE (TREE_VALUE (chain)));
9025
              chain = TREE_CHAIN (chain);
9026
            }
9027
 
9028
          if (METHOD_ADD_ARGS_ELLIPSIS_P (method))
9029
            strcat (errbuf, ", ...");
9030
        }
9031
    }
9032
 
9033
  else
9034
    /* We have a unary selector.  */
9035
    strcat (errbuf, IDENTIFIER_POINTER (METHOD_SEL_NAME (method)));
9036
 
9037
  return errbuf;
9038
}
9039
 
9040
/* Debug info.  */
9041
 
9042
 
9043
/* Dump an @interface declaration of the supplied class CHAIN to the
9044
   supplied file FP.  Used to implement the -gen-decls option (which
9045
   prints out an @interface declaration of all classes compiled in
9046
   this run); potentially useful for debugging the compiler too.  */
9047
void
9048
dump_interface (FILE *fp, tree chain)
9049
{
9050
  /* FIXME: A heap overflow here whenever a method (or ivar)
9051
     declaration is so long that it doesn't fit in the buffer.  The
9052
     code and all the related functions should be rewritten to avoid
9053
     using fixed size buffers.  */
9054
  const char *my_name = IDENTIFIER_POINTER (CLASS_NAME (chain));
9055
  tree ivar_decls = CLASS_RAW_IVARS (chain);
9056
  tree nst_methods = CLASS_NST_METHODS (chain);
9057
  tree cls_methods = CLASS_CLS_METHODS (chain);
9058
 
9059
  fprintf (fp, "\n@interface %s", my_name);
9060
 
9061
  /* CLASS_SUPER_NAME is used to store the superclass name for
9062
     classes, and the category name for categories.  */
9063
  if (CLASS_SUPER_NAME (chain))
9064
    {
9065
      const char *name = IDENTIFIER_POINTER (CLASS_SUPER_NAME (chain));
9066
 
9067
      switch (TREE_CODE (chain))
9068
        {
9069
        case CATEGORY_IMPLEMENTATION_TYPE:
9070
        case CATEGORY_INTERFACE_TYPE:
9071
          fprintf (fp, " (%s)\n", name);
9072
          break;
9073
        default:
9074
          fprintf (fp, " : %s\n", name);
9075
          break;
9076
        }
9077
    }
9078
  else
9079
    fprintf (fp, "\n");
9080
 
9081
  /* FIXME - the following doesn't seem to work at the moment.  */
9082
  if (ivar_decls)
9083
    {
9084
      fprintf (fp, "{\n");
9085
      do
9086
        {
9087
          fprintf (fp, "\t%s;\n", gen_declaration (ivar_decls));
9088
          ivar_decls = TREE_CHAIN (ivar_decls);
9089
        }
9090
      while (ivar_decls);
9091
      fprintf (fp, "}\n");
9092
    }
9093
 
9094
  while (nst_methods)
9095
    {
9096
      fprintf (fp, "- %s;\n", gen_method_decl (nst_methods));
9097
      nst_methods = TREE_CHAIN (nst_methods);
9098
    }
9099
 
9100
  while (cls_methods)
9101
    {
9102
      fprintf (fp, "+ %s;\n", gen_method_decl (cls_methods));
9103
      cls_methods = TREE_CHAIN (cls_methods);
9104
    }
9105
 
9106
  fprintf (fp, "@end\n");
9107
}
9108
 
9109
#if 0
9110
/* Produce the pretty printing for an Objective-C method.  This is
9111
   currently unused, but could be handy while reorganizing the pretty
9112
   printing to be more robust.  */
9113
static const char *
9114
objc_pretty_print_method (bool is_class_method,
9115
                          const char *class_name,
9116
                          const char *category_name,
9117
                          const char *selector)
9118
{
9119
  if (category_name)
9120
    {
9121
      char *result = XNEWVEC (char, strlen (class_name) + strlen (category_name)
9122
                              + strlen (selector) + 7);
9123
 
9124
      if (is_class_method)
9125
        sprintf (result, "+[%s(%s) %s]", class_name, category_name, selector);
9126
      else
9127
        sprintf (result, "-[%s(%s) %s]", class_name, category_name, selector);
9128
 
9129
      return result;
9130
    }
9131
  else
9132
    {
9133
      char *result = XNEWVEC (char, strlen (class_name)
9134
                              + strlen (selector) + 5);
9135
 
9136
      if (is_class_method)
9137
        sprintf (result, "+[%s %s]", class_name, selector);
9138
      else
9139
        sprintf (result, "-[%s %s]", class_name, selector);
9140
 
9141
      return result;
9142
    }
9143
}
9144
#endif
9145
 
9146
/* Demangle function for Objective-C.  Attempt to demangle the
9147
   function name associated with a method (eg, going from
9148
   "_i_NSObject__class" to "-[NSObject class]"); usually for the
9149
   purpose of pretty printing or error messages.  Return the demangled
9150
   name, or NULL if the string is not an Objective-C mangled method
9151
   name.
9152
 
9153
   Because of how the mangling is done, any method that has a '_' in
9154
   its original name is at risk of being demangled incorrectly.  In
9155
   some cases there are multiple valid ways to demangle a method name
9156
   and there is no way we can decide.
9157
 
9158
   TODO: objc_demangle() can't always get it right; the right way to
9159
   get this correct for all method names would be to store the
9160
   Objective-C method name somewhere in the function decl.  Then,
9161
   there is no demangling to do; we'd just pull the method name out of
9162
   the decl.  As an additional bonus, when printing error messages we
9163
   could check for such a method name, and if we find it, we know the
9164
   function is actually an Objective-C method and we could print error
9165
   messages saying "In method '+[NSObject class]" instead of "In
9166
   function '+[NSObject class]" as we do now.  */
9167
static const char *
9168
objc_demangle (const char *mangled)
9169
{
9170
  char *demangled, *cp;
9171
 
9172
  /* First of all, if the name is too short it can't be an Objective-C
9173
     mangled method name.  */
9174
  if (mangled[0] == '\0' || mangled[1] == '\0' || mangled[2] == '\0')
9175
    return NULL;
9176
 
9177
  /* If the name looks like an already demangled one, return it
9178
     unchanged.  This should only happen on Darwin, where method names
9179
     are mangled differently into a pretty-print form (such as
9180
     '+[NSObject class]', see darwin.h).  In that case, demangling is
9181
     a no-op, but we need to return the demangled name if it was an
9182
     ObjC one, and return NULL if not.  We should be safe as no C/C++
9183
     function can start with "-[" or "+[".  */
9184
  if ((mangled[0] == '-' || mangled[0] == '+')
9185
      && (mangled[1] == '['))
9186
    return mangled;
9187
 
9188
  if (mangled[0] == '_' &&
9189
      (mangled[1] == 'i' || mangled[1] == 'c') &&
9190
      mangled[2] == '_')
9191
    {
9192
      cp = demangled = XNEWVEC (char, strlen(mangled) + 2);
9193
      if (mangled[1] == 'i')
9194
        *cp++ = '-';            /* for instance method */
9195
      else
9196
        *cp++ = '+';            /* for class method */
9197
      *cp++ = '[';              /* opening left brace */
9198
      strcpy(cp, mangled+3);    /* tack on the rest of the mangled name */
9199
      while (*cp && *cp == '_')
9200
        cp++;                   /* skip any initial underbars in class name */
9201
      cp = strchr(cp, '_');     /* find first non-initial underbar */
9202
      if (cp == NULL)
9203
        {
9204
          free(demangled);      /* not mangled name */
9205
          return NULL;
9206
        }
9207
      if (cp[1] == '_')  /* easy case: no category name */
9208
        {
9209
          *cp++ = ' ';            /* replace two '_' with one ' ' */
9210
          strcpy(cp, mangled + (cp - demangled) + 2);
9211
        }
9212
      else
9213
        {
9214
          *cp++ = '(';            /* less easy case: category name */
9215
          cp = strchr(cp, '_');
9216
          if (cp == 0)
9217
            {
9218
              free(demangled);    /* not mangled name */
9219
              return NULL;
9220
            }
9221
          *cp++ = ')';
9222
          *cp++ = ' ';            /* overwriting 1st char of method name... */
9223
          strcpy(cp, mangled + (cp - demangled)); /* get it back */
9224
        }
9225
      /* Now we have the method name.  We need to generally replace
9226
         '_' with ':' but trying to preserve '_' if it could only have
9227
         been in the mangled string because it was already in the
9228
         original name.  In cases where it's ambiguous, we assume that
9229
         any '_' originated from a ':'.  */
9230
 
9231
      /* Initial '_'s in method name can't have been generating by
9232
         converting ':'s.  Skip them.  */
9233
      while (*cp && *cp == '_')
9234
        cp++;
9235
 
9236
      /* If the method name does not end with '_', then it has no
9237
         arguments and there was no replacement of ':'s with '_'s
9238
         during mangling.  Check for that case, and skip any
9239
         replacement if so.  This at least guarantees that methods
9240
         with no arguments are always demangled correctly (unless the
9241
         original name ends with '_').  */
9242
      if (*(mangled + strlen (mangled) - 1) != '_')
9243
        {
9244
          /* Skip to the end.  */
9245
          for (; *cp; cp++)
9246
            ;
9247
        }
9248
      else
9249
        {
9250
          /* Replace remaining '_' with ':'.  This may get it wrong if
9251
             there were '_'s in the original name.  In most cases it
9252
             is impossible to disambiguate.  */
9253
          for (; *cp; cp++)
9254
            if (*cp == '_')
9255
              *cp = ':';
9256
        }
9257
      *cp++ = ']';              /* closing right brace */
9258
      *cp++ = 0;                /* string terminator */
9259
      return demangled;
9260
    }
9261
  else
9262
    return NULL;             /* not an objc mangled name */
9263
}
9264
 
9265
/* Try to pretty-print a decl.  If the 'decl' is an Objective-C
9266
   specific decl, return the printable name for it.  If not, return
9267
   NULL.  */
9268
const char *
9269
objc_maybe_printable_name (tree decl, int v ATTRIBUTE_UNUSED)
9270
{
9271
  switch (TREE_CODE (decl))
9272
    {
9273
    case FUNCTION_DECL:
9274
      return objc_demangle (IDENTIFIER_POINTER (DECL_NAME (decl)));
9275
      break;
9276
 
9277
      /* The following happens when we are printing a deprecation
9278
         warning for a method.  The warn_deprecation() will end up
9279
         trying to print the decl for INSTANCE_METHOD_DECL or
9280
         CLASS_METHOD_DECL.  It would be nice to be able to print
9281
         "-[NSObject autorelease] is deprecated", but to do that, we'd
9282
         need to store the class and method name in the method decl,
9283
         which we currently don't do.  For now, just return the name
9284
         of the method.  We don't return NULL, because that may
9285
         trigger further attempts to pretty-print the decl in C/C++,
9286
         but they wouldn't know how to pretty-print it.  */
9287
    case INSTANCE_METHOD_DECL:
9288
    case CLASS_METHOD_DECL:
9289
      return IDENTIFIER_POINTER (DECL_NAME (decl));
9290
      break;
9291
      /* This happens when printing a deprecation warning for a
9292
         property.  We may want to consider some sort of pretty
9293
         printing (eg, include the class name where it was declared
9294
         ?).  */
9295
    case PROPERTY_DECL:
9296
      return IDENTIFIER_POINTER (PROPERTY_NAME (decl));
9297
      break;
9298
    default:
9299
      return NULL;
9300
      break;
9301
    }
9302
}
9303
 
9304
/* Return a printable name for 'decl'.  This first tries
9305
   objc_maybe_printable_name(), and if that fails, it returns the name
9306
   in the decl.  This is used as LANG_HOOKS_DECL_PRINTABLE_NAME for
9307
   Objective-C; in Objective-C++, setting the hook is not enough
9308
   because lots of C++ Front-End code calls cxx_printable_name,
9309
   dump_decl and other C++ functions directly.  So instead we have
9310
   modified dump_decl to call objc_maybe_printable_name directly.  */
9311
const char *
9312
objc_printable_name (tree decl, int v)
9313
{
9314
  const char *demangled_name = objc_maybe_printable_name (decl, v);
9315
 
9316
  if (demangled_name != NULL)
9317
    return demangled_name;
9318
  else
9319
    return IDENTIFIER_POINTER (DECL_NAME (decl));
9320
}
9321
 
9322
/* Routine is called to issue diagnostic when reference to a private
9323
   ivar is made and no other variable with same name is found in
9324
   current scope.  */
9325
bool
9326
objc_diagnose_private_ivar (tree id)
9327
{
9328
  tree ivar;
9329
  if (!objc_method_context)
9330
    return false;
9331
  ivar = is_ivar (objc_ivar_chain, id);
9332
  if (ivar && is_private (ivar))
9333
    {
9334
      error ("instance variable %qs is declared private",
9335
             IDENTIFIER_POINTER (id));
9336
      return true;
9337
    }
9338
  return false;
9339
}
9340
 
9341
/* Look up ID as an instance variable.  OTHER contains the result of
9342
   the C or C++ lookup, which we may want to use instead.  */
9343
/* To use properties inside an instance method, use self.property.  */
9344
tree
9345
objc_lookup_ivar (tree other, tree id)
9346
{
9347
  tree ivar;
9348
 
9349
  /* If we are not inside of an ObjC method, ivar lookup makes no sense.  */
9350
  if (!objc_method_context)
9351
    return other;
9352
 
9353
  if (!strcmp (IDENTIFIER_POINTER (id), "super"))
9354
    /* We have a message to super.  */
9355
    return get_super_receiver ();
9356
 
9357
  /* In a class method, look up an instance variable only as a last
9358
     resort.  */
9359
  if (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL
9360
      && other && other != error_mark_node)
9361
    return other;
9362
 
9363
  /* Look up the ivar, but do not use it if it is not accessible.  */
9364
  ivar = is_ivar (objc_ivar_chain, id);
9365
 
9366
  if (!ivar || is_private (ivar))
9367
    return other;
9368
 
9369
  /* In an instance method, a local variable (or parameter) may hide the
9370
     instance variable.  */
9371
  if (TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL
9372
      && other && other != error_mark_node
9373
#ifdef OBJCPLUS
9374
      && CP_DECL_CONTEXT (other) != global_namespace)
9375
#else
9376
      && !DECL_FILE_SCOPE_P (other))
9377
#endif
9378
    {
9379
      warning (0, "local declaration of %qE hides instance variable", id);
9380
 
9381
      return other;
9382
    }
9383
 
9384
  /* At this point, we are either in an instance method with no obscuring
9385
     local definitions, or in a class method with no alternate definitions
9386
     at all.  */
9387
  return build_ivar_reference (id);
9388
}
9389
 
9390
/* Possibly rewrite a function CALL into an OBJ_TYPE_REF expression.  This
9391
   needs to be done if we are calling a function through a cast.  */
9392
 
9393
tree
9394
objc_rewrite_function_call (tree function, tree first_param)
9395
{
9396
  if (TREE_CODE (function) == NOP_EXPR
9397
      && TREE_CODE (TREE_OPERAND (function, 0)) == ADDR_EXPR
9398
      && TREE_CODE (TREE_OPERAND (TREE_OPERAND (function, 0), 0))
9399
         == FUNCTION_DECL)
9400
    {
9401
      function = build3 (OBJ_TYPE_REF, TREE_TYPE (function),
9402
                         TREE_OPERAND (function, 0),
9403
                         first_param, size_zero_node);
9404
    }
9405
 
9406
  return function;
9407
}
9408
 
9409
/* This is called to "gimplify" a PROPERTY_REF node.  It builds the
9410
   corresponding 'getter' function call.  Note that we assume the
9411
   PROPERTY_REF to be valid since we generated it while parsing.  */
9412
static void
9413
objc_gimplify_property_ref (tree *expr_p)
9414
{
9415
  tree getter = PROPERTY_REF_GETTER_CALL (*expr_p);
9416
  tree call_exp;
9417
 
9418
  if (getter == NULL_TREE)
9419
    {
9420
      tree property_decl = PROPERTY_REF_PROPERTY_DECL (*expr_p);
9421
      /* This can happen if DECL_ARTIFICIAL (*expr_p), but
9422
         should be impossible for real properties, which always
9423
         have a getter.  */
9424
      error_at (EXPR_LOCATION (*expr_p), "no %qs getter found",
9425
                IDENTIFIER_POINTER (PROPERTY_NAME (property_decl)));
9426
      /* Try to recover from the error to prevent an ICE.  We take
9427
         zero and cast it to the type of the property.  */
9428
      *expr_p = convert (TREE_TYPE (property_decl),
9429
                         integer_zero_node);
9430
      return;
9431
    }
9432
 
9433
  if (PROPERTY_REF_DEPRECATED_GETTER (*expr_p))
9434
    {
9435
      /* PROPERTY_REF_DEPRECATED_GETTER contains the method prototype
9436
         that is deprecated.  */
9437
      warn_deprecated_use (PROPERTY_REF_DEPRECATED_GETTER (*expr_p),
9438
                           NULL_TREE);
9439
    }
9440
 
9441
  call_exp = getter;
9442
#ifdef OBJCPLUS
9443
  /* In C++, a getter which returns an aggregate value results in a
9444
     target_expr which initializes a temporary to the call
9445
     expression.  */
9446
  if (TREE_CODE (getter) == TARGET_EXPR)
9447
    {
9448
      gcc_assert (MAYBE_CLASS_TYPE_P (TREE_TYPE (getter)));
9449
      gcc_assert (TREE_CODE (TREE_OPERAND (getter, 0)) == VAR_DECL);
9450
      call_exp = TREE_OPERAND (getter, 1);
9451
    }
9452
#endif
9453
  gcc_assert (TREE_CODE (call_exp) == CALL_EXPR);
9454
 
9455
  *expr_p = call_exp;
9456
}
9457
 
9458
/* This is called when "gimplifying" the trees.  We need to gimplify
9459
   the Objective-C/Objective-C++ specific trees, then hand over the
9460
   process to C/C++.  */
9461
int
9462
objc_gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
9463
{
9464
  enum tree_code code = TREE_CODE (*expr_p);
9465
  switch (code)
9466
    {
9467
      /* Look for the special case of OBJC_TYPE_REF with the address
9468
         of a function in OBJ_TYPE_REF_EXPR (presumably objc_msgSend
9469
         or one of its cousins).  */
9470
    case OBJ_TYPE_REF:
9471
      if (TREE_CODE (OBJ_TYPE_REF_EXPR (*expr_p)) == ADDR_EXPR
9472
          && TREE_CODE (TREE_OPERAND (OBJ_TYPE_REF_EXPR (*expr_p), 0))
9473
          == FUNCTION_DECL)
9474
        {
9475
          enum gimplify_status r0, r1;
9476
 
9477
          /* Postincrements in OBJ_TYPE_REF_OBJECT don't affect the
9478
             value of the OBJ_TYPE_REF, so force them to be emitted
9479
             during subexpression evaluation rather than after the
9480
             OBJ_TYPE_REF. This permits objc_msgSend calls in
9481
             Objective C to use direct rather than indirect calls when
9482
             the object expression has a postincrement.  */
9483
          r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p, NULL,
9484
                              is_gimple_val, fb_rvalue);
9485
          r1 = gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p), pre_p, post_p,
9486
                              is_gimple_val, fb_rvalue);
9487
 
9488
          return MIN (r0, r1);
9489
        }
9490
      break;
9491
    case PROPERTY_REF:
9492
      objc_gimplify_property_ref (expr_p);
9493
      /* Do not return yet; let C/C++ gimplify the resulting expression.  */
9494
      break;
9495
    default:
9496
      break;
9497
    }
9498
 
9499
#ifdef OBJCPLUS
9500
  return (enum gimplify_status) cp_gimplify_expr (expr_p, pre_p, post_p);
9501
#else
9502
  return (enum gimplify_status) c_gimplify_expr (expr_p, pre_p, post_p);
9503
#endif
9504
}
9505
 
9506
/* --- FAST ENUMERATION --- */
9507
/* Begin code generation for fast enumeration (foreach) ... */
9508
 
9509
/* Defines
9510
 
9511
  struct __objcFastEnumerationState
9512
   {
9513
     unsigned long state;
9514
     id            *itemsPtr;
9515
     unsigned long *mutationsPtr;
9516
     unsigned long extra[5];
9517
   };
9518
 
9519
   Confusingly enough, NSFastEnumeration is then defined by libraries
9520
   to be the same structure.
9521
*/
9522
 
9523
static void
9524
build_fast_enumeration_state_template (void)
9525
{
9526
  tree decls, *chain = NULL;
9527
 
9528
  /* { */
9529
  objc_fast_enumeration_state_template = objc_start_struct (get_identifier
9530
                                                            (TAG_FAST_ENUMERATION_STATE));
9531
 
9532
  /* unsigned long state; */
9533
  decls = add_field_decl (long_unsigned_type_node, "state", &chain);
9534
 
9535
  /* id            *itemsPtr; */
9536
  add_field_decl (build_pointer_type (objc_object_type),
9537
                  "itemsPtr", &chain);
9538
 
9539
  /* unsigned long *mutationsPtr; */
9540
  add_field_decl (build_pointer_type (long_unsigned_type_node),
9541
                  "mutationsPtr", &chain);
9542
 
9543
  /* unsigned long extra[5]; */
9544
  add_field_decl (build_sized_array_type (long_unsigned_type_node, 5),
9545
                  "extra", &chain);
9546
 
9547
  /* } */
9548
  objc_finish_struct (objc_fast_enumeration_state_template, decls);
9549
}
9550
 
9551
/*
9552
  'objc_finish_foreach_loop()' generates the code for an Objective-C
9553
  foreach loop.  The 'location' argument is the location of the 'for'
9554
  that starts the loop.  The 'object_expression' is the expression of
9555
  the 'object' that iterates; the 'collection_expression' is the
9556
  expression of the collection that we iterate over (we need to make
9557
  sure we evaluate this only once); the 'for_body' is the set of
9558
  statements to be executed in each iteration; 'break_label' and
9559
  'continue_label' are the break and continue labels which we need to
9560
  emit since the <statements> may be jumping to 'break_label' (if they
9561
  contain 'break') or to 'continue_label' (if they contain
9562
  'continue').
9563
 
9564
  The syntax is
9565
 
9566
  for (<object expression> in <collection expression>)
9567
    <statements>
9568
 
9569
  which is compiled into the following blurb:
9570
 
9571
  {
9572
    id __objc_foreach_collection;
9573
    __objc_fast_enumeration_state __objc_foreach_enum_state;
9574
    unsigned long __objc_foreach_batchsize;
9575
    id __objc_foreach_items[16];
9576
    __objc_foreach_collection = <collection expression>;
9577
    __objc_foreach_enum_state = { 0 };
9578
    __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state  objects: __objc_foreach_items  count: 16];
9579
 
9580
    if (__objc_foreach_batchsize == 0)
9581
      <object expression> = nil;
9582
    else
9583
      {
9584
        unsigned long __objc_foreach_mutations_pointer = *__objc_foreach_enum_state.mutationsPtr;
9585
        next_batch:
9586
          {
9587
            unsigned long __objc_foreach_index;
9588
            __objc_foreach_index = 0;
9589
 
9590
            next_object:
9591
            if (__objc_foreach_mutation_pointer != *__objc_foreach_enum_state.mutationsPtr) objc_enumeration_mutation (<collection expression>);
9592
            <object expression> = enumState.itemsPtr[__objc_foreach_index];
9593
            <statements> [PS: inside <statments>, 'break' jumps to break_label and 'continue' jumps to continue_label]
9594
 
9595
            continue_label:
9596
            __objc_foreach_index++;
9597
            if (__objc_foreach_index < __objc_foreach_batchsize) goto next_object;
9598
            __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state  objects: __objc_foreach_items  count: 16];
9599
         }
9600
       if (__objc_foreach_batchsize != 0) goto next_batch;
9601
       <object expression> = nil;
9602
       break_label:
9603
      }
9604
  }
9605
 
9606
  'statements' may contain a 'continue' or 'break' instruction, which
9607
  the user expects to 'continue' or 'break' the entire foreach loop.
9608
  We are provided the labels that 'break' and 'continue' jump to, so
9609
  we place them where we want them to jump to when they pick them.
9610
 
9611
  Optimization TODO: we could cache the IMP of
9612
  countByEnumeratingWithState:objects:count:.
9613
*/
9614
 
9615
/* If you need to debug objc_finish_foreach_loop(), uncomment the following line.  */
9616
/* #define DEBUG_OBJC_FINISH_FOREACH_LOOP 1 */
9617
 
9618
#ifdef DEBUG_OBJC_FINISH_FOREACH_LOOP
9619
#include "tree-pretty-print.h"
9620
#endif
9621
 
9622
void
9623
objc_finish_foreach_loop (location_t location, tree object_expression, tree collection_expression, tree for_body,
9624
                          tree break_label, tree continue_label)
9625
{
9626
  /* A tree representing the __objcFastEnumerationState struct type,
9627
     or NSFastEnumerationState struct, whatever we are using.  */
9628
  tree objc_fast_enumeration_state_type;
9629
 
9630
  /* The trees representing the declarations of each of the local variables.  */
9631
  tree objc_foreach_collection_decl;
9632
  tree objc_foreach_enum_state_decl;
9633
  tree objc_foreach_items_decl;
9634
  tree objc_foreach_batchsize_decl;
9635
  tree objc_foreach_mutations_pointer_decl;
9636
  tree objc_foreach_index_decl;
9637
 
9638
  /* A tree representing the selector countByEnumeratingWithState:objects:count:.  */
9639
  tree selector_name;
9640
 
9641
  /* A tree representing the local bind.  */
9642
  tree bind;
9643
 
9644
  /* A tree representing the external 'if (__objc_foreach_batchsize)' */
9645
  tree first_if;
9646
 
9647
  /* A tree representing the 'else' part of 'first_if'  */
9648
  tree first_else;
9649
 
9650
  /* A tree representing the 'next_batch' label.  */
9651
  tree next_batch_label_decl;
9652
 
9653
  /* A tree representing the binding after the 'next_batch' label.  */
9654
  tree next_batch_bind;
9655
 
9656
  /* A tree representing the 'next_object' label.  */
9657
  tree next_object_label_decl;
9658
 
9659
  /* Temporary variables.  */
9660
  tree t;
9661
  int i;
9662
 
9663
  if (flag_objc1_only)
9664
    error_at (location, "fast enumeration is not available in Objective-C 1.0");
9665
 
9666
  if (object_expression == error_mark_node)
9667
    return;
9668
 
9669
  if (collection_expression == error_mark_node)
9670
    return;
9671
 
9672
  if (!objc_type_valid_for_messaging (TREE_TYPE (object_expression), true))
9673
    {
9674
      error_at (location, "iterating variable in fast enumeration is not an object");
9675
      return;
9676
    }
9677
 
9678
  if (!objc_type_valid_for_messaging (TREE_TYPE (collection_expression), true))
9679
    {
9680
      error_at (location, "collection in fast enumeration is not an object");
9681
      return;
9682
    }
9683
 
9684
  /* TODO: Check that object_expression is either a variable
9685
     declaration, or an lvalue.  */
9686
 
9687
  /* This kludge is an idea from apple.  We use the
9688
     __objcFastEnumerationState struct implicitly defined by the
9689
     compiler, unless a NSFastEnumerationState struct has been defined
9690
     (by a Foundation library such as GNUstep Base) in which case, we
9691
     use that one.
9692
  */
9693
  objc_fast_enumeration_state_type = objc_fast_enumeration_state_template;
9694
  {
9695
    tree objc_NSFastEnumeration_type = lookup_name (get_identifier ("NSFastEnumerationState"));
9696
 
9697
    if (objc_NSFastEnumeration_type)
9698
      {
9699
        /* TODO: We really need to check that
9700
           objc_NSFastEnumeration_type is the same as ours!  */
9701
        if (TREE_CODE (objc_NSFastEnumeration_type) == TYPE_DECL)
9702
          {
9703
            /* If it's a typedef, use the original type.  */
9704
            if (DECL_ORIGINAL_TYPE (objc_NSFastEnumeration_type))
9705
              objc_fast_enumeration_state_type = DECL_ORIGINAL_TYPE (objc_NSFastEnumeration_type);
9706
            else
9707
              objc_fast_enumeration_state_type = TREE_TYPE (objc_NSFastEnumeration_type);
9708
          }
9709
      }
9710
  }
9711
 
9712
  /* { */
9713
  /* Done by c-parser.c.  */
9714
 
9715
  /* type object; */
9716
  /* Done by c-parser.c.  */
9717
 
9718
  /* Disable warnings that 'object' is unused.  For example the code
9719
 
9720
     for (id object in collection)
9721
       i++;
9722
 
9723
     which can be used to count how many objects there are in the
9724
     collection is fine and should generate no warnings even if
9725
     'object' is technically unused.  */
9726
  TREE_USED (object_expression) = 1;
9727
  if (DECL_P (object_expression))
9728
    DECL_READ_P (object_expression) = 1;
9729
 
9730
  /*  id __objc_foreach_collection */
9731
  objc_foreach_collection_decl = objc_create_temporary_var (objc_object_type, "__objc_foreach_collection");
9732
 
9733
  /*  __objcFastEnumerationState __objc_foreach_enum_state; */
9734
  objc_foreach_enum_state_decl = objc_create_temporary_var (objc_fast_enumeration_state_type, "__objc_foreach_enum_state");
9735
  TREE_CHAIN (objc_foreach_enum_state_decl) = objc_foreach_collection_decl;
9736
 
9737
  /* id __objc_foreach_items[16]; */
9738
  objc_foreach_items_decl = objc_create_temporary_var (build_sized_array_type (objc_object_type, 16), "__objc_foreach_items");
9739
  TREE_CHAIN (objc_foreach_items_decl) = objc_foreach_enum_state_decl;
9740
 
9741
  /* unsigned long __objc_foreach_batchsize; */
9742
  objc_foreach_batchsize_decl = objc_create_temporary_var (long_unsigned_type_node, "__objc_foreach_batchsize");
9743
  TREE_CHAIN (objc_foreach_batchsize_decl) = objc_foreach_items_decl;
9744
 
9745
  /* Generate the local variable binding.  */
9746
  bind = build3 (BIND_EXPR, void_type_node, objc_foreach_batchsize_decl, NULL, NULL);
9747
  SET_EXPR_LOCATION (bind, location);
9748
  TREE_SIDE_EFFECTS (bind) = 1;
9749
 
9750
  /*  __objc_foreach_collection = <collection expression>; */
9751
  t = build2 (MODIFY_EXPR, void_type_node, objc_foreach_collection_decl, collection_expression);
9752
  SET_EXPR_LOCATION (t, location);
9753
  append_to_statement_list (t, &BIND_EXPR_BODY (bind));
9754
  /* We have used 'collection_expression'.  */
9755
  mark_exp_read (collection_expression);
9756
 
9757
  /*  __objc_foreach_enum_state.state = 0; */
9758
  t = build2 (MODIFY_EXPR, void_type_node, objc_build_component_ref (objc_foreach_enum_state_decl,
9759
                                                                     get_identifier ("state")),
9760
              build_int_cst (long_unsigned_type_node, 0));
9761
  SET_EXPR_LOCATION (t, location);
9762
  append_to_statement_list (t, &BIND_EXPR_BODY (bind));
9763
 
9764
  /*  __objc_foreach_enum_state.itemsPtr = NULL; */
9765
  t = build2 (MODIFY_EXPR, void_type_node, objc_build_component_ref (objc_foreach_enum_state_decl,
9766
                                                                     get_identifier ("itemsPtr")),
9767
              null_pointer_node);
9768
  SET_EXPR_LOCATION (t, location);
9769
  append_to_statement_list (t, &BIND_EXPR_BODY (bind));
9770
 
9771
  /*  __objc_foreach_enum_state.mutationsPtr = NULL; */
9772
  t = build2 (MODIFY_EXPR, void_type_node, objc_build_component_ref (objc_foreach_enum_state_decl,
9773
                                                                     get_identifier ("mutationsPtr")),
9774
              null_pointer_node);
9775
  SET_EXPR_LOCATION (t, location);
9776
  append_to_statement_list (t, &BIND_EXPR_BODY (bind));
9777
 
9778
  /*  __objc_foreach_enum_state.extra[0] = 0; */
9779
  /*  __objc_foreach_enum_state.extra[1] = 0; */
9780
  /*  __objc_foreach_enum_state.extra[2] = 0; */
9781
  /*  __objc_foreach_enum_state.extra[3] = 0; */
9782
  /*  __objc_foreach_enum_state.extra[4] = 0; */
9783
  for (i = 0; i < 5 ; i++)
9784
    {
9785
      t = build2 (MODIFY_EXPR, void_type_node,
9786
                  build_array_ref (location, objc_build_component_ref (objc_foreach_enum_state_decl,
9787
                                                                       get_identifier ("extra")),
9788
                                   build_int_cst (NULL_TREE, i)),
9789
                  build_int_cst (long_unsigned_type_node, 0));
9790
      SET_EXPR_LOCATION (t, location);
9791
      append_to_statement_list (t, &BIND_EXPR_BODY (bind));
9792
    }
9793
 
9794
  /* __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state  objects: __objc_foreach_items  count: 16]; */
9795
  selector_name = get_identifier ("countByEnumeratingWithState:objects:count:");
9796
#ifdef OBJCPLUS
9797
  t = objc_finish_message_expr (objc_foreach_collection_decl, selector_name,
9798
                                /* Parameters.  */
9799
                                tree_cons    /* &__objc_foreach_enum_state */
9800
                                (NULL_TREE, build_fold_addr_expr_loc (location, objc_foreach_enum_state_decl),
9801
                                 tree_cons   /* __objc_foreach_items  */
9802
                                 (NULL_TREE, objc_foreach_items_decl,
9803
                                  tree_cons  /* 16 */
9804
                                  (NULL_TREE, build_int_cst (NULL_TREE, 16), NULL_TREE))), NULL);
9805
#else
9806
  /* In C, we need to decay the __objc_foreach_items array that we are passing.  */
9807
  {
9808
    struct c_expr array;
9809
    array.value = objc_foreach_items_decl;
9810
    t = objc_finish_message_expr (objc_foreach_collection_decl, selector_name,
9811
                                  /* Parameters.  */
9812
                                  tree_cons    /* &__objc_foreach_enum_state */
9813
                                  (NULL_TREE, build_fold_addr_expr_loc (location, objc_foreach_enum_state_decl),
9814
                                   tree_cons   /* __objc_foreach_items  */
9815
                                   (NULL_TREE, default_function_array_conversion (location, array).value,
9816
                                    tree_cons  /* 16 */
9817
                                    (NULL_TREE, build_int_cst (NULL_TREE, 16), NULL_TREE))), NULL);
9818
  }
9819
#endif
9820
  t = build2 (MODIFY_EXPR, void_type_node, objc_foreach_batchsize_decl,
9821
              convert (long_unsigned_type_node, t));
9822
  SET_EXPR_LOCATION (t, location);
9823
  append_to_statement_list (t, &BIND_EXPR_BODY (bind));
9824
 
9825
  /* if (__objc_foreach_batchsize == 0) */
9826
  first_if = build3 (COND_EXPR, void_type_node,
9827
                     /* Condition.  */
9828
                     c_fully_fold
9829
                     (c_common_truthvalue_conversion
9830
                      (location,
9831
                       build_binary_op (location,
9832
                                        EQ_EXPR,
9833
                                        objc_foreach_batchsize_decl,
9834
                                        build_int_cst (long_unsigned_type_node, 0), 1)),
9835
                      false, NULL),
9836
                     /* Then block (we fill it in later).  */
9837
                     NULL_TREE,
9838
                     /* Else block (we fill it in later).  */
9839
                     NULL_TREE);
9840
  SET_EXPR_LOCATION (first_if, location);
9841
  append_to_statement_list (first_if, &BIND_EXPR_BODY (bind));
9842
 
9843
  /* then <object expression> = nil; */
9844
  t = build2 (MODIFY_EXPR, void_type_node, object_expression, convert (objc_object_type, null_pointer_node));
9845
  SET_EXPR_LOCATION (t, location);
9846
  COND_EXPR_THEN (first_if) = t;
9847
 
9848
  /* Now we build the 'else' part of the if; once we finish building
9849
     it, we attach it to first_if as the 'else' part.  */
9850
 
9851
  /* else */
9852
  /* { */
9853
 
9854
  /* unsigned long __objc_foreach_mutations_pointer; */
9855
  objc_foreach_mutations_pointer_decl = objc_create_temporary_var (long_unsigned_type_node, "__objc_foreach_mutations_pointer");
9856
 
9857
  /* Generate the local variable binding.  */
9858
  first_else = build3 (BIND_EXPR, void_type_node, objc_foreach_mutations_pointer_decl, NULL, NULL);
9859
  SET_EXPR_LOCATION (first_else, location);
9860
  TREE_SIDE_EFFECTS (first_else) = 1;
9861
 
9862
  /* __objc_foreach_mutations_pointer = *__objc_foreach_enum_state.mutationsPtr; */
9863
  t = build2 (MODIFY_EXPR, void_type_node, objc_foreach_mutations_pointer_decl,
9864
              build_indirect_ref (location, objc_build_component_ref (objc_foreach_enum_state_decl,
9865
                                                                      get_identifier ("mutationsPtr")),
9866
                                  RO_UNARY_STAR));
9867
  SET_EXPR_LOCATION (t, location);
9868
  append_to_statement_list (t, &BIND_EXPR_BODY (first_else));
9869
 
9870
  /* next_batch: */
9871
  next_batch_label_decl = create_artificial_label (location);
9872
  t = build1 (LABEL_EXPR, void_type_node, next_batch_label_decl);
9873
  SET_EXPR_LOCATION (t, location);
9874
  append_to_statement_list (t, &BIND_EXPR_BODY (first_else));
9875
 
9876
  /* { */
9877
 
9878
  /* unsigned long __objc_foreach_index; */
9879
  objc_foreach_index_decl = objc_create_temporary_var (long_unsigned_type_node, "__objc_foreach_index");
9880
 
9881
  /* Generate the local variable binding.  */
9882
  next_batch_bind = build3 (BIND_EXPR, void_type_node, objc_foreach_index_decl, NULL, NULL);
9883
  SET_EXPR_LOCATION (next_batch_bind, location);
9884
  TREE_SIDE_EFFECTS (next_batch_bind) = 1;
9885
  append_to_statement_list (next_batch_bind, &BIND_EXPR_BODY (first_else));
9886
 
9887
  /* __objc_foreach_index = 0; */
9888
  t = build2 (MODIFY_EXPR, void_type_node, objc_foreach_index_decl,
9889
              build_int_cst (long_unsigned_type_node, 0));
9890
  SET_EXPR_LOCATION (t, location);
9891
  append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind));
9892
 
9893
  /* next_object: */
9894
  next_object_label_decl = create_artificial_label (location);
9895
  t = build1 (LABEL_EXPR, void_type_node, next_object_label_decl);
9896
  SET_EXPR_LOCATION (t, location);
9897
  append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind));
9898
 
9899
  /* if (__objc_foreach_mutation_pointer != *__objc_foreach_enum_state.mutationsPtr) objc_enumeration_mutation (<collection expression>); */
9900
  t = build3 (COND_EXPR, void_type_node,
9901
              /* Condition.  */
9902
              c_fully_fold
9903
              (c_common_truthvalue_conversion
9904
               (location,
9905
                build_binary_op
9906
                (location,
9907
                 NE_EXPR,
9908
                 objc_foreach_mutations_pointer_decl,
9909
                 build_indirect_ref (location,
9910
                                     objc_build_component_ref (objc_foreach_enum_state_decl,
9911
                                                               get_identifier ("mutationsPtr")),
9912
                                     RO_UNARY_STAR), 1)),
9913
               false, NULL),
9914
              /* Then block.  */
9915
              build_function_call (input_location,
9916
                                   objc_enumeration_mutation_decl,
9917
                                   tree_cons (NULL, collection_expression, NULL)),
9918
              /* Else block.  */
9919
              NULL_TREE);
9920
  SET_EXPR_LOCATION (t, location);
9921
  append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind));
9922
 
9923
  /* <object expression> = enumState.itemsPtr[__objc_foreach_index]; */
9924
  t = build2 (MODIFY_EXPR, void_type_node, object_expression,
9925
              build_array_ref (location, objc_build_component_ref (objc_foreach_enum_state_decl,
9926
                                                                   get_identifier ("itemsPtr")),
9927
                               objc_foreach_index_decl));
9928
  SET_EXPR_LOCATION (t, location);
9929
  append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind));
9930
 
9931
  /* <statements> [PS: in <statments>, 'break' jumps to break_label and 'continue' jumps to continue_label] */
9932
  append_to_statement_list (for_body, &BIND_EXPR_BODY (next_batch_bind));
9933
 
9934
  /* continue_label: */
9935
  if (continue_label)
9936
    {
9937
      t = build1 (LABEL_EXPR, void_type_node, continue_label);
9938
      SET_EXPR_LOCATION (t, location);
9939
      append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind));
9940
    }
9941
 
9942
  /* __objc_foreach_index++; */
9943
  t = build2 (MODIFY_EXPR, void_type_node, objc_foreach_index_decl,
9944
              build_binary_op (location,
9945
                               PLUS_EXPR,
9946
                               objc_foreach_index_decl,
9947
                               build_int_cst (long_unsigned_type_node, 1), 1));
9948
  SET_EXPR_LOCATION (t, location);
9949
  append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind));
9950
 
9951
  /* if (__objc_foreach_index < __objc_foreach_batchsize) goto next_object; */
9952
  t = build3 (COND_EXPR, void_type_node,
9953
              /* Condition.  */
9954
              c_fully_fold
9955
              (c_common_truthvalue_conversion
9956
               (location,
9957
                build_binary_op (location,
9958
                                 LT_EXPR,
9959
                                 objc_foreach_index_decl,
9960
                                 objc_foreach_batchsize_decl, 1)),
9961
               false, NULL),
9962
              /* Then block.  */
9963
              build1 (GOTO_EXPR, void_type_node, next_object_label_decl),
9964
              /* Else block.  */
9965
              NULL_TREE);
9966
  SET_EXPR_LOCATION (t, location);
9967
  append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind));
9968
 
9969
  /* __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state  objects: __objc_foreach_items  count: 16]; */
9970
#ifdef OBJCPLUS
9971
  t = objc_finish_message_expr (objc_foreach_collection_decl, selector_name,
9972
                                /* Parameters.  */
9973
                                tree_cons    /* &__objc_foreach_enum_state */
9974
                                (NULL_TREE, build_fold_addr_expr_loc (location, objc_foreach_enum_state_decl),
9975
                                 tree_cons   /* __objc_foreach_items  */
9976
                                 (NULL_TREE, objc_foreach_items_decl,
9977
                                  tree_cons  /* 16 */
9978
                                  (NULL_TREE, build_int_cst (NULL_TREE, 16), NULL_TREE))), NULL);
9979
#else
9980
  /* In C, we need to decay the __objc_foreach_items array that we are passing.  */
9981
  {
9982
    struct c_expr array;
9983
    array.value = objc_foreach_items_decl;
9984
    t = objc_finish_message_expr (objc_foreach_collection_decl, selector_name,
9985
                                  /* Parameters.  */
9986
                                  tree_cons    /* &__objc_foreach_enum_state */
9987
                                  (NULL_TREE, build_fold_addr_expr_loc (location, objc_foreach_enum_state_decl),
9988
                                   tree_cons   /* __objc_foreach_items  */
9989
                                   (NULL_TREE, default_function_array_conversion (location, array).value,
9990
                                    tree_cons  /* 16 */
9991
                                    (NULL_TREE, build_int_cst (NULL_TREE, 16), NULL_TREE))), NULL);
9992
  }
9993
#endif
9994
  t = build2 (MODIFY_EXPR, void_type_node, objc_foreach_batchsize_decl,
9995
              convert (long_unsigned_type_node, t));
9996
  SET_EXPR_LOCATION (t, location);
9997
  append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind));
9998
 
9999
  /* } */
10000
 
10001
  /* if (__objc_foreach_batchsize != 0) goto next_batch; */
10002
  t = build3 (COND_EXPR, void_type_node,
10003
              /* Condition.  */
10004
              c_fully_fold
10005
              (c_common_truthvalue_conversion
10006
               (location,
10007
                build_binary_op (location,
10008
                                 NE_EXPR,
10009
                                 objc_foreach_batchsize_decl,
10010
                                 build_int_cst (long_unsigned_type_node, 0), 1)),
10011
               false, NULL),
10012
              /* Then block.  */
10013
              build1 (GOTO_EXPR, void_type_node, next_batch_label_decl),
10014
              /* Else block.  */
10015
              NULL_TREE);
10016
  SET_EXPR_LOCATION (t, location);
10017
  append_to_statement_list (t, &BIND_EXPR_BODY (first_else));
10018
 
10019
  /* <object expression> = nil; */
10020
  t = build2 (MODIFY_EXPR, void_type_node, object_expression, convert (objc_object_type, null_pointer_node));
10021
  SET_EXPR_LOCATION (t, location);
10022
  append_to_statement_list (t, &BIND_EXPR_BODY (first_else));
10023
 
10024
  /* break_label: */
10025
  if (break_label)
10026
    {
10027
      t = build1 (LABEL_EXPR, void_type_node, break_label);
10028
      SET_EXPR_LOCATION (t, location);
10029
      append_to_statement_list (t, &BIND_EXPR_BODY (first_else));
10030
    }
10031
 
10032
  /* } */
10033
  COND_EXPR_ELSE (first_if) = first_else;
10034
 
10035
  /* Do the whole thing.  */
10036
  add_stmt (bind);
10037
 
10038
#ifdef DEBUG_OBJC_FINISH_FOREACH_LOOP
10039
  /* This will print to stderr the whole blurb generated by the
10040
     compiler while compiling (assuming the compiler doesn't crash
10041
     before getting here).
10042
   */
10043
  debug_generic_stmt (bind);
10044
#endif
10045
 
10046
  /* } */
10047
  /* Done by c-parser.c  */
10048
}
10049
 
10050
/* --- SUPPORT FOR FORMAT ARG CHECKING --- */
10051
/* Return true if we have an NxString object pointer.  */
10052
 
10053
bool
10054
objc_string_ref_type_p (tree strp)
10055
{
10056
  tree tmv;
10057
  if (!strp || TREE_CODE (strp) != POINTER_TYPE)
10058
    return false;
10059
 
10060
  tmv = TYPE_MAIN_VARIANT (TREE_TYPE (strp));
10061
  tmv = OBJC_TYPE_NAME (tmv);
10062
  return (tmv
10063
          && TREE_CODE (tmv) == IDENTIFIER_NODE
10064
          && IDENTIFIER_POINTER (tmv)
10065
          && !strncmp (IDENTIFIER_POINTER (tmv), "NSString", 8));
10066
}
10067
 
10068
/* At present the behavior of this is undefined and it does nothing.  */
10069
void
10070
objc_check_format_arg (tree ARG_UNUSED (format_arg),
10071
                       tree ARG_UNUSED (args_list))
10072
{
10073
}
10074
 
10075
void
10076
objc_common_init_ts (void)
10077
{
10078
  c_common_init_ts ();
10079
 
10080
  MARK_TS_DECL_NON_COMMON (CLASS_METHOD_DECL);
10081
  MARK_TS_DECL_NON_COMMON (INSTANCE_METHOD_DECL);
10082
  MARK_TS_DECL_NON_COMMON (KEYWORD_DECL);
10083
  MARK_TS_DECL_NON_COMMON (PROPERTY_DECL);
10084
 
10085
  MARK_TS_COMMON (CLASS_INTERFACE_TYPE);
10086
  MARK_TS_COMMON (PROTOCOL_INTERFACE_TYPE);
10087
  MARK_TS_COMMON (CLASS_IMPLEMENTATION_TYPE);
10088
 
10089
  MARK_TS_TYPED (MESSAGE_SEND_EXPR);
10090
  MARK_TS_TYPED (PROPERTY_REF);
10091
}
10092
 
10093
#include "gt-objc-objc-act.h"

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.