1 files changed, 186 insertions, 0 deletions
diff --git a/toolkit/crashreporter/google-breakpad/src/processor/cfi_frame_info.cc b/toolkit/crashreporter/google-breakpad/src/processor/cfi_frame_info.cc
new file mode 100644
index 0000000000..0c4af7ba84
--- /dev/null
+++ b/toolkit/crashreporter/google-breakpad/src/processor/cfi_frame_info.cc
@@ -0,0 +1,186 @@
+// Copyright (c) 2010, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>
+
+// cfi_frame_info.cc: Implementation of CFIFrameInfo class.
+// See cfi_frame_info.h for details.
+
+#include "processor/cfi_frame_info.h"
+
+#include <string.h>
+
+#include <sstream>
+
+#include "common/scoped_ptr.h"
+#include "processor/postfix_evaluator-inl.h"
+
+namespace google_breakpad {
+
+#ifdef _MSC_VER
+#define strtok_r strtok_s
+#endif
+
+template<typename V>
+bool CFIFrameInfo::FindCallerRegs(const RegisterValueMap<V> &registers,
+                                  const MemoryRegion &memory,
+                                  RegisterValueMap<V> *caller_registers) const {
+  // If there are not rules for both .ra and .cfa in effect at this address,
+  // don't use this CFI data for stack walking.
+  if (cfa_rule_.empty() || ra_rule_.empty())
+    return false;
+
+  RegisterValueMap<V> working;
+  PostfixEvaluator<V> evaluator(&working, &memory);
+
+  caller_registers->clear();
+
+  // First, compute the CFA.
+  V cfa;
+  working = registers;
+  if (!evaluator.EvaluateForValue(cfa_rule_, &cfa))
+    return false;
+
+  // Then, compute the return address.
+  V ra;
+  working = registers;
+  working[".cfa"] = cfa;
+  if (!evaluator.EvaluateForValue(ra_rule_, &ra))
+    return false;
+
+  // Now, compute values for all the registers register_rules_ mentions.
+  for (RuleMap::const_iterator it = register_rules_.begin();
+       it != register_rules_.end(); it++) {
+    V value;
+    working = registers;
+    working[".cfa"] = cfa;
+    if (!evaluator.EvaluateForValue(it->second, &value))
+      return false;
+    (*caller_registers)[it->first] = value;
+  }
+
+  (*caller_registers)[".ra"] = ra;
+  (*caller_registers)[".cfa"] = cfa;
+
+  return true;
+}
+
+// Explicit instantiations for 32-bit and 64-bit architectures.
+template bool CFIFrameInfo::FindCallerRegs<uint32_t>(
+    const RegisterValueMap<uint32_t> &registers,
+    const MemoryRegion &memory,
+    RegisterValueMap<uint32_t> *caller_registers) const;
+template bool CFIFrameInfo::FindCallerRegs<uint64_t>(
+    const RegisterValueMap<uint64_t> &registers,
+    const MemoryRegion &memory,
+    RegisterValueMap<uint64_t> *caller_registers) const;
+
+string CFIFrameInfo::Serialize() const {
+  std::ostringstream stream;
+
+  if (!cfa_rule_.empty()) {
+    stream << ".cfa: " << cfa_rule_;
+  }
+  if (!ra_rule_.empty()) {
+    if (static_cast<std::streamoff>(stream.tellp()) != 0)
+      stream << " ";
+    stream << ".ra: " << ra_rule_;
+  }
+  for (RuleMap::const_iterator iter = register_rules_.begin();
+       iter != register_rules_.end();
+       ++iter) {
+    if (static_cast<std::streamoff>(stream.tellp()) != 0)
+      stream << " ";
+    stream << iter->first << ": " << iter->second;
+  }
+
+  return stream.str();
+}
+
+bool CFIRuleParser::Parse(const string &rule_set) {
+  size_t rule_set_len = rule_set.size();
+  scoped_array<char> working_copy(new char[rule_set_len + 1]);
+  memcpy(working_copy.get(), rule_set.data(), rule_set_len);
+  working_copy[rule_set_len] = '\0';
+
+  name_.clear();
+  expression_.clear();
+
+  char *cursor;
+  static const char token_breaks[] = " \t\r\n";
+  char *token = strtok_r(working_copy.get(), token_breaks, &cursor);
+
+  for (;;) {
+    // End of rule set?
+    if (!token) return Report();
+
+    // Register/pseudoregister name?
+    size_t token_len = strlen(token);
+    if (token_len >= 1 && token[token_len - 1] == ':') {
+      // Names can't be empty.
+      if (token_len < 2) return false;
+      // If there is any pending content, report it.
+      if (!name_.empty() || !expression_.empty()) {
+        if (!Report()) return false;
+      }
+      name_.assign(token, token_len - 1);
+      expression_.clear();
+    } else {
+      // Another expression component.
+      assert(token_len > 0); // strtok_r guarantees this, I think.
+      if (!expression_.empty())
+        expression_ += ' ';
+      expression_ += token;
+    }
+    token = strtok_r(NULL, token_breaks, &cursor);
+  }
+}
+
+bool CFIRuleParser::Report() {
+  if (name_.empty() || expression_.empty()) return false;
+  if (name_ == ".cfa") handler_->CFARule(expression_);
+  else if (name_ == ".ra") handler_->RARule(expression_);
+  else handler_->RegisterRule(name_, expression_);
+  return true;
+}
+
+void CFIFrameInfoParseHandler::CFARule(const string &expression) {
+  frame_info_->SetCFARule(expression);
+}
+
+void CFIFrameInfoParseHandler::RARule(const string &expression) {
+  frame_info_->SetRARule(expression);
+}
+
+void CFIFrameInfoParseHandler::RegisterRule(const string &name,
+                                            const string &expression) {
+  frame_info_->SetRegisterRule(name, expression);
+}
+
+} // namespace google_breakpad