Add a flag -fgo-debug-escape-hash for debugging escape analysis.
It takes a binary string, optionally led by a "-", as argument.
When specified, the escape analysis runs only on functions whose
name is hashed to a value with matching suffix. The "-" sign
negates the match, i.e. the analysis runs only on functions with
non-matching hash.
Reviewed-on: https://go-review.googlesource.com/83878
* lang.opt (fgo-debug-escape-hash): New option.
* go-c.h (struct go_create_gogo_args): Add debug_escape_hash
field.
* go-lang.c (go_langhook_init): Set debug_escape_hash field.
* gccgo.texi (Invoking gccgo): Document -fgo-debug-escape-hash.
From-SVN: r256393
+2018-01-09 Cherry Zhang <cherryyz@google.com>
+
+ * lang.opt (fgo-debug-escape-hash): New option.
+ * go-c.h (struct go_create_gogo_args): Add debug_escape_hash
+ field.
+ * go-lang.c (go_langhook_init): Set debug_escape_hash field.
+ * gccgo.texi (Invoking gccgo): Document -fgo-debug-escape-hash.
+
2018-01-05 Ian Lance Taylor <iant@golang.org>
* go-gcc.cc (Gcc_backend::Gcc_backend): Correct
Output escape analysis debugging information. Larger values of
@var{n} generate more information.
+@item -fgo-debug-escape-hash=@var{n}
+@cindex @option{-fgo-debug-escape-hash}
+A hash value to debug escape analysis. @var{n} is a binary string.
+This runs escape analysis only on functions whose names hash to values
+that match the given suffix @var{n}. This can be used to binary
+search across functions to uncover escape analysis bugs.
+
@item -fgo-c-header=@var{file}
@cindex @option{-fgo-c-header}
Write top-level named Go struct definitions to @var{file} as C code.
bool check_divide_overflow;
bool compiling_runtime;
int debug_escape_level;
+ const char* debug_escape_hash;
int64_t nil_check_size_threshold;
};
args.check_divide_overflow = go_check_divide_overflow;
args.compiling_runtime = go_compiling_runtime;
args.debug_escape_level = go_debug_escape_level;
+ args.debug_escape_hash = go_debug_escape_hash;
args.nil_check_size_threshold = TARGET_AIX ? -1 : 4096;
args.linemap = go_get_linemap();
args.backend = go_get_backend();
#include "ast-dump.h"
#include "go-optimize.h"
#include "go-diagnostics.h"
+#include "go-sha1.h"
// class Node.
Go_optimize optimize_allocation_flag("allocs");
+// A helper function to compute whether a function name has a
+// matching hash value.
+
+static bool
+escape_hash_match(std::string suffix, std::string name)
+{
+ if (suffix.empty())
+ return true;
+ if (suffix.at(0) == '-')
+ return !escape_hash_match(suffix.substr(1), name);
+
+ const char* p = name.c_str();
+ Go_sha1_helper* sha1_helper = go_create_sha1_helper();
+ sha1_helper->process_bytes(p, strlen(p));
+ std::string s = sha1_helper->finish();
+ delete sha1_helper;
+
+ int j = suffix.size() - 1;
+ for (int i = s.size() - 1; i >= 0; i--)
+ {
+ char c = s.at(i);
+ for (int k = 0; k < 8; k++, j--, c>>=1)
+ {
+ if (j < 0)
+ return true;
+ char bit = suffix.at(j) - '0';
+ if ((c&1) != bit)
+ return false;
+ }
+ }
+ return false;
+}
+
// Analyze the program flow for escape information.
void
// information in this package.
this->discover_analysis_sets();
+ if (!this->debug_escape_hash().empty())
+ std::cerr << "debug-escape-hash " << this->debug_escape_hash() << "\n";
+
for (std::vector<Analysis_set>::iterator p = this->analysis_sets_.begin();
p != this->analysis_sets_.end();
++p)
{
std::vector<Named_object*> stack = p->first;
+
+ if (!this->debug_escape_hash().empty())
+ {
+ bool match = false;
+ for (std::vector<Named_object*>::const_iterator fn = stack.begin();
+ fn != stack.end();
+ ++fn)
+ match = match || escape_hash_match(this->debug_escape_hash(), (*fn)->message_name());
+ if (!match)
+ {
+ // Escape analysis won't run on these functions, but still
+ // need to tag them, so the caller knows.
+ for (std::vector<Named_object*>::iterator fn = stack.begin();
+ fn != stack.end();
+ ++fn)
+ if ((*fn)->is_function())
+ {
+ Function_type* fntype = (*fn)->func_value()->type();
+ fntype->set_is_tagged();
+
+ std::cerr << "debug-escape-hash disables " << debug_function_name(*fn) << "\n";
+ }
+
+ continue;
+ }
+ for (std::vector<Named_object*>::const_iterator fn = stack.begin();
+ fn != stack.end();
+ ++fn)
+ if ((*fn)->is_function())
+ std::cerr << "debug-escape-hash triggers " << debug_function_name(*fn) << "\n";
+ }
+
Escape_context* context = new Escape_context(this, p->second);
// Analyze the flow of each function; build the connection graph.
if (args->c_header != NULL)
::gogo->set_c_header(args->c_header);
::gogo->set_debug_escape_level(args->debug_escape_level);
+ if (args->debug_escape_hash != NULL)
+ ::gogo->set_debug_escape_hash(args->debug_escape_hash);
::gogo->set_nil_check_size_threshold(args->nil_check_size_threshold);
}
set_debug_escape_level(int level)
{ this->debug_escape_level_ = level; }
+ // Return the hash for debug escape analysis.
+ std::string
+ debug_escape_hash() const
+ { return this->debug_escape_hash_; }
+
+ // Set the hash value for debug escape analysis.
+ void
+ set_debug_escape_hash(const std::string& s)
+ { this->debug_escape_hash_ = s; }
+
// Return the size threshold used to determine whether to issue
// a nil-check for a given pointer dereference. A threshold of -1
// implies that all potentially faulting dereference ops should
// The level of escape analysis debug information to emit, from the
// -fgo-debug-escape option.
int debug_escape_level_;
+ // A hash value for debug escape analysis, from the
+ // -fgo-debug-escape-hash option. The analysis is run only on
+ // functions with names that hash to the matching value.
+ std::string debug_escape_hash_;
// Nil-check size threshhold.
int64_t nil_check_size_threshold_;
// A list of types to verify.
Go Joined UInteger Var(go_debug_escape_level) Init(0)
Emit debugging information related to the escape analysis pass when run with -fgo-optimize-allocs.
+fgo-debug-escape-hash=
+Go Joined RejectNegative Var(go_debug_escape_hash) Init(0)
+-fgo-debug-escape-hash=<string> Hash value to debug escape analysis.
+
o
Go Joined Separate
; Documented in common.opt
projects / gcc.git / commitdiff