truffle: src/share/vm/adlc/output

comparison src/share/vm/adlc/output_h.cpp @ 18041:52b4284cb496

Merge with jdk8u20-b26

author	Gilles Duboscq <duboscq@ssw.jku.at>
date	Wed, 15 Oct 2014 16:02:50 +0200
parents	89152779163c 78bbf4d43a14
children

comparison

equal deleted inserted replaced

-:45d7b2c7029d
+:52b4284cb496
 /*
-* Copyright (c) 1998, 2013, Oracle and/or its affiliates. All rights reserved.
+* Copyright (c) 1998, 2014, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 // output_h.cpp - Class HPP file output routines for architecture definition
 #include "adlc.hpp"
 // The comment delimiter used in format statements after assembler instructions.
+#if defined(PPC64)
+#define commentSeperator "\t//"
+#else
 #define commentSeperator "!"
+#endif
 // Generate the #define that describes the number of registers.
 static void defineRegCount(FILE *fp, RegisterForm *registers) {
 if (registers) {
 int regCount =  AdlcVMDeps::Physical + registers->_rdefs.count();
 // Generate the format rule for condition codes
 static void defineCCodeDump(OperandForm* oper, FILE *fp, int i) {
 assert(oper != NULL, "what");
 CondInterface* cond = oper->_interface->is_CondInterface();
-fprintf(fp, "       if( _c%d == BoolTest::eq ) st->print(\"%s\");\n",i,cond->_equal_format);
+fprintf(fp, "       if( _c%d == BoolTest::eq ) st->print_raw(\"%s\");\n",i,cond->_equal_format);
-fprintf(fp, "  else if( _c%d == BoolTest::ne ) st->print(\"%s\");\n",i,cond->_not_equal_format);
+fprintf(fp, "  else if( _c%d == BoolTest::ne ) st->print_raw(\"%s\");\n",i,cond->_not_equal_format);
-fprintf(fp, "  else if( _c%d == BoolTest::le ) st->print(\"%s\");\n",i,cond->_less_equal_format);
+fprintf(fp, "  else if( _c%d == BoolTest::le ) st->print_raw(\"%s\");\n",i,cond->_less_equal_format);
-fprintf(fp, "  else if( _c%d == BoolTest::ge ) st->print(\"%s\");\n",i,cond->_greater_equal_format);
+fprintf(fp, "  else if( _c%d == BoolTest::ge ) st->print_raw(\"%s\");\n",i,cond->_greater_equal_format);
-fprintf(fp, "  else if( _c%d == BoolTest::lt ) st->print(\"%s\");\n",i,cond->_less_format);
+fprintf(fp, "  else if( _c%d == BoolTest::lt ) st->print_raw(\"%s\");\n",i,cond->_less_format);
-fprintf(fp, "  else if( _c%d == BoolTest::gt ) st->print(\"%s\");\n",i,cond->_greater_format);
+fprintf(fp, "  else if( _c%d == BoolTest::gt ) st->print_raw(\"%s\");\n",i,cond->_greater_format);
-fprintf(fp, "  else if( _c%d == BoolTest::overflow ) st->print(\"%s\");\n",i,cond->_overflow_format);
+fprintf(fp, "  else if( _c%d == BoolTest::overflow ) st->print_raw(\"%s\");\n",i,cond->_overflow_format);
-fprintf(fp, "  else if( _c%d == BoolTest::no_overflow ) st->print(\"%s\");\n",i,cond->_no_overflow_format);
+fprintf(fp, "  else if( _c%d == BoolTest::no_overflow ) st->print_raw(\"%s\");\n",i,cond->_no_overflow_format);
 }
 // Output code that dumps constant values, increment "i" if type is constant
 static uint dump_spec_constant(FILE *fp, const char *ideal_type, uint i, OperandForm* oper) {
 if (!strcmp(ideal_type, "ConI")) {
 else if (!strcmp(ideal_type, "ConNKlass")) {
 fprintf(fp,"    _c%d->dump_on(st);\n", i);
 ++i;
 }
 else if (!strcmp(ideal_type, "ConL")) {
-fprintf(fp,"    st->print(\"#\" INT64_FORMAT, _c%d);\n", i);
+fprintf(fp,"    st->print(\"#\" INT64_FORMAT, (int64_t)_c%d);\n", i);
-fprintf(fp,"    st->print(\"/\" PTR64_FORMAT, _c%d);\n", i);
+fprintf(fp,"    st->print(\"/\" PTR64_FORMAT, (uint64_t)_c%d);\n", i);
 ++i;
 }
 else if (!strcmp(ideal_type, "ConF")) {
 fprintf(fp,"    st->print(\"#%%f\", _c%d);\n", i);
 fprintf(fp,"    jint _c%di = JavaValue(_c%d).get_jint();\n", i, i);
 ++i;
 }
 else if (!strcmp(ideal_type, "ConD")) {
 fprintf(fp,"    st->print(\"#%%f\", _c%d);\n", i);
 fprintf(fp,"    jlong _c%dl = JavaValue(_c%d).get_jlong();\n", i, i);
-fprintf(fp,"    st->print(\"/\" PTR64_FORMAT, _c%dl);\n", i);
+fprintf(fp,"    st->print(\"/\" PTR64_FORMAT, (uint64_t)_c%dl);\n", i);
 ++i;
 }
 else if (!strcmp(ideal_type, "Bool")) {
 defineCCodeDump(oper, fp,i);
 ++i;
 // Check if this is a standard string or a replacement variable
 if ( string != NameList::_signal ) {
 // Normal string
 // Pass through to st->print
-fprintf(fp,"  st->print(\"%s\");\n", string);
+fprintf(fp,"  st->print_raw(\"%s\");\n", string);
 } else {
 // Replacement variable
 const char *rep_var = oper._format->_rep_vars.iter();
 // Check that it is a local name, and an operand
 const Form* form = oper._localNames[rep_var];
 // Check if this is a standard string or a replacement variable
 if ( string != NameList::_signal ) {
 // Normal string
 // Pass through to st->print
-fprintf(fp,"  st->print(\"%s\");\n", string);
+fprintf(fp,"  st->print_raw(\"%s\");\n", string);
 } else {
 // Replacement variable
 const char *rep_var = oper._format->_rep_vars.iter();
 // Check that it is a local name, and an operand
 const Form* form = oper._localNames[rep_var];
 assert( false, "ShouldNotReachHere()");
 }
 } else if( string == NameList::_signal2 ) // Raw program text
 fputs(inst._format->_strings.iter(), fp);
 else
-fprintf(fp,"st->print(\"%s\");\n", string);
+fprintf(fp,"st->print_raw(\"%s\");\n", string);
 } // Done with all format strings
 } // Done generating the user-defined portion of the format
 // Add call debug info automatically
 Form::CallType call_type = inst.is_ideal_call();
 fprintf(fp,"  st->print(\" %%s\", _name);");
 break;
 default:
 assert(0,"ShouldNotReachHere");
 }
-fprintf(fp,  "  st->print_cr(\"\");\n" );
+fprintf(fp,  "  st->cr();\n" );
 fprintf(fp,  "  if (_jvms) _jvms->format(ra, this, st); else st->print_cr(\"        No JVM State Info\");\n" );
 fprintf(fp,  "  st->print(\"        # \");\n" );
 fprintf(fp,  "  if( _jvms && _oop_map ) _oop_map->print_on(st);\n");
 }
 else if(inst.is_ideal_safepoint()) {
-fprintf(fp,  "  st->print(\"\");\n" );
+fprintf(fp,  "  st->print_raw(\"\");\n" );
 fprintf(fp,  "  if (_jvms) _jvms->format(ra, this, st); else st->print_cr(\"        No JVM State Info\");\n" );
 fprintf(fp,  "  st->print(\"        # \");\n" );
 fprintf(fp,  "  if( _jvms && _oop_map ) _oop_map->print_on(st);\n");
 }
 else if( inst.is_ideal_if() ) {
 fprintf(fp,"private:\n");
 fprintf(fp,"  MachOper *_opnd_array[%d];\n", instr->num_opnds() );
 if ( instr->is_ideal_jump() ) {
 fprintf(fp, "  GrowableArray<Label*> _index2label;\n");
 }
-fprintf(fp,"public:\n");
+fprintf(fp, "public:\n");
+Attribute *att = instr->_attribs;
+// Fields of the node specified in the ad file.
+while (att != NULL) {
+if (strncmp(att->_ident, "ins_field_", 10) == 0) {
+const char *field_name = att->_ident+10;
+const char *field_type = att->_val;
+fprintf(fp, "  %s _%s;\n", field_type, field_name);
+}
+att = (Attribute *)att->_next;
+}
 fprintf(fp,"  MachOper *opnd_array(uint operand_index) const {\n");
 fprintf(fp,"    assert(operand_index < _num_opnds, \"invalid _opnd_array index\");\n");
 fprintf(fp,"    return _opnd_array[operand_index];\n");
 fprintf(fp,"  }\n");
 fprintf(fp,"  void      set_opnd_array(uint operand_index, MachOper *operand) {\n");
 // virtual functions for attributes
 //
 // Each instruction attribute results in a virtual call of same name.
 // The ins_cost is not handled here.
 Attribute *attr = instr->_attribs;
-bool avoid_back_to_back = false;
+Attribute *avoid_back_to_back_attr = NULL;
 while (attr != NULL) {
-if (strcmp(attr->_ident,"ins_cost") &&
+if (strcmp (attr->_ident, "ins_is_TrapBasedCheckNode") == 0) {
-strcmp(attr->_ident,"ins_short_branch")) {
+fprintf(fp, "  virtual bool           is_TrapBasedCheckNode() const { return %s; }\n", attr->_val);
-fprintf(fp,"          int            %s() const { return %s; }\n",
+} else if (strcmp (attr->_ident, "ins_cost") != 0 &&
-attr->_ident, attr->_val);
+strncmp(attr->_ident, "ins_field_", 10) != 0 &&
-}
+// Must match function in node.hpp: return type bool, no prefix "ins_".
-// Check value for ins_avoid_back_to_back, and if it is true (1), set the flag
+strcmp (attr->_ident, "ins_is_TrapBasedCheckNode") != 0 &&
-if (!strcmp(attr->_ident,"ins_avoid_back_to_back") && attr->int_val(*this) != 0)
+strcmp (attr->_ident, "ins_short_branch") != 0) {
-avoid_back_to_back = true;
+fprintf(fp, "  virtual int            %s() const { return %s; }\n", attr->_ident, attr->_val);
+}
+if (strcmp(attr->_ident, "ins_avoid_back_to_back") == 0) {
+avoid_back_to_back_attr = attr;
+}
 attr = (Attribute *)attr->_next;
 }
 // virtual functions for encode and format
 }
 // Output the opcode function and the encode function here using the
 // encoding class information in the _insencode slot.
 if ( instr->_insencode ) {
-fprintf(fp,"  virtual void           emit(CodeBuffer &cbuf, PhaseRegAlloc *ra_) const;\n");
+if (instr->postalloc_expands()) {
+fprintf(fp,"  virtual bool           requires_postalloc_expand() const { return true; }\n");
+fprintf(fp,"  virtual void           postalloc_expand(GrowableArray <Node *> *nodes, PhaseRegAlloc *ra_);\n");
+} else {
+fprintf(fp,"  virtual void           emit(CodeBuffer &cbuf, PhaseRegAlloc *ra_) const;\n");
+}
 }
 // virtual function for getting the size of an instruction
 if ( instr->_size ) {
 fprintf(fp,"  virtual uint           size(PhaseRegAlloc *ra_) const;\n");
 // if the ideal_Opcode == Op_Node.
 if ( strcmp("Node", instr->ideal_Opcode(_globalNames)) != 0 ||
 strcmp("MachNode", instr->mach_base_class(_globalNames)) != 0 ) {
 fprintf(fp,"  virtual int            ideal_Opcode() const { return Op_%s; }\n",
 instr->ideal_Opcode(_globalNames) );
+}
+if (instr->needs_constant_base() &&
+!instr->is_mach_constant()) {  // These inherit the funcion from MachConstantNode.
+fprintf(fp,"  virtual uint           mach_constant_base_node_input() const { ");
+if (instr->is_ideal_call() != Form::invalid_type &&
+instr->is_ideal_call() != Form::JAVA_LEAF) {
+// MachConstantBase goes behind arguments, but before jvms.
+fprintf(fp,"assert(tf() && tf()->domain(), \"\"); return tf()->domain()->cnt();");
+} else {
+fprintf(fp,"return req()-1;");
+}
+fprintf(fp," }\n");
 }
 // Allow machine-independent optimization, invert the sense of the IF test
 if( instr->is_ideal_if() ) {
 fprintf(fp,"  virtual void           negate() { \n");
 node_flags_set = true;
 }
 }
 // flag: if this instruction should not be generated back to back.
-if ( avoid_back_to_back ) {
+if (avoid_back_to_back_attr != NULL) {
-if ( node_flags_set ) {
+if (node_flags_set) {
-fprintf(fp," | Flag_avoid_back_to_back");
+fprintf(fp," | (%s)", avoid_back_to_back_attr->_val);
 } else {
-fprintf(fp,"init_flags(Flag_avoid_back_to_back");
+fprintf(fp,"init_flags((%s)", avoid_back_to_back_attr->_val);
 node_flags_set = true;
 }
 }
 // Check if machine instructions that USE memory, but do not DEF memory,
 // Virtual methods which are only generated to override base class
 if( instr->expands() || instr->needs_projections() ||
 instr->has_temps() ||
 instr->is_mach_constant() ||
+instr->needs_constant_base() ||
 instr->_matrule != NULL &&
 instr->num_opnds() != instr->num_unique_opnds() ) {
 fprintf(fp,"  virtual MachNode      *Expand(State *state, Node_List &proj_list, Node* mem);\n");
 }

Mercurial > hg > truffle

comparison src/share/vm/adlc/output_h.cpp @ 18041:52b4284cb496