d-apple-gcc.c

   1 #include "config.h"
   2 #include "system.h"
   3 #include "coretypes.h"
   4 #include "tm.h"
   5 #include "tree.h"
   6 #include "flags.h"
   7 #include "convert.h"
   8 #include "cpplib.h"
   9
  10 typedef void iasm_md_extra_info;
  11
  12 int iasm_in_operands;
  13 int iasm_state;
  14
  15 enum { unused } c_language;
  16 const char *constant_string_class_name = NULL;
  17 int flag_next_runtime;
  18 int flag_iasm_blocks;
  19 int flag_weak;
  20
  21 int disable_typechecking_for_spec_flag;
  22
  23 add_cpp_dir_path (cpp_dir *p, int chain)
  24 {
  25     /* nothing */
  26 }
  27
  28 void
  29 add_path (char *path, int chain, int cxx_aware, bool user_supplied_p)
  30 {
  31     /* nothing */
  32 }
  33
  34 void
  35 builtin_define_with_value (const char *macro, const char *expansion, int is_str)
  36 {
  37     /* nothing */
  38 }
  39
  40
  41 tree
  42 build_function_call (tree function, tree params)
  43 {
  44   tree fntype, fundecl = 0;
  45   tree name = NULL_TREE, result;
  46   /* Strip NON_LVALUE_EXPRs, etc., since we aren't using as an lvalue.  */
  47   STRIP_TYPE_NOPS (function);
  48   /* Convert anything with function type to a pointer-to-function.  */
  49   gcc_assert(TREE_CODE (function) == FUNCTION_DECL);
  50   if (TREE_CODE (function) == FUNCTION_DECL)
  51     {
  52       name = DECL_NAME (function);
  53
  54       /* Differs from default_conversion by not setting TREE_ADDRESSABLE
  55          (because calling an inline function does not mean the function
  56          needs to be separately compiled).  */
  57       fntype = build_type_variant (TREE_TYPE (function),
  58                                    TREE_READONLY (function),
  59                                    TREE_THIS_VOLATILE (function));
  60       fundecl = function;
  61       function = build1 (ADDR_EXPR, build_pointer_type (fntype), function);
  62     }
  63   else
  64       function = default_conversion (function);
  65   /* APPLE LOCAL begin mainline */
  66   /* For Objective-C, convert any calls via a cast to OBJC_TYPE_REF
  67      expressions, like those used for ObjC messenger dispatches.  */
  68   function = objc_rewrite_function_call (function, params);
  69
  70   /* APPLE LOCAL end mainline */
  71   fntype = TREE_TYPE (function);
  72
  73   if (TREE_CODE (fntype) == ERROR_MARK)
  74     return error_mark_node;
  75
  76   if (!(TREE_CODE (fntype) == POINTER_TYPE
  77         && TREE_CODE (TREE_TYPE (fntype)) == FUNCTION_TYPE))
  78     {
  79       error ("called object %qE is not a function", function);
  80       return error_mark_node;
  81     }
  82   /* fntype now gets the type of function pointed to.  */
  83   fntype = TREE_TYPE (fntype);
  84
  85   result = build3 (CALL_EXPR, TREE_TYPE (fntype),
  86                    function, params, NULL_TREE);
  87   TREE_SIDE_EFFECTS (result) = 1;
  88
  89   result = fold (result);
  90   return result;
  91 }
  92
  93 tree
  94 build_modify_expr (tree lhs, enum tree_code modifycode, tree rhs)
  95 {
  96     gcc_assert(modifycode == NOP_EXPR);
  97     tree result = build2(MODIFY_EXPR, TREE_TYPE(lhs), lhs, rhs);
  98     TREE_SIDE_EFFECTS (result) = 1;
  99     // objc write barrier...
 100     return result;
 101 }
 102
 103 tree
 104 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
 105 {
 106     gcc_assert(0);
 107 }
 108
 109 tree
 110 pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
 111 {
 112     gcc_assert(0);
 113 }
 114
 115 tree
 116 decl_constant_value (tree decl)
 117 {
 118     gcc_assert(0);
 119 }
 120
 121 tree
 122 lookup_name_two (tree name, int ARG_UNUSED (prefer_type))
 123 {
 124     return NULL_TREE;
 125 }
 126
 127 enum cpp_ttype
 128 c_lex (tree *value)
 129 {
 130     gcc_assert(0);
 131 }
 132
 133 tree
 134 iasm_addr (tree e)
 135 {
 136     gcc_assert(0);
 137 }
 138
 139 static enum machine_mode
 140 iasm_get_mode (tree type)
 141 {
 142     gcc_assert(0);
 143 }
 144
 145 tree
 146 iasm_ptr_conv (tree type, tree exp)
 147 {
 148     gcc_assert(0);
 149 }
 150
 151 tree
 152 iasm_build_bracket (tree v1, tree v2)
 153 {
 154     gcc_assert(0);
 155 }
 156
 157 static tree
 158 iasm_default_function_conversion (tree exp)
 159 {
 160     gcc_assert(0);
 161 }
 162
 163 bool
 164 iasm_is_pseudo (const char *opcode)
 165 {
 166     gcc_assert(0);
 167 }
 168
 169 static int
 170 iasm_op_comp (const void *a, const void *b)
 171 {
 172     gcc_assert(0);
 173 }
 174
 175 static const char*
 176 iasm_constraint_for (const char *opcode, unsigned argnum, unsigned ARG_UNUSED (num_args))
 177 {
 178     gcc_assert(0);
 179 }
 180
 181 static void
 182 iasm_process_arg (const char *opcodename, int op_num,
 183                   tree *outputsp, tree *inputsp, tree *uses, unsigned num_args,
 184                   iasm_md_extra_info *e)
 185 {
 186     gcc_assert(0);
 187 }
 188
 189 static tree
 190 iasm_identifier (tree expr)
 191 {
 192     gcc_assert(0);
 193 }
 194
 195 bool
 196 iasm_is_prefix (tree ARG_UNUSED (id))
 197 {
 198     gcc_assert(0);
 199 }
 200
 201 static int
 202 iasm_num_constraints_1 (tree io)
 203 {
 204     gcc_assert(0);
 205 }
 206
 207 static int
 208 iasm_num_constraints (tree inputs, tree outputs)
 209 {
 210     gcc_assert(0);
 211 }
 212
 213 static void
 214 iasm_set_constraints_1 (int num, tree io)
 215 {
 216     gcc_assert(0);
 217 }
 218
 219 static void
 220 iasm_set_constraints (int num, tree inputs, tree outputs)
 221 {
 222     gcc_assert(0);
 223 }
 224
 225 static int
 226 iasm_op_clobber_comp (const void *a, const void *b)
 227 {
 228     gcc_assert(0);
 229 }
 230
 231 static void
 232 iasm_extra_clobbers (const char *opcode, tree *clobbersp)
 233 {
 234     gcc_assert(0);
 235 }
 236
 237 tree
 238 iasm_stmt (tree expr, tree args, int lineno)
 239 {
 240     gcc_assert(0);
 241 }
 242
 243 static int
 244 iasm_field_offset (tree arg)
 245 {
 246     gcc_assert(0);
 247 }
 248
 249 static bool
 250 iasm_simple_expr (tree arg)
 251 {
 252     gcc_assert(0);
 253 }
 254
 255 static int
 256 iasm_expr_val (tree arg)
 257 {
 258     gcc_assert(0);
 259 }
 260
 261 void
 262 iasm_force_constraint (const char *c, iasm_md_extra_info *e)
 263 {
 264     gcc_assert(0);
 265 }
 266
 267 static void
 268 iasm_maybe_force_mem (tree arg, char *buf, unsigned argnum, bool must_be_reg, iasm_md_extra_info *e)
 269 {
 270     gcc_assert(0);
 271 }
 272
 273 void
 274 iasm_print_operand (char *buf, tree arg, unsigned argnum,
 275                     tree *uses,
 276                     bool must_be_reg, bool must_not_be_reg, iasm_md_extra_info *e)
 277 {
 278     gcc_assert(0);
 279 }
 280
 281 void
 282 iasm_get_register_var (tree var, const char *modifier, char *buf, unsigned argnum,
 283                        bool must_be_reg, iasm_md_extra_info *e)
 284 {
 285     gcc_assert(0);
 286 }
 287
 288 tree
 289 iasm_reg_name (tree id)
 290 {
 291     gcc_assert(0);
 292 }
 293
 294 tree
 295 iasm_label (tree labid, int atsign)
 296 {
 297     gcc_assert(0);
 298 }
 299
 300 tree
 301 iasm_get_identifier (tree id, const char *str)
 302 {
 303     gcc_assert(0);
 304 }
 305
 306 void
 307 iasm_clear_labels (void)
 308 {
 309     gcc_assert(0);
 310 }
 311
 312 tree
 313 iasm_do_id (tree id)
 314 {
 315     gcc_assert(0);
 316 }
 317
 318 static tree
 319 iasm_get_label (tree labid)
 320 {
 321     gcc_assert(0);
 322 }
 323
 324 tree
 325 iasm_build_register_offset (tree offset, tree regname)
 326 {
 327     gcc_assert(0);
 328 }
 329
 330 tree
 331 iasm_entry (tree keyword, tree scspec, tree fn)
 332 {
 333     gcc_assert(0);
 334 }