src/pmc/nci.pmc

   1 /*
   2 Copyright (C) 2001-2010, Parrot Foundation.
   3 $Id$
   4
   5 =head1 NAME
   6
   7 src/pmc/nci.pmc - Native Call Interface
   8
   9 =head1 DESCRIPTION
  10
  11 The vtable functions for the native C call functions.
  12
  13 =head2 Methods
  14
  15 =over 4
  16
  17 =cut
  18
  19 */
  20
  21 /* HEADERIZER HFILE: none */
  22 /* HEADERIZER BEGIN: static */
  23 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
  24
  25 PARROT_IGNORABLE_RESULT
  26 static nci_thunk_t /*@alt void@*/
  27 build_func(PARROT_INTERP,
  28     ARGMOD(Parrot_NCI_attributes *nci_info))
  29         __attribute__nonnull__(1)
  30         __attribute__nonnull__(2)
  31         FUNC_MODIFIES(*nci_info);
  32
  33 static void pcc_params(PARROT_INTERP,
  34     ARGIN(STRING *sig),
  35     ARGMOD(Parrot_NCI_attributes *nci_info),
  36     size_t sig_length)
  37         __attribute__nonnull__(1)
  38         __attribute__nonnull__(2)
  39         __attribute__nonnull__(3)
  40         FUNC_MODIFIES(*nci_info);
  41
  42 #define ASSERT_ARGS_build_func __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
  43        PARROT_ASSERT_ARG(interp) \
  44     , PARROT_ASSERT_ARG(nci_info))
  45 #define ASSERT_ARGS_pcc_params __attribute__unused__ int _ASSERT_ARGS_CHECK = (\
  46        PARROT_ASSERT_ARG(interp) \
  47     , PARROT_ASSERT_ARG(sig) \
  48     , PARROT_ASSERT_ARG(nci_info))
  49 /* Don't modify between HEADERIZER BEGIN / HEADERIZER END.  Your changes will be lost. */
  50 /* HEADERIZER END: static */
  51
  52 /*
  53
  54 =item C<static void pcc_params(PARROT_INTERP, STRING *sig, Parrot_NCI_attributes
  55 *nci_info, size_t sig_length)>
  56
  57 =cut
  58
  59 */
  60
  61 static void
  62 pcc_params(PARROT_INTERP, ARGIN(STRING *sig), ARGMOD(Parrot_NCI_attributes *nci_info),
  63                 size_t sig_length)
  64 {
  65     ASSERT_ARGS(pcc_params)
  66
  67     /* NCI and PCC have a 1 to 1 mapping except an
  68        extra char in PCC for invocant and slurpy */
  69     size_t       buf_length = sig_length + 2 + 1;
  70
  71     /* avoid malloc churn on common signatures */
  72     char         static_buf[16];
  73     char * const sig_buf = sig_length <= sizeof static_buf ?
  74                             static_buf :
  75                             (char *)mem_sys_allocate(buf_length);
  76
  77     size_t j = 0;
  78     size_t i;
  79
  80     for (i = 0; i < sig_length; ++i) {
  81         const INTVAL c = Parrot_str_indexed(interp, sig, i);
  82
  83         PARROT_ASSERT(j < buf_length - 1);
  84
  85         switch (c) {
  86           case (INTVAL)'0':    /* null ptr or such - doesn't consume a reg */
  87             break;
  88           case (INTVAL)'f':
  89           case (INTVAL)'N':
  90           case (INTVAL)'d':
  91             sig_buf[j++] = 'N';
  92             break;
  93           case (INTVAL)'I':   /* INTVAL */
  94           case (INTVAL)'l':   /* long */
  95           case (INTVAL)'i':   /* int */
  96           case (INTVAL)'s':   /* short */
  97           case (INTVAL)'c':   /* char */
  98             sig_buf[j++] = 'I';
  99             break;
 100           case (INTVAL)'S':
 101           case (INTVAL)'t':   /* string, pass a cstring */
 102             sig_buf[j++] = 'S';
 103             break;
 104           case (INTVAL)'J':   /* interpreter */
 105             break;
 106           case (INTVAL)'p':   /* push pmc->data */
 107           case (INTVAL)'P':   /* push PMC * */
 108           case (INTVAL)'V':   /* push PMC * */
 109           case (INTVAL)'2':
 110           case (INTVAL)'3':
 111           case (INTVAL)'4':
 112             sig_buf[j++] = 'P';
 113             break;
 114           case (INTVAL)'v':
 115             /* null return */
 116             if (j == 0)
 117                 sig_buf[j++] = '\0';
 118             break;
 119           case (INTVAL)'O':   /* push PMC * invocant */
 120             sig_buf[j++] = 'P';
 121             sig_buf[j++] = 'i';
 122             break;
 123           case (INTVAL)'@':   /* push PMC * slurpy */
 124             sig_buf[j++] = 'P';
 125             sig_buf[j++] = 's';
 126             break;
 127           case (INTVAL)'b': /* buffer (void*) pass Buffer_bufstart(SReg) */
 128           case (INTVAL)'B': /* buffer (void**) pass &Buffer_bufstart(SReg) */
 129             sig_buf[j++] = 'S';
 130             break;
 131           default:
 132             Parrot_ex_throw_from_c_args(interp, NULL,
 133                     EXCEPTION_JIT_ERROR,
 134                     "Unknown param Signature %c\n", (char)c);
 135             break;
 136         }
 137     }
 138
 139     PARROT_ASSERT(j < buf_length);
 140     sig_buf[j++] = '\0';
 141
 142
 143     nci_info->pcc_return_signature =
 144         Parrot_str_new(interp, sig_buf, 1);
 145
 146     nci_info->pcc_params_signature = j ?
 147         Parrot_str_new(interp, sig_buf + 1, j - 1) :
 148         CONST_STRING(interp, "");
 149
 150     if (sig_buf != static_buf)
 151         mem_sys_free(sig_buf);
 152 }
 153
 154 /*
 155
 156 =item C<static nci_thunk_t build_func(PARROT_INTERP, Parrot_NCI_attributes
 157 *nci_info)>
 158
 159 Actually build the NCI thunk.
 160
 161 =cut
 162
 163 */
 164
 165 PARROT_IGNORABLE_RESULT
 166 static nci_thunk_t
 167 build_func(PARROT_INTERP, ARGMOD(Parrot_NCI_attributes *nci_info))
 168 {
 169     ASSERT_ARGS(build_func)
 170
 171     STRING * const key      = nci_info->signature;
 172     const size_t key_length = Parrot_str_byte_length(interp, key);
 173
 174     pcc_params(interp, key, nci_info, key_length);
 175
 176     /* Arity is length of that string minus one (the return type). */
 177     nci_info->arity       = key_length - 1;
 178
 179     /* Build call function. */
 180     nci_info->fb_info     = build_call_func(interp, key);
 181     nci_info->func        = F2DPTR(VTABLE_get_pointer(interp, nci_info->fb_info));
 182
 183     return (nci_thunk_t)nci_info->func;
 184 }
 185
 186
 187 pmclass NCI auto_attrs provides invokable {
 188     /* NCI thunk handling attributes */
 189     /* NCI thunk handling attributes */
 190     ATTR STRING    *signature;              /* The signature. */
 191     ATTR void      *func;                   /* Function pointer to call. */
 192     ATTR PMC       *fb_info;                /* Frame-builder info */
 193     ATTR void      *orig_func;              /* Function pointer
 194                                              * used to create func */
 195     /* Parrot Sub-ish attributes */
 196     ATTR STRING    *pcc_params_signature;
 197     ATTR STRING    *pcc_return_signature;
 198     ATTR INTVAL     arity;                  /* Cached arity of the NCI. */
 199
 200     /* MMD fields */
 201     ATTR STRING    *long_signature;         /* The full signature. */
 202     ATTR PMC       *multi_sig;              /* type tuple array (?) */
 203
 204 /*
 205
 206 =item C<METHOD get_multisig()>
 207
 208 Return the MMD signature PMC, if any or a Null PMC.
 209
 210 =cut
 211
 212 */
 213
 214     METHOD get_multisig() {
 215         PMC *sig;
 216         GET_ATTR_multi_sig(INTERP, SELF, sig);
 217         if (PMC_IS_NULL(sig))
 218             sig = PMCNULL;
 219         RETURN(PMC *sig);
 220     }
 221
 222 /*
 223
 224 =item C<void init()>
 225
 226 Initializes the NCI with a C<NULL> function pointer.
 227
 228 =cut
 229
 230 */
 231
 232     VTABLE void init() {
 233         PObj_custom_mark_SET(SELF);
 234     }
 235
 236     VTABLE void *get_pointer() {
 237         return PARROT_NCI(SELF)->orig_func;
 238     }
 239
 240 /*
 241
 242 =item C<void set_pointer_keyed_str(STRING *key, void *func)>
 243
 244 Sets the specified function pointer and signature (C<*key>).
 245
 246 =cut
 247
 248 */
 249
 250     VTABLE void set_pointer_keyed_str(STRING *key, void *func) {
 251         Parrot_NCI_attributes * const nci_info   = PARROT_NCI(SELF);
 252
 253         /* Store the original function and signature. */
 254         SET_ATTR_orig_func(INTERP, SELF, func);
 255
 256         /* ensure that the STRING signature is constant */
 257         if (!PObj_constant_TEST(key)) {
 258             char * const key_c      = Parrot_str_to_cstring(INTERP, key);
 259             const size_t key_length = Parrot_str_byte_length(interp, key);
 260             key                     = Parrot_str_new_init(interp, key_c, key_length,
 261                                         Parrot_default_encoding_ptr, PObj_constant_FLAG);
 262             Parrot_str_free_cstring(key_c);
 263         }
 264
 265         nci_info->signature = key;
 266     }
 267
 268 /*
 269
 270 =item C<void mark()>
 271
 272 Mark any referenced strings and PMCs.
 273
 274 =cut
 275
 276 */
 277     VTABLE void mark() {
 278         if (PARROT_NCI(SELF)) {
 279             Parrot_NCI_attributes * const nci_info = PARROT_NCI(SELF);
 280
 281             Parrot_gc_mark_PMC_alive(interp, nci_info->fb_info);
 282             Parrot_gc_mark_PMC_alive(interp, nci_info->multi_sig);
 283
 284             Parrot_gc_mark_STRING_alive(interp, nci_info->signature);
 285             Parrot_gc_mark_STRING_alive(interp, nci_info->long_signature);
 286             Parrot_gc_mark_STRING_alive(interp, nci_info->pcc_params_signature);
 287             Parrot_gc_mark_STRING_alive(interp, nci_info->pcc_return_signature);
 288         }
 289     }
 290
 291 /*
 292
 293 =item C<PMC *clone()>
 294
 295 Creates and returns a clone of the NCI.
 296
 297 =cut
 298
 299 */
 300
 301     VTABLE PMC *clone() {
 302         Parrot_NCI_attributes * const nci_info_self = PARROT_NCI(SELF);
 303         Parrot_NCI_attributes *nci_info_ret;
 304         void                  *orig_func;
 305
 306         PMC * const ret     = Parrot_pmc_new(INTERP, SELF->vtable->base_type);
 307         nci_info_ret        = PARROT_NCI(ret);
 308
 309         /* FIXME if data is malloced (JIT/i386!) then we need
 310          * the length of data here, to memcpy it
 311          * ManagedStruct or Buffer?
 312          */
 313         nci_info_ret->func                  = nci_info_self->func;
 314         nci_info_ret->fb_info               = nci_info_self->fb_info;
 315         nci_info_ret->orig_func             = nci_info_self->orig_func;
 316         nci_info_ret->signature             = nci_info_self->signature;
 317         nci_info_ret->pcc_params_signature  = nci_info_self->pcc_params_signature;
 318         nci_info_ret->pcc_return_signature  = nci_info_self->pcc_params_signature;
 319         nci_info_ret->arity                 = nci_info_self->arity;
 320         PObj_get_FLAGS(ret)                 = PObj_get_FLAGS(SELF);
 321
 322         return ret;
 323     }
 324
 325 /*
 326
 327 =item C<INTVAL defined()>
 328
 329 Returns whether the NCI is defined.
 330
 331 =cut
 332
 333 */
 334
 335     VTABLE INTVAL defined() {
 336         Parrot_NCI_attributes * const nci_info = PARROT_NCI(SELF);
 337         return nci_info->orig_func != NULL;
 338     }
 339
 340 /*
 341
 342 =item C<opcode_t *invoke(void *next)>
 343
 344 Calls the associated C function, returning C<*next>. If the invocant is a
 345 class, the PMC arguments are shifted down.
 346
 347 =cut
 348
 349 */
 350
 351     VTABLE opcode_t *invoke(void *next) {
 352         Parrot_NCI_attributes * const nci_info = PARROT_NCI(SELF);
 353         nci_thunk_t                   func;
 354         PMC                          *fb_info;
 355         char                         *sig_str;
 356         void                         *orig_func;
 357         PMC                          *cont;
 358
 359         GET_ATTR_orig_func(INTERP, SELF, orig_func);
 360         func = (nci_thunk_t)D2FPTR(nci_info->func);
 361
 362         GET_ATTR_fb_info(INTERP, SELF, fb_info);
 363
 364         if (!func) {
 365             /* build the thunk only when necessary */
 366             func = build_func(interp, nci_info);
 367
 368             if (!func)
 369                 Parrot_ex_throw_from_c_args(INTERP, NULL,
 370                     EXCEPTION_INVALID_OPERATION,
 371                     "attempt to call NULL function");
 372         }
 373
 374         func(INTERP, SELF, fb_info);
 375         cont = INTERP->current_cont;
 376
 377         /*
 378          * If the NCI function was tailcalled, the return result
 379          * is already passed back to the caller of this frame
 380          * - see  Parrot_init_ret_nci(). We therefore invoke the
 381          * return continuation here, which gets rid of this frame
 382          * and returns the real return address
 383          */
 384         if (cont && cont != NEED_CONTINUATION
 385         && (PObj_get_FLAGS(cont) & SUB_FLAG_TAILCALL)) {
 386             cont = Parrot_pcc_get_continuation(interp, CURRENT_CONTEXT(interp));
 387             next = VTABLE_invoke(INTERP, cont, next);
 388         }
 389
 390         return (opcode_t *)next;
 391     }
 392
 393 /*
 394
 395 =item C<INTVAL get_integer()>
 396
 397 Returns the function pointer as an integer.
 398
 399 =cut
 400
 401 */
 402
 403     VTABLE INTVAL get_integer() {
 404         Parrot_NCI_attributes * const nci_info = PARROT_NCI(SELF);
 405         if (!nci_info->func)
 406             build_func(INTERP, nci_info);
 407         return (INTVAL)nci_info->func;
 408     }
 409
 410 /*
 411
 412 =item C<INTVAL get_bool()>
 413
 414 Returns the boolean value of the pointer.
 415
 416 =cut
 417
 418 */
 419
 420     VTABLE INTVAL get_bool() {
 421         Parrot_NCI_attributes * const nci_info = PARROT_NCI(SELF);
 422         return (0 != (INTVAL)nci_info->orig_func);
 423     }
 424
 425 /*
 426
 427 =item C<METHOD arity()>
 428
 429 Return the arity of the NCI (the number of arguments).
 430
 431 =cut
 432
 433 */
 434     METHOD arity() {
 435         Parrot_NCI_attributes * const nci_info = PARROT_NCI(SELF);
 436         INTVAL arity = 0;
 437
 438         if (nci_info) {
 439             if (!nci_info->func)
 440                 build_func(INTERP, nci_info);
 441             if (nci_info->func) {
 442                 arity = nci_info->arity;
 443                 RETURN(INTVAL arity);
 444             }
 445         }
 446
 447         Parrot_ex_throw_from_c_args(INTERP, NULL,
 448             EXCEPTION_INVALID_OPERATION,
 449             "You cannot get the arity of an undefined NCI.");
 450     }
 451 }
 452
 453 /*
 454
 455 =back
 456
 457 =head1 SEE ALSO
 458
 459 F<docs/pdds/pdd03_calling_conventions.pod>.
 460
 461 =head1 HISTORY
 462
 463 Initial revision by sean 2002/08/04.
 464
 465 =cut
 466
 467 */
 468
 469 /*
 470  * Local variables:
 471  *   c-file-style: "parrot"
 472  * End:
 473  * vim: expandtab shiftwidth=4:
 474  */