truffle: src/share/vm/asm/codeBuffer.cpp comparison

comparison src/share/vm/asm/codeBuffer.cpp @ 8767:a5de0cc2f91c

8008555: Debugging code in compiled method sometimes leaks memory Summary: support for strings that have same life-time as code that uses them. Reviewed-by: kvn, twisti

author	roland
date	Mon, 18 Mar 2013 13:19:06 +0100
parents	30866cd626b0
children	b9a918201d47 de6a9e811145

comparison

equal deleted inserted replaced

-:592f9722c72e
+:a5de0cc2f91c
 CodeBuffer dest(dest_blob);
 assert(dest_blob->content_size() >= total_content_size(), "good sizing");
 this->compute_final_layout(&dest);
 relocate_code_to(&dest);
-// transfer comments from buffer to blob
+// transfer strings and comments from buffer to blob
-dest_blob->set_comments(_comments);
+dest_blob->set_strings(_strings);
 // Done moving code bytes; were they the right size?
 assert(round_to(dest.total_content_size(), oopSize) == dest_blob->content_size(), "sanity");
 // Flush generated code
 Disassembler::decode(start(), end());
 }
 void CodeBuffer::block_comment(intptr_t offset, const char * comment) {
-_comments.add_comment(offset, comment);
+_strings.add_comment(offset, comment);
 }
-class CodeComment: public CHeapObj<mtCode> {
+const char* CodeBuffer::code_string(const char* str) {
+return _strings.add_string(str);
+}
+class CodeString: public CHeapObj<mtCode> {
 private:
-friend class CodeComments;
+friend class CodeStrings;
+const char * _string;
+CodeString*  _next;
 intptr_t     _offset;
-const char * _comment;
-CodeComment* _next;
+~CodeString() {
-~CodeComment() {
 assert(_next == NULL, "wrong interface for freeing list");
-os::free((void*)_comment, mtCode);
+os::free((void*)_string, mtCode);
 }
+bool is_comment() const { return _offset >= 0; }
 public:
-CodeComment(intptr_t offset, const char * comment) {
+CodeString(const char * string, intptr_t offset = -1)
-_offset = offset;
+: _next(NULL), _offset(offset) {
-_comment = os::strdup(comment, mtCode);
+_string = os::strdup(string, mtCode);
-_next = NULL;
+}
-}
+const char * string() const { return _string; }
-intptr_t     offset()  const { return _offset;  }
+intptr_t     offset() const { assert(_offset >= 0, "offset for non comment?"); return _offset;  }
-const char * comment() const { return _comment; }
+CodeString* next()    const { return _next; }
-CodeComment* next()          { return _next; }
+void set_next(CodeString* next) { _next = next; }
-void set_next(CodeComment* next) { _next = next; }
+CodeString* first_comment() {
-CodeComment* find(intptr_t offset) {
+if (is_comment()) {
-CodeComment* a = this;
+return this;
-while (a != NULL && a->_offset != offset) {
+} else {
-a = a->_next;
+return next_comment();
 }
-return a;
+}
-}
+CodeString* next_comment() const {
+CodeString* s = _next;
-// Convenience for add_comment.
+while (s != NULL && !s->is_comment()) {
-CodeComment* find_last(intptr_t offset) {
+s = s->_next;
-CodeComment* a = find(offset);
+}
-if (a != NULL) {
+return s;
-while ((a->_next != NULL) && (a->_next->_offset == offset)) {
-a = a->_next;
-}
-}
-return a;
 }
 };
+CodeString* CodeStrings::find(intptr_t offset) const {
-void CodeComments::add_comment(intptr_t offset, const char * comment) {
+CodeString* a = _strings->first_comment();
-CodeComment* c      = new CodeComment(offset, comment);
+while (a != NULL && a->offset() != offset) {
-CodeComment* inspos = (_comments == NULL) ? NULL : _comments->find_last(offset);
+a = a->next_comment();
+}
+return a;
+}
+// Convenience for add_comment.
+CodeString* CodeStrings::find_last(intptr_t offset) const {
+CodeString* a = find(offset);
+if (a != NULL) {
+CodeString* c = NULL;
+while (((c = a->next_comment()) != NULL) && (c->offset() == offset)) {
+a = c;
+}
+}
+return a;
+}
+void CodeStrings::add_comment(intptr_t offset, const char * comment) {
+CodeString* c      = new CodeString(comment, offset);
+CodeString* inspos = (_strings == NULL) ? NULL : find_last(offset);
 if (inspos) {
 // insert after already existing comments with same offset
 c->set_next(inspos->next());
 inspos->set_next(c);
 } else {
 // no comments with such offset, yet. Insert before anything else.
-c->set_next(_comments);
+c->set_next(_strings);
-_comments = c;
+_strings = c;
 }
 }
+void CodeStrings::assign(CodeStrings& other) {
-void CodeComments::assign(CodeComments& other) {
+_strings = other._strings;
-_comments = other._comments;
+}
-}
+void CodeStrings::print_block_comment(outputStream* stream, intptr_t offset) const {
+if (_strings != NULL) {
-void CodeComments::print_block_comment(outputStream* stream, intptr_t offset) const {
+CodeString* c = find(offset);
-if (_comments != NULL) {
-CodeComment* c = _comments->find(offset);
 while (c && c->offset() == offset) {
 stream->bol();
 stream->print("  ;; ");
-stream->print_cr(c->comment());
+stream->print_cr(c->string());
-c = c->next();
+c = c->next_comment();
 }
 }
 }
-void CodeComments::free() {
+void CodeStrings::free() {
-CodeComment* n = _comments;
+CodeString* n = _strings;
 while (n) {
 // unlink the node from the list saving a pointer to the next
-CodeComment* p = n->_next;
+CodeString* p = n->next();
-n->_next = NULL;
+n->set_next(NULL);
 delete n;
 n = p;
 }
-_comments = NULL;
+_strings = NULL;
 }
+const char* CodeStrings::add_string(const char * string) {
+CodeString* s = new CodeString(string);
+s->set_next(_strings);
+_strings = s;
+assert(s->string() != NULL, "should have a string");
+return s->string();
+}
 void CodeBuffer::decode() {
 ttyLocker ttyl;
 Disassembler::decode(decode_begin(), insts_end());
 _decode_begin = insts_end();

Mercurial > hg > truffle

comparison src/share/vm/asm/codeBuffer.cpp @ 8767:a5de0cc2f91c