void runtime_goenvs_unix(void) { String *s; int32 i, n; for(n=0; argv[argc+1+n] != 0; n++) ; s = runtime_malloc(n*sizeof s[0]); for(i=0; i<n; i++) s[i] = runtime_gostringnocopy(argv[argc+1+i]); syscall_Envs.__values = (void*)s; syscall_Envs.__count = n; syscall_Envs.__capacity = n; }
void runtime_goargs(void) { String *s; int32 i; // for windows implementation see "os" package if(Windows) return; s = runtime_malloc(argc*sizeof s[0]); for(i=0; i<argc; i++) s[i] = runtime_gostringnocopy((const byte*)argv[i]); os_Args.__values = (void*)s; os_Args.__count = argc; os_Args.__capacity = argc; }
static int callback (void *data, uintptr_t pc, const char *filename, int lineno, const char *function) { struct callers_data *arg = (struct callers_data *) data; Location *loc; /* Skip split stack functions. */ if (function != NULL) { const char *p; p = function; if (__builtin_strncmp (p, "___", 3) == 0) ++p; if (__builtin_strncmp (p, "__morestack_", 12) == 0) return 0; } else if (filename != NULL) { const char *p; p = strrchr (filename, '/'); if (p == NULL) p = filename; if (__builtin_strncmp (p, "/morestack.S", 12) == 0) return 0; } /* Skip thunks and recover functions. There is no equivalent to these functions in the gc toolchain, so returning them here means significantly different results for runtime.Caller(N). */ if (function != NULL) { const char *p; p = __builtin_strchr (function, '.'); if (p != NULL && __builtin_strncmp (p + 1, "$thunk", 6) == 0) return 0; p = __builtin_strrchr (function, '$'); if (p != NULL && __builtin_strcmp(p, "$recover") == 0) return 0; } if (arg->skip > 0) { --arg->skip; return 0; } loc = &arg->locbuf[arg->index]; loc->pc = pc; /* The libbacktrace library says that these strings might disappear, but with the current implementation they won't. We can't easily allocate memory here, so for now assume that we can save a pointer to the strings. */ loc->filename = runtime_gostringnocopy ((const byte *) filename); loc->function = runtime_gostringnocopy ((const byte *) function); loc->lineno = lineno; ++arg->index; return arg->index >= arg->max; }
static int callback (void *data, uintptr_t pc, const char *filename, int lineno, const char *function) { struct callers_data *arg = (struct callers_data *) data; Location *loc; /* Skip split stack functions. */ if (function != NULL) { const char *p; p = function; if (__builtin_strncmp (p, "___", 3) == 0) ++p; if (__builtin_strncmp (p, "__morestack_", 12) == 0) return 0; } else if (filename != NULL) { const char *p; p = strrchr (filename, '/'); if (p == NULL) p = filename; if (__builtin_strncmp (p, "/morestack.S", 12) == 0) return 0; } /* Skip thunks and recover functions. There is no equivalent to these functions in the gc toolchain, so returning them here means significantly different results for runtime.Caller(N). */ if (function != NULL) { const char *p; p = __builtin_strchr (function, '.'); if (p != NULL && __builtin_strncmp (p + 1, "$thunk", 6) == 0) return 0; p = __builtin_strrchr (function, '$'); if (p != NULL && __builtin_strcmp(p, "$recover") == 0) return 0; } if (arg->skip > 0) { --arg->skip; return 0; } loc = &arg->locbuf[arg->index]; loc->pc = pc; /* The libbacktrace library says that these strings might disappear, but with the current implementation they won't. We can't easily allocate memory here, so for now assume that we can save a pointer to the strings. */ loc->filename = runtime_gostringnocopy ((const byte *) filename); loc->function = runtime_gostringnocopy ((const byte *) function); loc->lineno = lineno; ++arg->index; /* There is no point to tracing past certain runtime functions. Stopping the backtrace here can avoid problems on systems that don't provide proper unwind information for makecontext, such as Solaris (http://gcc.gnu.org/PR52583 comment #21). */ if (function != NULL) { if (__builtin_strcmp (function, "makecontext") == 0) return 1; if (filename != NULL) { const char *p; p = strrchr (filename, '/'); if (p == NULL) p = filename; if (__builtin_strcmp (p, "/proc.c") == 0) { if (__builtin_strcmp (function, "kickoff") == 0 || __builtin_strcmp (function, "runtime_mstart") == 0 || __builtin_strcmp (function, "runtime_main") == 0) return 1; } } } return arg->index >= arg->max; }