Index: gcc/go/go-gcc.cc =================================================================== --- gcc/go/go-gcc.cc (revision 193595) +++ gcc/go/go-gcc.cc (working copy) @@ -28,6 +28,7 @@ #include "tree-iterator.h" #include "gimple.h" #include "toplev.h" +#include "output.h" #include "go-c.h" @@ -267,6 +268,7 @@ class Gcc_backend : public Backend Btype* btype, bool is_external, bool is_hidden, + bool in_unique_section, Location location); void @@ -1277,6 +1279,7 @@ Gcc_backend::global_variable(const std:: Btype* btype, bool is_external, bool is_hidden, + bool in_unique_section, Location location) { tree type_tree = btype->get_tree(); @@ -1308,6 +1311,9 @@ Gcc_backend::global_variable(const std:: } TREE_USED(decl) = 1; + if (in_unique_section) + resolve_unique_section (decl, 0, 1); + go_preserve_from_gc(decl); return new Bvariable(decl); @@ -1326,6 +1332,16 @@ Gcc_backend::global_variable_set_init(Bv if (var_decl == error_mark_node) return; DECL_INITIAL(var_decl) = expr_tree; + + // If this variable goes in a unique section, it may need to go into + // a different one now that DECL_INITIAL is set. + if (DECL_HAS_IMPLICIT_SECTION_NAME_P (var_decl)) + { + DECL_SECTION_NAME (var_decl) = NULL_TREE; + resolve_unique_section (var_decl, + compute_reloc_for_constant (expr_tree), + 1); + } } // Make a local variable. Index: gcc/go/Make-lang.in =================================================================== --- gcc/go/Make-lang.in (revision 193595) +++ gcc/go/Make-lang.in (working copy) @@ -1,6 +1,6 @@ # Make-lang.in -- Top level -*- makefile -*- fragment for gcc Go frontend. -# Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc. +# Copyright (C) 2009, 2010, 2011, 2012 Free Software Foundation, Inc. # This file is part of GCC. @@ -254,7 +254,7 @@ go/go-lang.o: go/go-lang.c $(CONFIG_H) $ GOINCLUDES = -I $(srcdir)/go -I $(srcdir)/go/gofrontend go/go-gcc.o: go/go-gcc.cc $(GO_SYSTEM_H) $(TREE_H) tree-iterator.h \ - $(GIMPLE_H) toplev.h $(GO_C_H) $(GO_GOGO_H) \ + $(GIMPLE_H) toplev.h output.h $(GO_C_H) $(GO_GOGO_H) \ go/gofrontend/backend.h $(CXX) -c $(GOINCLUDES) $(ALL_CPPFLAGS) $(ALL_CXXFLAGS) $< $(OUTPUT_OPTION) Index: gcc/go/gofrontend/gogo.cc =================================================================== --- gcc/go/gofrontend/gogo.cc (revision 193874) +++ gcc/go/gofrontend/gogo.cc (working copy) @@ -3075,7 +3075,8 @@ Function::Function(Function_type* type, closure_var_(NULL), block_(block), location_(location), labels_(), local_type_count_(0), fndecl_(NULL), defer_stack_(NULL), results_are_named_(false), nointerface_(false), calls_recover_(false), - is_recover_thunk_(false), has_recover_thunk_(false) + is_recover_thunk_(false), has_recover_thunk_(false), + in_unique_section_(false) { } @@ -3896,7 +3897,7 @@ Variable::Variable(Type* type, Expressio seen_(false), init_is_lowered_(false), type_from_init_tuple_(false), type_from_range_index_(false), type_from_range_value_(false), type_from_chan_element_(false), is_type_switch_var_(false), - determined_type_(false) + determined_type_(false), in_unique_section_(false) { go_assert(type != NULL || init != NULL); go_assert(!is_parameter || init == NULL); @@ -4315,6 +4316,7 @@ Variable::get_backend_variable(Gogo* gog btype, package != NULL, Gogo::is_hidden_name(name), + this->in_unique_section_, this->location_); else if (function == NULL) { Index: gcc/go/gofrontend/runtime.def =================================================================== --- gcc/go/gofrontend/runtime.def (revision 193595) +++ gcc/go/gofrontend/runtime.def (working copy) @@ -354,6 +354,10 @@ DEF_GO_RUNTIME(PRINT_SPACE, "__go_print_ DEF_GO_RUNTIME(PRINT_NL, "__go_print_nl", P0(), R0()) +// Used for field tracking for data analysis. +DEF_GO_RUNTIME(FIELDTRACK, "__go_fieldtrack", P1(POINTER), R0()) + + // Remove helper macros. #undef ABFT6 #undef ABFT2 Index: gcc/go/gofrontend/gogo.h =================================================================== --- gcc/go/gofrontend/gogo.h (revision 193874) +++ gcc/go/gofrontend/gogo.h (working copy) @@ -1032,6 +1032,11 @@ class Function set_has_recover_thunk() { this->has_recover_thunk_ = true; } + // Mark the function as going into a unique section. + void + set_in_unique_section() + { this->in_unique_section_ = true; } + // Swap with another function. Used only for the thunk which calls // recover. void @@ -1139,6 +1144,9 @@ class Function bool is_recover_thunk_; // True if this function already has a recover thunk. bool has_recover_thunk_; + // True if this function should be put in a unique section. This is + // turned on for field tracking. + bool in_unique_section_ : 1; }; // A snapshot of the current binding state. @@ -1414,6 +1422,14 @@ class Variable set_is_type_switch_var() { this->is_type_switch_var_ = true; } + // Mark the variable as going into a unique section. + void + set_in_unique_section() + { + go_assert(this->is_global_); + this->in_unique_section_ = true; + } + // Traverse the initializer expression. int traverse_expression(Traverse*, unsigned int traverse_mask); @@ -1504,6 +1520,9 @@ class Variable bool is_type_switch_var_ : 1; // True if we have determined types. bool determined_type_ : 1; + // True if this variable should be put in a unique section. This is + // used for field tracking. + bool in_unique_section_ : 1; }; // A variable which is really the name for a function return value, or Index: gcc/go/gofrontend/expressions.h =================================================================== --- gcc/go/gofrontend/expressions.h (revision 193595) +++ gcc/go/gofrontend/expressions.h (working copy) @@ -1842,7 +1842,7 @@ class Field_reference_expression : publi Field_reference_expression(Expression* expr, unsigned int field_index, Location location) : Expression(EXPRESSION_FIELD_REFERENCE, location), - expr_(expr), field_index_(field_index) + expr_(expr), field_index_(field_index), called_fieldtrack_(false) { } // Return the struct expression. @@ -1868,6 +1868,9 @@ class Field_reference_expression : publi do_traverse(Traverse* traverse) { return Expression::traverse(&this->expr_, traverse); } + Expression* + do_lower(Gogo*, Named_object*, Statement_inserter*, int); + Type* do_type(); @@ -1906,6 +1909,8 @@ class Field_reference_expression : publi Expression* expr_; // The zero-based index of the field we are retrieving. unsigned int field_index_; + // Whether we have already emitted a fieldtrack call. + bool called_fieldtrack_; }; // A reference to a field of an interface. Index: gcc/go/gofrontend/gogo-tree.cc =================================================================== --- gcc/go/gofrontend/gogo-tree.cc (revision 193596) +++ gcc/go/gofrontend/gogo-tree.cc (working copy) @@ -1316,6 +1316,9 @@ Function::get_or_make_decl(Gogo* gogo, N DECL_ATTRIBUTES(decl) = tree_cons(attr, NULL_TREE, NULL_TREE); } + if (this->in_unique_section_) + resolve_unique_section (decl, 0, 1); + go_preserve_from_gc(decl); if (this->closure_var_ != NULL) Index: gcc/go/gofrontend/backend.h =================================================================== --- gcc/go/gofrontend/backend.h (revision 193595) +++ gcc/go/gofrontend/backend.h (working copy) @@ -326,8 +326,11 @@ class Backend // option. NAME is the name of the variable. BTYPE is the type of // the variable. IS_EXTERNAL is true if the variable is defined in // some other package. IS_HIDDEN is true if the variable is not - // exported (name begins with a lower case letter). LOCATION is - // where the variable was defined. + // exported (name begins with a lower case letter). + // IN_UNIQUE_SECTION is true if the variable should be put into a + // unique section if possible; this is intended to permit the linker + // to garbage collect the variable if it is not referenced. + // LOCATION is where the variable was defined. virtual Bvariable* global_variable(const std::string& package_name, const std::string& pkgpath, @@ -335,6 +338,7 @@ class Backend Btype* btype, bool is_external, bool is_hidden, + bool in_unique_section, Location location) = 0; // A global variable will 1) be initialized to zero, or 2) be Index: gcc/go/gofrontend/expressions.cc =================================================================== --- gcc/go/gofrontend/expressions.cc (revision 193596) +++ gcc/go/gofrontend/expressions.cc (working copy) @@ -10580,6 +10580,102 @@ Expression::make_map_index(Expression* m // Class Field_reference_expression. +// Lower a field reference expression. There is nothing to lower, but +// this is where we generate the tracking information for fields with +// the magic go:"track" tag. + +Expression* +Field_reference_expression::do_lower(Gogo* gogo, Named_object* function, + Statement_inserter* inserter, int) +{ + Struct_type* struct_type = this->expr_->type()->struct_type(); + if (struct_type == NULL) + { + // Error will be reported elsewhere. + return this; + } + const Struct_field* field = struct_type->field(this->field_index_); + if (field == NULL) + return this; + if (!field->has_tag()) + return this; + if (field->tag().find("go:\"track\"") == std::string::npos) + return this; + + // We have found a reference to a tracked field. Build a call to + // the runtime function __go_fieldtrack with a string that describes + // the field. FIXME: We should only call this once per referenced + // field per function, not once for each reference to the field. + + if (this->called_fieldtrack_) + return this; + this->called_fieldtrack_ = true; + + Location loc = this->location(); + + std::string s = "fieldtrack \""; + Named_type* nt = this->expr_->type()->named_type(); + if (nt == NULL || nt->named_object()->package() == NULL) + s.append(gogo->pkgpath()); + else + s.append(nt->named_object()->package()->pkgpath()); + s.push_back('.'); + if (nt != NULL) + s.append(nt->name()); + s.push_back('.'); + s.append(field->field_name()); + s.push_back('"'); + + // We can't use a string here, because internally a string holds a + // pointer to the actual bytes; when the linker garbage collects the + // string, it won't garbage collect the bytes. So we use a + // [...]byte. + + mpz_t val; + mpz_init_set_ui(val, s.length()); + Expression* length_expr = Expression::make_integer(&val, NULL, loc); + mpz_clear(val); + + Type* byte_type = gogo->lookup_global("byte")->type_value(); + Type* array_type = Type::make_array_type(byte_type, length_expr); + + Expression_list* bytes = new Expression_list(); + for (std::string::const_iterator p = s.begin(); p != s.end(); p++) + { + mpz_init_set_ui(val, *p); + Expression* byte = Expression::make_integer(&val, NULL, loc); + mpz_clear(val); + bytes->push_back(byte); + } + + Expression* e = Expression::make_composite_literal(array_type, 0, false, + bytes, loc); + + Variable* var = new Variable(array_type, e, true, false, false, loc); + + static int count; + char buf[50]; + snprintf(buf, sizeof buf, "fieldtrack.%d", count); + ++count; + + Named_object* no = gogo->add_variable(buf, var); + e = Expression::make_var_reference(no, loc); + e = Expression::make_unary(OPERATOR_AND, e, loc); + + Expression* call = Runtime::make_call(Runtime::FIELDTRACK, loc, 1, e); + inserter->insert(Statement::make_statement(call, false)); + + // Put this function, and the global variable we just created, into + // unique sections. This will permit the linker to garbage collect + // them if they are not referenced. The effect is that the only + // strings, indicating field references, that will wind up in the + // executable will be those for functions that are actually needed. + function->func_value()->set_in_unique_section(); + var->set_in_unique_section(); + + return this; +} + // Return the type of a field reference. Type* Index: libgo/runtime/go-fieldtrack.c =================================================================== --- libgo/runtime/go-fieldtrack.c (revision 0) +++ libgo/runtime/go-fieldtrack.c (revision 0) @@ -0,0 +1,101 @@ +/* go-fieldtrack.c -- structure field data analysis. + + Copyright 2012 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 "runtime.h" +#include "go-type.h" +#include "map.h" + +/* The compiler will track fields that have the tag go:"track". Any + function that refers to such a field will call this function with a + string + fieldtrack "package.type.field" + + This function does not actually do anything. Instead, we gather + the field tracking information by looking for strings of that form + in the read-only data section. This is, of course, a horrible + hack, but it's good enough for now. We can improve it, e.g., by a + linker plugin, if this turns out to be useful. */ + +void +__go_fieldtrack (byte *p __attribute__ ((unused))) +{ +} + +/* A runtime function to add all the tracked fields to a + map[string]bool. */ + +extern const char _etext[] __attribute__ ((weak)); +extern const char __etext[] __attribute__ ((weak)); +extern const char __data_start[] __attribute__ ((weak)); +extern const char _edata[] __attribute__ ((weak)); +extern const char __edata[] __attribute__ ((weak)); +extern const char __bss_start[] __attribute__ ((weak)); + +void runtime_Fieldtrack (struct __go_map *) __asm__ ("runtime.Fieldtrack"); + +void +runtime_Fieldtrack (struct __go_map *m) +{ + const char *p; + const char *pend; + const char *prefix; + size_t prefix_len; + + p = __data_start; + if (p == NULL) + p = __etext; + if (p == NULL) + p = _etext; + if (p == NULL) + return; + + pend = __edata; + if (pend == NULL) + pend = _edata; + if (pend == NULL) + pend = __bss_start; + if (pend == NULL) + return; + + prefix = "fieldtrack "; + prefix_len = __builtin_strlen (prefix); + + while (p < pend) + { + const char *q1; + const char *q2; + + q1 = __builtin_memchr (p + prefix_len, '"', pend - (p + prefix_len)); + if (q1 == NULL) + break; + + if (__builtin_memcmp (q1 - prefix_len, prefix, prefix_len) != 0) + { + p = q1 + 1; + continue; + } + + q1++; + q2 = __builtin_memchr (q1, '"', pend - q1); + if (q2 == NULL) + break; + + if (__builtin_memchr (q1, '\0', q2 - q1) == NULL) + { + String s; + void *v; + _Bool *pb; + + s.str = (const byte *) q1; + s.len = q2 - q1; + v = __go_map_index (m, &s, 1); + pb = (_Bool *) v; + *pb = 1; + } + + p = q2; + } +} Index: libgo/go/runtime/debug.go =================================================================== --- libgo/go/runtime/debug.go (revision 193688) +++ libgo/go/runtime/debug.go (working copy) @@ -168,3 +168,10 @@ func BlockProfile(p []BlockProfileRecord // If all is true, Stack formats stack traces of all other goroutines // into buf after the trace for the current goroutine. func Stack(buf []byte, all bool) int + +// Get field tracking information. Only fields with a tag go:"track" +// are tracked. This function will add every such field that is +// referenced to the map. The keys in the map will be +// PkgPath.Name.FieldName. The value will be true for each field +// added. +func Fieldtrack(map[string]bool) Index: libgo/Makefile.am =================================================================== --- libgo/Makefile.am (revision 193688) +++ libgo/Makefile.am (working copy) @@ -450,6 +450,7 @@ runtime_files = \ runtime/go-deferred-recover.c \ runtime/go-eface-compare.c \ runtime/go-eface-val-compare.c \ + runtime/go-fieldtrack.c \ runtime/go-getgoroot.c \ runtime/go-int-array-to-string.c \ runtime/go-int-to-string.c \