VMReg bias(int offset) { assert(is_stack(), "must be"); // VMReg res = VMRegImpl::as_VMReg(value() + offset); VMReg res = stack2reg(reg2stack() + offset); assert(res->is_stack(), "must be"); return res; }
void VMRegImpl::print_on(outputStream* st) const { if( is_reg() ) { assert( VMRegImpl::regName[value()], "" ); st->print("%s",VMRegImpl::regName[value()]); } else if (is_stack()) { int stk = value() - stack0->value(); st->print("[%d]", stk*4); } else { st->print("BAD!"); } }
/* * display a single VMA to a sequenced file */ static int nommu_vma_show(struct seq_file *m, struct vm_area_struct *vma, int is_pid) { struct mm_struct *mm = vma->vm_mm; struct proc_maps_private *priv = m->private; unsigned long ino = 0; struct file *file; dev_t dev = 0; int flags; unsigned long long pgoff = 0; flags = vma->vm_flags; file = vma->vm_file; if (file) { struct inode *inode = file_inode(vma->vm_file); dev = inode->i_sb->s_dev; ino = inode->i_ino; pgoff = (loff_t)vma->vm_pgoff << PAGE_SHIFT; } seq_setwidth(m, 25 + sizeof(void *) * 6 - 1); seq_printf(m, "%08lx-%08lx %c%c%c%c %08llx %02x:%02x %lu ", vma->vm_start, vma->vm_end, flags & VM_READ ? 'r' : '-', flags & VM_WRITE ? 'w' : '-', flags & VM_EXEC ? 'x' : '-', flags & VM_MAYSHARE ? flags & VM_SHARED ? 'S' : 's' : 'p', pgoff, MAJOR(dev), MINOR(dev), ino); if (file) { seq_pad(m, ' '); seq_file_path(m, file, ""); } else if (mm && is_stack(priv, vma, is_pid)) { seq_pad(m, ' '); seq_printf(m, "[stack]"); } seq_putc(m, '\n'); return 0; }
TEST(AliasClass, SpecializedUnions) { IRUnit unit{test_context}; auto const marker = BCMarker::Dummy(); auto const FP = unit.gen(DefFP, marker)->dst(); AliasClass const stk = AStack { FP, -10, 3 }; AliasClass const unrelated_stk = AStack { FP, -14, 1 }; AliasClass const related_stk = AStack { FP, -11, 2 }; auto const stk_and_frame = stk | AFrameAny; EXPECT_TRUE(!stk_and_frame.is_stack()); EXPECT_TRUE(AFrameAny <= stk_and_frame); EXPECT_TRUE(stk <= stk_and_frame); EXPECT_TRUE(AStackAny.maybe(stk_and_frame)); EXPECT_TRUE(AFrameAny.maybe(stk_and_frame)); EXPECT_FALSE(unrelated_stk <= stk_and_frame); EXPECT_FALSE(stk_and_frame.maybe(unrelated_stk)); auto const stk_and_prop = stk | APropAny; EXPECT_TRUE(stk_and_prop.maybe(stk_and_frame)); EXPECT_TRUE(stk_and_frame.maybe(stk_and_prop)); EXPECT_FALSE(stk_and_prop <= stk_and_frame); EXPECT_FALSE(stk_and_frame <= stk_and_prop); EXPECT_TRUE(APropAny.maybe(stk_and_prop)); EXPECT_TRUE(AStackAny.maybe(stk_and_prop)); auto const unrelated_stk_and_prop = unrelated_stk | APropAny; EXPECT_FALSE(stk_and_frame.maybe(unrelated_stk_and_prop)); EXPECT_FALSE(unrelated_stk_and_prop.maybe(stk_and_frame)); EXPECT_TRUE(unrelated_stk_and_prop.maybe(stk_and_prop)); // because of prop EXPECT_FALSE(unrelated_stk_and_prop <= stk_and_prop); EXPECT_FALSE(stk_and_prop <= unrelated_stk_and_prop); EXPECT_FALSE(unrelated_stk_and_prop <= stk_and_frame); EXPECT_FALSE(stk_and_frame <= unrelated_stk_and_prop); EXPECT_FALSE(stk_and_prop <= AHeapAny); EXPECT_TRUE(stk_and_prop.maybe(AHeapAny)); EXPECT_FALSE(stk_and_frame <= AHeapAny); EXPECT_FALSE(stk_and_frame.maybe(AHeapAny)); auto const rel_stk_and_frame = related_stk | AFrameAny; EXPECT_TRUE(stk_and_frame.maybe(rel_stk_and_frame)); EXPECT_TRUE(rel_stk_and_frame.maybe(stk_and_frame)); EXPECT_TRUE(related_stk <= stk); EXPECT_TRUE(rel_stk_and_frame <= stk_and_frame); EXPECT_FALSE(stk_and_frame <= rel_stk_and_frame); EXPECT_TRUE(rel_stk_and_frame.maybe(stk_and_prop)); EXPECT_TRUE(stk_and_prop.maybe(rel_stk_and_frame)); EXPECT_FALSE(rel_stk_and_frame <= stk_and_prop); auto const some_mis = AMIStateTvRef; { auto const some_heap = AElemIAny; auto const u1 = some_heap | some_mis; auto const u2 = AFrameAny | u1; EXPECT_TRUE((AHeapAny | some_heap) == AHeapAny); EXPECT_TRUE(AHeapAny <= (AHeapAny | u1)); EXPECT_TRUE(AHeapAny <= (AHeapAny | u2)); } auto const mis_stk = some_mis | stk; auto const mis_stk_any = AStackAny | mis_stk; EXPECT_EQ(some_mis, AliasClass{*mis_stk_any.mis()}); EXPECT_NE(mis_stk_any, AStackAny | AMIStateAny); auto const other_mis = AMIStateBase; EXPECT_LE(some_mis, some_mis | other_mis); EXPECT_LE(other_mis, some_mis | other_mis); EXPECT_NE(some_mis, some_mis | other_mis); EXPECT_NE(other_mis, some_mis | other_mis); }
// This really ought to check that the register is "real" in the sense that // we don't try and get the VMReg number of a physical register that doesn't // have an expressible part. That would be pd specific code VMReg next() { assert((is_reg() && value() < stack0->value() - 1) || is_stack(), "must be"); return (VMReg)(intptr_t)(value() + 1); }
bool is_reg() const { return is_valid() && !is_stack(); }
uintptr_t reg2stack() { assert( is_stack(), "Not a stack-based register" ); return value() - stack0->value(); }
VMReg prev() { assert((is_stack() && value() > stack0->value()) || (is_reg() && value() != 0), "must be"); return (VMReg)(intptr_t)(value() - 1); }