TEST(SplitRegionTest, Basic2) { //rectangular case region_descriptor test3 = create_rectangle(cv::Rect(10,15, 10,20)); std::vector<region_descriptor> res3; int ret3 = split_region(test3, 4, std::back_inserter(res3)); EXPECT_EQ(ret3, 4); EXPECT_EQ(res3.size(), 4); EXPECT_EQ(res3[0].size(), 50); EXPECT_EQ(res3[1].size(), 50); EXPECT_EQ(res3[2].size(), 50); EXPECT_EQ(res3[3].size(), 50); //to small case (one direction) std::vector<region_descriptor> res4; int ret4 = split_region(test3, 10, std::back_inserter(res4)); EXPECT_EQ(ret4, 2); EXPECT_EQ(res4.size(), 2); EXPECT_EQ(res4[0].size(), 100); EXPECT_EQ(res4[1].size(), 100); //irregular shaped case region_descriptor test5 = test3; test5.lineIntervals.push_back(region_interval(30,15,40)); test5.bounding_box.width = 25; test5.bounding_box.height += 1; std::vector<region_descriptor> res5; int ret5 = split_region(test5, 5, std::back_inserter(res5)); EXPECT_EQ(ret5, 4); EXPECT_EQ(res5.size(), 4); }
void set_intersection(paramset const & other) { std::vector<region_t> res; std::vector<region_t> new_sregions; std::vector<region_t> const & oregions = other.regions(); for (std::size_t oregion_index = 0; oregion_index < oregions.size(); ++oregion_index) { new_sregions.clear(); region_t const & oregion = oregions[oregion_index]; for (std::size_t sregion_index = 0; sregion_index < m_regions.size(); ++sregion_index) { region_t & sregion = m_regions[sregion_index]; bool intersecting = true; for (std::size_t i = 0; intersecting && i < oregion.box.size(); ++i) { if (oregion.box[i].second <= sregion.box[i].first || sregion.box[i].second <= oregion.box[i].first) intersecting = false; } if (!intersecting) { new_sregions.push_back(std::move(sregion)); continue; } for (std::size_t i = 0; i < oregion.box.size(); ++i) { region_t removed; boost::tie(sregion, removed) = split_region(std::move(sregion), i, oregion.box[i].first, true); if (!removed.box.empty()) new_sregions.push_back(std::move(removed)); if (sregion.box.empty()) break; boost::tie(sregion, removed) = split_region(std::move(sregion), i, oregion.box[i].second, false); if (!removed.box.empty()) new_sregions.push_back(std::move(removed)); if (sregion.box.empty()) break; } if (!sregion.box.empty()) res.push_back(std::move(sregion)); } m_regions = std::move(new_sregions); } m_regions = std::move(res); }
bool set_union_impl(std::vector<region_t> oregions) { std::vector<region_t> new_oregions; for (std::size_t sregion_index = 0; sregion_index < m_regions.size(); ++sregion_index) { region_t const & sregion = m_regions[sregion_index]; new_oregions.clear(); for (std::size_t oregion_index = 0; oregion_index < oregions.size(); ++oregion_index) { region_t & oregion = oregions[oregion_index]; BOOST_ASSERT(oregion.box.size() == sregion.box.size()); bool intersecting = true; for (std::size_t i = 0; intersecting && i < oregion.box.size(); ++i) { if (oregion.box[i].second <= sregion.box[i].first || sregion.box[i].second <= oregion.box[i].first) intersecting = false; } if (!intersecting) { new_oregions.push_back(std::move(oregion)); continue; } for (std::size_t i = 0; i < oregion.box.size(); ++i) { region_t removed; boost::tie(oregion, removed) = split_region(std::move(oregion), i, sregion.box[i].first, true); if (!removed.box.empty()) new_oregions.push_back(std::move(removed)); if (oregion.box.empty()) break; boost::tie(oregion, removed) = split_region(std::move(oregion), i, sregion.box[i].second, false); if (!removed.box.empty()) new_oregions.push_back(std::move(removed)); if (oregion.box.empty()) break; } } oregions = std::move(new_oregions); } for (std::size_t i = 0; i < oregions.size(); ++i) m_regions.push_back(std::move(oregions[i])); return !oregions.empty(); }
TEST(SplitRegionTest, Basic) { //quadratic case region_descriptor test = create_rectangle(cv::Rect(5,5,10,10)); std::vector<region_descriptor> res1; int ret1 = split_region(test, 5, std::back_inserter(res1)); EXPECT_EQ(res1.size(), 4); EXPECT_EQ(res1[0].size(), 25); EXPECT_EQ(res1[1].size(), 25); EXPECT_EQ(res1[2].size(), 25); EXPECT_EQ(res1[3].size(), 25); EXPECT_EQ(ret1, 4); //too small case (both directions) std::vector<region_descriptor> res2; int ret2 = split_region(test, 6, std::back_inserter(res2)); EXPECT_EQ(ret2, 1); EXPECT_EQ(res2.size(), 1); EXPECT_EQ(res2[0].size(), 100); }
UNICORN_EXPORT uc_err uc_mem_unmap(struct uc_struct *uc, uint64_t address, size_t size) { MemoryRegion *mr; uint64_t addr; size_t count, len; if (size == 0) // nothing to unmap return UC_ERR_OK; // address must be aligned to uc->target_page_size if ((address & uc->target_page_align) != 0) return UC_ERR_ARG; // size must be multiple of uc->target_page_size if ((size & uc->target_page_align) != 0) return UC_ERR_MAP; if (uc->mem_redirect) { address = uc->mem_redirect(address); } // check that user's entire requested block is mapped if (!check_mem_area(uc, address, size)) return UC_ERR_NOMEM; // Now we know entire region is mapped, so do the unmap // We may need to split regions if this area spans adjacent regions addr = address; count = 0; while(count < size) { mr = memory_mapping(uc, addr); len = MIN(size - count, mr->end - addr); if (!split_region(uc, mr, addr, len, true)) return UC_ERR_NOMEM; // if we can retrieve the mapping, then no splitting took place // so unmap here mr = memory_mapping(uc, addr); if (mr != NULL) uc->memory_unmap(uc, mr); count += len; addr += len; } return UC_ERR_OK; }
UNICORN_EXPORT uc_err uc_mem_protect(struct uc_struct *uc, uint64_t address, size_t size, uint32_t perms) { MemoryRegion *mr; uint64_t addr = address; size_t count, len; if (size == 0) // trivial case, no change return UC_ERR_OK; // address must be aligned to uc->target_page_size if ((address & uc->target_page_align) != 0) return UC_ERR_ARG; // size must be multiple of uc->target_page_size if ((size & uc->target_page_align) != 0) return UC_ERR_ARG; // check for only valid permissions if ((perms & ~UC_PROT_ALL) != 0) return UC_ERR_ARG; // check that user's entire requested block is mapped if (!check_mem_area(uc, address, size)) return UC_ERR_NOMEM; // Now we know entire region is mapped, so change permissions // We may need to split regions if this area spans adjacent regions addr = address; count = 0; while(count < size) { mr = memory_mapping(uc, addr); len = MIN(size - count, mr->end - addr); if (!split_region(uc, mr, addr, len, false)) return UC_ERR_NOMEM; mr = memory_mapping(uc, addr); mr->perms = perms; uc->readonly_mem(mr, (perms & UC_PROT_WRITE) == 0); count += len; addr += len; } return UC_ERR_OK; }
paramset remove_cut(std::size_t dim, value_type value, bool up) { paramset res; region_t removed; for (std::size_t i = m_regions.size(); i != 0; --i) { boost::tie(m_regions[i-1], removed) = split_region(std::move(m_regions[i-1]), dim, value, !up); if (m_regions[i-1].box.empty()) { std::swap(m_regions[i-1], m_regions.back()); m_regions.pop_back(); } if (!removed.box.empty()) res.m_regions.push_back(std::move(removed)); } return std::move(res); }
UNICORN_EXPORT uc_err uc_mem_protect(struct uc_struct *uc, uint64_t address, size_t size, uint32_t perms) { MemoryRegion *mr; uint64_t addr = address; size_t count, len; bool remove_exec = false; if (size == 0) // trivial case, no change return UC_ERR_OK; // address must be aligned to uc->target_page_size if ((address & uc->target_page_align) != 0) return UC_ERR_ARG; // size must be multiple of uc->target_page_size if ((size & uc->target_page_align) != 0) return UC_ERR_ARG; // check for only valid permissions if ((perms & ~UC_PROT_ALL) != 0) return UC_ERR_ARG; if (uc->mem_redirect) { address = uc->mem_redirect(address); } // check that user's entire requested block is mapped if (!check_mem_area(uc, address, size)) return UC_ERR_NOMEM; // Now we know entire region is mapped, so change permissions // We may need to split regions if this area spans adjacent regions addr = address; count = 0; while(count < size) { mr = memory_mapping(uc, addr); len = MIN(size - count, mr->end - addr); if (!split_region(uc, mr, addr, len, false)) return UC_ERR_NOMEM; mr = memory_mapping(uc, addr); // will this remove EXEC permission? if (((mr->perms & UC_PROT_EXEC) != 0) && ((perms & UC_PROT_EXEC) == 0)) remove_exec = true; mr->perms = perms; uc->readonly_mem(mr, (perms & UC_PROT_WRITE) == 0); count += len; addr += len; } // if EXEC permission is removed, then quit TB and continue at the same place if (remove_exec) { uc->quit_request = true; uc_emu_stop(uc); } return UC_ERR_OK; }