Subversion Repositories openrisc

// runtime.cc -- runtime functions called by generated code

// Copyright 2011 The Go Authors. All rights reserved.

// Use of this source code is governed by a BSD-style

// license that can be found in the LICENSE file.

#include "go-system.h"

#include <gmp.h>

#include "gogo.h"

#include "types.h"

#include "expressions.h"

#include "runtime.h"

// The frontend generates calls to various runtime functions.  They

// are implemented in libgo/runtime.  This is how the runtime

// functions are represented in the frontend.  Note that there is

// currently nothing which ensures that the compiler's understanding

// of the runtime function matches the actual implementation in

// libgo/runtime.

// Parameter and result types used by runtime functions.

enum Runtime_function_type

{

  // General indicator that value is not used.

  RFT_VOID,

  // Go type bool, C type _Bool.

  RFT_BOOL,

  // Go type *bool, C type _Bool*.

  RFT_BOOLPTR,

  // Go type int, C type int.

  RFT_INT,

  // Go type int64, C type int64_t.

  RFT_INT64,

  // Go type uint64, C type uint64_t.

  RFT_UINT64,

  // Go type uintptr, C type uintptr_t.

  RFT_UINTPTR,

  // Go type rune, C type int32_t.

  RFT_RUNE,

  // Go type float64, C type double.

  RFT_FLOAT64,

  // Go type complex128, C type __complex double.

  RFT_COMPLEX128,

  // Go type string, C type struct __go_string.

  RFT_STRING,

  // Go type unsafe.Pointer, C type "void *".

  RFT_POINTER,

  // Go type []any, C type struct __go_open_array.

  RFT_SLICE,

  // Go type map[any]any, C type struct __go_map *.

  RFT_MAP,

  // Pointer to map iteration type.

  RFT_MAPITER,

  // Go type chan any, C type struct __go_channel *.

  RFT_CHAN,

  // Go type non-empty interface, C type struct __go_interface.

  RFT_IFACE,

  // Go type interface{}, C type struct __go_empty_interface.

  RFT_EFACE,

  // Go type func(unsafe.Pointer), C type void (*) (void *).

  RFT_FUNC_PTR,

  // Pointer to Go type descriptor.

  RFT_TYPE,

  // Pointer to map descriptor.

  RFT_MAPDESCRIPTOR,

  NUMBER_OF_RUNTIME_FUNCTION_TYPES

};

// The Type structures for the runtime function types.

static Type* runtime_function_types[NUMBER_OF_RUNTIME_FUNCTION_TYPES];

// Get the Type for a Runtime_function_type code.

static Type*

runtime_function_type(Runtime_function_type bft)

{

  go_assert(bft < NUMBER_OF_RUNTIME_FUNCTION_TYPES);

  if (runtime_function_types[bft] == NULL)

    {

      const Location bloc = Linemap::predeclared_location();

      Type* t;

      switch (bft)

        {

        default:

        case RFT_VOID:

          go_unreachable();

        case RFT_BOOL:

          t = Type::lookup_bool_type();

          break;

        case RFT_BOOLPTR:

          t = Type::make_pointer_type(Type::lookup_bool_type());

          break;

        case RFT_INT:

          t = Type::lookup_integer_type("int");

          break;

        case RFT_INT64:

          t = Type::lookup_integer_type("int64");

          break;

        case RFT_UINT64:

          t = Type::lookup_integer_type("uint64");

          break;

        case RFT_RUNE:

          t = Type::lookup_integer_type("int32");

          break;

        case RFT_UINTPTR:

          t = Type::lookup_integer_type("uintptr");

          break;

        case RFT_FLOAT64:

          t = Type::lookup_float_type("float64");

          break;

        case RFT_COMPLEX128:

          t = Type::lookup_complex_type("complex128");

          break;

        case RFT_STRING:

          t = Type::lookup_string_type();

          break;

        case RFT_POINTER:

          t = Type::make_pointer_type(Type::make_void_type());

          break;

        case RFT_SLICE:

          t = Type::make_array_type(Type::make_void_type(), NULL);

          break;

        case RFT_MAP:

          t = Type::make_map_type(Type::make_void_type(),

                                  Type::make_void_type(),

                                  bloc);

          break;

        case RFT_MAPITER:

          t = Type::make_pointer_type(Runtime::map_iteration_type());

          break;

        case RFT_CHAN:

          t = Type::make_channel_type(true, true, Type::make_void_type());

          break;

        case RFT_IFACE:

          {

            Typed_identifier_list* methods = new Typed_identifier_list();

            Type* mtype = Type::make_function_type(NULL, NULL, NULL, bloc);

            methods->push_back(Typed_identifier("x", mtype, bloc));

            Interface_type* it = Type::make_interface_type(methods, bloc);

            it->finalize_methods();

            t = it;

          }

          break;

        case RFT_EFACE:

          t = Type::make_empty_interface_type(bloc);

          break;

        case RFT_FUNC_PTR:

          {

            Typed_identifier_list* param_types = new Typed_identifier_list();

            Type* ptrtype = runtime_function_type(RFT_POINTER);

            param_types->push_back(Typed_identifier("", ptrtype, bloc));

            t = Type::make_function_type(NULL, param_types, NULL, bloc);

          }

          break;

        case RFT_TYPE:

          t = Type::make_type_descriptor_ptr_type();

          break;

        case RFT_MAPDESCRIPTOR:

          t = Type::make_pointer_type(Map_type::make_map_descriptor_type());

          break;

        }

      runtime_function_types[bft] = t;

    }

  return runtime_function_types[bft];

}

// Convert an expression to the type to pass to a runtime function.

static Expression*

convert_to_runtime_function_type(Runtime_function_type bft, Expression* e,

                                 Location loc)

{

  switch (bft)

    {

    default:

    case RFT_VOID:

      go_unreachable();

    case RFT_BOOL:

    case RFT_BOOLPTR:

    case RFT_INT:

    case RFT_INT64:

    case RFT_UINT64:

    case RFT_UINTPTR:

    case RFT_RUNE:

    case RFT_FLOAT64:

    case RFT_COMPLEX128:

    case RFT_STRING:

    case RFT_POINTER:

    case RFT_MAPITER:

    case RFT_FUNC_PTR:

      {

        Type* t = runtime_function_type(bft);

        if (!Type::are_identical(t, e->type(), true, NULL))

          e = Expression::make_cast(t, e, loc);

        return e;

      }

    case RFT_SLICE:

    case RFT_MAP:

    case RFT_CHAN:

    case RFT_IFACE:

    case RFT_EFACE:

      return Expression::make_unsafe_cast(runtime_function_type(bft), e, loc);

    case RFT_TYPE:

      go_assert(e->type() == Type::make_type_descriptor_ptr_type());

      return e;

    case RFT_MAPDESCRIPTOR:

      go_assert(e->type()->points_to()

                == Map_type::make_map_descriptor_type());

      return e;

    }

}

// Convert all the types used for runtime functions to the backend

// representation.

void

Runtime::convert_types(Gogo* gogo)

{

  for (int i = 0; i < static_cast<int>(NUMBER_OF_RUNTIME_FUNCTION_TYPES); ++i)

    {

      Type* t = runtime_function_types[i];

      if (t != NULL && t->named_type() != NULL)

        {

          bool r = t->verify();

          go_assert(r);

          t->named_type()->convert(gogo);

        }

    }

}

// The type used to define a runtime function.

struct Runtime_function

{

  // Function name.

  const char* name;

  // Parameter types.  Never more than 6, as it happens.  RFT_VOID if

  // not used.

  Runtime_function_type parameter_types[6];

  // Result types.  Never more than 2, as it happens.  RFT_VOID if not

  // used.

  Runtime_function_type result_types[2];

};

static const Runtime_function runtime_functions[] =

{

#define DEF_GO_RUNTIME(CODE, NAME, PARAMS, RESULTS) { NAME, PARAMS, RESULTS } ,

#include "runtime.def"

#undef DEF_GO_RUNTIME

};

static Named_object*

runtime_function_declarations[Runtime::NUMBER_OF_FUNCTIONS];

// Get the declaration of a runtime function.

Named_object*

Runtime::runtime_declaration(Function code)

{

  go_assert(code < Runtime::NUMBER_OF_FUNCTIONS);

  if (runtime_function_declarations[code] == NULL)

    {

      const Runtime_function* pb = &runtime_functions[code];

      Location bloc = Linemap::predeclared_location();

      Typed_identifier_list* param_types = NULL;

      if (pb->parameter_types[0] != RFT_VOID)

        {

          param_types = new Typed_identifier_list();

          for (unsigned int i = 0;

               i < (sizeof(pb->parameter_types)

                    / sizeof (pb->parameter_types[0]));

               i++)

            {

              if (pb->parameter_types[i] == RFT_VOID)

                break;

              Type* t = runtime_function_type(pb->parameter_types[i]);

              param_types->push_back(Typed_identifier("", t, bloc));

            }

        }

      Typed_identifier_list* result_types = NULL;

      if (pb->result_types[0] != RFT_VOID)

        {

          result_types = new Typed_identifier_list();

          for (unsigned int i = 0;

               i < sizeof(pb->result_types) / sizeof(pb->result_types[0]);

               i++)

            {

              if (pb->result_types[i] == RFT_VOID)

                break;

              Type* t = runtime_function_type(pb->result_types[i]);

              result_types->push_back(Typed_identifier("", t, bloc));

            }

        }

      Function_type* fntype = Type::make_function_type(NULL, param_types,

                                                       result_types, bloc);

      const char* n = pb->name;

      const char* n1 = strchr(n, '.');

      if (n1 != NULL)

        n = n1 + 1;

      Named_object* no = Named_object::make_function_declaration(n, NULL,

                                                                 fntype, bloc);

      no->func_declaration_value()->set_asm_name(pb->name);

      runtime_function_declarations[code] = no;

    }

  return runtime_function_declarations[code];

}

// Make a call to a runtime function.

Call_expression*

Runtime::make_call(Runtime::Function code, Location loc,

                   int param_count, ...)

{

  go_assert(code < Runtime::NUMBER_OF_FUNCTIONS);

  const Runtime_function* pb = &runtime_functions[code];

  go_assert(static_cast<size_t>(param_count)

             <= sizeof(pb->parameter_types) / sizeof(pb->parameter_types[0]));

  Named_object* no = runtime_declaration(code);

  Expression* func = Expression::make_func_reference(no, NULL, loc);

  Expression_list* args = new Expression_list();

  args->reserve(param_count);

  va_list ap;

  va_start(ap, param_count);

  for (int i = 0; i < param_count; ++i)

    {

      Expression* e = va_arg(ap, Expression*);

      Runtime_function_type rft = pb->parameter_types[i];

      args->push_back(convert_to_runtime_function_type(rft, e, loc));

    }

  va_end(ap);

  return Expression::make_call(func, args, false, loc);

}

// The type we use for a map iteration.  This is really a struct which

// is four pointers long.  This must match the runtime struct

// __go_hash_iter.

Type*

Runtime::map_iteration_type()

{

  const unsigned long map_iteration_size = 4;

  mpz_t ival;

  mpz_init_set_ui(ival, map_iteration_size);

  Expression* iexpr = Expression::make_integer(&ival, NULL,

                                               Linemap::predeclared_location());

  mpz_clear(ival);

  return Type::make_array_type(runtime_function_type(RFT_POINTER), iexpr);

}