go/gofrontend/expressions.cc

226   // Otherwise it is the interface method table for RHS_TYPE.
314   // method table to match it up with the interface methods.
389   // If the value is a pointer, then it is the value we want.
390   // Otherwise it points to the value.
401 // the child class.  Not that it is not in general safe to call this multiple
663   // However, it can happen, at least when we have an invalid const
1029 // a function seems like it could work, though there might be little
1030 // point to it.
1090 // we take the address of a function rather than simply calling it.  A func
1265 // Make the function descriptor type, so that it can be converted.
2552   // Whether we found it.
2613   // expression, we export the value.  We ignore the fact that it has
2986 // it should have.
3656   // moving x to the heap.  FIXME: Is it worth doing a real escape
3778       // Taking the address of a variable is constant if it is a
3877 	    // The number of HOST_WIDE_INTs that it takes to represent
3947 // Return the integral constant value of a unary expression, if it has one.
4173 	      // value initializer may have to be copied to the heap if it
4183 	      // rather than copying it.  In that case we can't make it
4184 	      // read-only, because the program is permitted to change it.
4375       // May be a type error--let it be diagnosed elsewhere.
5265 // Return the numeric constant value, if it has one.
6118       // address if it is not a pointer.
6306 // If a bound method expression is not simply called, then it is
6353   // The type here is wrong--it should be the C function type.  But it
6465   // FIXME: We should lower this earlier, but we can't lower it in the
6491   // that is not NULL).  We are going to pass it a closure whose
6517       // because in the lowering pass we forced it into a temporary
6676   // variable, or passing it around everywhere.
6799 	  // it must not be reached through pointer indirections.
6895 	    // Since this function returns no value it must appear in
6897 	    // order of evaluation of values around it.  Evaluate the
7177 // to float64, so it has to be done by name.  This returns NULL if it
7428 	      // the type of f when it is used as a field in a struct.
7753 	      // an integer if we know it is nonnegative, otherwise
7905 		    // If this is a type expression it's going to give
8309 	// because it changes whether it can recover a panic or not.
8522 // calling it, the backend type of that function is actually a struct.
8537 // function code such that it expects an additional final argument of
8552 // the closure, even though it is the last argument, because that will
8557 // points to the closure, ignores it, and calls the real function as a
8562 // it; 2) GCC only permits using a static chain to call a known
8563 // function, so we can't use it for an indirect call anyhow.  Since we
8564 // can't use it for an indirect call, we may as well not worry about
8565 // using it for a direct call either.
8567 // We pass the closure last rather than first because it means that
8590   // that type.  We don't traverse this->type_ because it may be a
8723 	  // take the address.  We can't do that here because it will
8763 // which the call occurs--it's not the function we are calling.
9020 // we should report it.
9204   // we don't have to worry about it here unless something is wrong.
9232       // results can be matched to parameters, it would have been
9281 // results then it will inevitably be executed last.
9651 // call expression.  We don't do this at lowering time because it makes it
9679   // FIXME: Wouldn't it be better if the call is assigned to a temporary
9745       // dereferenced.  For a slice it will not--the resulting slice
9899   // index, or it may be a nil expression for the length of the array.
10409   // or it may be a nil expression for the length of the string.
10664 // temporary variable if it isn't already.  The value pointer will be
10920   // string, it won't garbage collect the bytes.  So we use a
11145 // If an interface field reference is not simply called, then it is
11192   // The type here is wrong--it should be the C function type.  But it
11280   // FIXME: We should lower this earlier, but we can't it lower it in
11425       Interface_type* it = nt->interface_type();
11426       if (it != NULL)
11427 	imethod = it->find_method(name);
11514   // FIXME: This optimization is disabled because it doesn't yet work
11542   // Even though we found the method above, if it has an error type we
13057 	      // different package than the struct it is a part of, do not count
13154 	  // A predefined name won't be packed.  If it starts with a
13393 	  Integer_type* it = Type::lookup_integer_type("int")->integer_type();
13394 	  if (sizeof(size) <= static_cast<size_t>(it->bits() * 8)
13395 	      && size >> (it->bits() - 1) != 0)
13471 	  // Make sure we have lowered the key; it may not have been
13473 	  // literals.  Lower it now to get the right error message.
13695 // When you take the address of an escaping expression, it is allocated