equal
deleted
inserted
replaced
2739 } |
2739 } |
2740 |
2740 |
2741 //------------------------------Idealize--------------------------------------- |
2741 //------------------------------Idealize--------------------------------------- |
2742 // Clearing a short array is faster with stores |
2742 // Clearing a short array is faster with stores |
2743 Node *ClearArrayNode::Ideal(PhaseGVN *phase, bool can_reshape){ |
2743 Node *ClearArrayNode::Ideal(PhaseGVN *phase, bool can_reshape){ |
|
2744 // Already know this is a large node, do not try to ideal it |
|
2745 if (_is_large) return NULL; |
|
2746 |
2744 const int unit = BytesPerLong; |
2747 const int unit = BytesPerLong; |
2745 const TypeX* t = phase->type(in(2))->isa_intptr_t(); |
2748 const TypeX* t = phase->type(in(2))->isa_intptr_t(); |
2746 if (!t) return NULL; |
2749 if (!t) return NULL; |
2747 if (!t->is_con()) return NULL; |
2750 if (!t->is_con()) return NULL; |
2748 intptr_t raw_count = t->get_con(); |
2751 intptr_t raw_count = t->get_con(); |
2751 // Clearing nothing uses the Identity call. |
2754 // Clearing nothing uses the Identity call. |
2752 // Negative clears are possible on dead ClearArrays |
2755 // Negative clears are possible on dead ClearArrays |
2753 // (see jck test stmt114.stmt11402.val). |
2756 // (see jck test stmt114.stmt11402.val). |
2754 if (size <= 0 || size % unit != 0) return NULL; |
2757 if (size <= 0 || size % unit != 0) return NULL; |
2755 intptr_t count = size / unit; |
2758 intptr_t count = size / unit; |
2756 // Length too long; use fast hardware clear |
2759 // Length too long; communicate this to matchers and assemblers. |
2757 if (size > Matcher::init_array_short_size) return NULL; |
2760 // Assemblers are responsible to produce fast hardware clears for it. |
|
2761 if (size > InitArrayShortSize) { |
|
2762 return new ClearArrayNode(in(0), in(1), in(2), in(3), true); |
|
2763 } |
2758 Node *mem = in(1); |
2764 Node *mem = in(1); |
2759 if( phase->type(mem)==Type::TOP ) return NULL; |
2765 if( phase->type(mem)==Type::TOP ) return NULL; |
2760 Node *adr = in(3); |
2766 Node *adr = in(3); |
2761 const Type* at = phase->type(adr); |
2767 const Type* at = phase->type(adr); |
2762 if( at==Type::TOP ) return NULL; |
2768 if( at==Type::TOP ) return NULL; |
2850 } |
2856 } |
2851 |
2857 |
2852 // Bulk clear double-words |
2858 // Bulk clear double-words |
2853 Node* zsize = phase->transform(new SubXNode(zend, zbase) ); |
2859 Node* zsize = phase->transform(new SubXNode(zend, zbase) ); |
2854 Node* adr = phase->transform(new AddPNode(dest, dest, start_offset) ); |
2860 Node* adr = phase->transform(new AddPNode(dest, dest, start_offset) ); |
2855 mem = new ClearArrayNode(ctl, mem, zsize, adr); |
2861 mem = new ClearArrayNode(ctl, mem, zsize, adr, false); |
2856 return phase->transform(mem); |
2862 return phase->transform(mem); |
2857 } |
2863 } |
2858 |
2864 |
2859 Node* ClearArrayNode::clear_memory(Node* ctl, Node* mem, Node* dest, |
2865 Node* ClearArrayNode::clear_memory(Node* ctl, Node* mem, Node* dest, |
2860 intptr_t start_offset, |
2866 intptr_t start_offset, |
3899 zeroes_done = align_size_down(zeroes_done, BytesPerInt); |
3905 zeroes_done = align_size_down(zeroes_done, BytesPerInt); |
3900 rawmem = ClearArrayNode::clear_memory(rawctl, rawmem, rawptr, |
3906 rawmem = ClearArrayNode::clear_memory(rawctl, rawmem, rawptr, |
3901 zeroes_done, zeroes_needed, |
3907 zeroes_done, zeroes_needed, |
3902 phase); |
3908 phase); |
3903 zeroes_done = zeroes_needed; |
3909 zeroes_done = zeroes_needed; |
3904 if (zsize > Matcher::init_array_short_size && ++big_init_gaps > 2) |
3910 if (zsize > InitArrayShortSize && ++big_init_gaps > 2) |
3905 do_zeroing = false; // leave the hole, next time |
3911 do_zeroing = false; // leave the hole, next time |
3906 } |
3912 } |
3907 } |
3913 } |
3908 |
3914 |
3909 // Collect the store and move on: |
3915 // Collect the store and move on: |