ogles_context_t *ogles_init(size_t extra) { void* const base = malloc(extra + sizeof(ogles_context_t) + 32); if (!base) return 0; ogles_context_t *c = (ogles_context_t *)((ptrdiff_t(base) + extra + 31) & ~0x1FL); memset(c, 0, sizeof(ogles_context_t)); ggl_init_context(&(c->rasterizer)); // XXX: this should be passed as an argument sp<EGLSurfaceManager> smgr(new EGLSurfaceManager()); c->surfaceManager = smgr.get(); c->surfaceManager->incStrong(c); sp<EGLBufferObjectManager> bomgr(new EGLBufferObjectManager()); c->bufferObjectManager = bomgr.get(); c->bufferObjectManager->incStrong(c); ogles_init_array(c); ogles_init_matrix(c); ogles_init_vertex(c); ogles_init_light(c); ogles_init_texture(c); c->rasterizer.base = base; c->point.size = TRI_ONE; c->line.width = TRI_ONE; // in OpenGL, writing to the depth buffer is enabled by default. c->rasterizer.procs.depthMask(c, 1); // OpenGL enables dithering by default c->rasterizer.procs.enable(c, GL_DITHER); return c; }
int main(int argc, char *argv[]) { int i; bool bScale = false; double fScale = 0.0f; char * newFName = 0; DiffSimu smgr( argc, argv ); if (argc < 2) { printHelp(); exit(-1); } i = 1; while (i<argc) { if (strcmp("-s", argv[i]) == 0) { bScale = true; fScale = atof( argv[++i] ); newFName = argv[++i]; } i++; } if (bScale) { Grid * g = smgr.getGrid(); if (g != 0) { scaleGrid(g,fScale); DpReader dpr; dpr.SaveToFile(g,newFName); } } return(0); }
ogles_context_t *ogles_init(size_t extra) { void* const base = malloc(extra + sizeof(ogles_context_t) + 32); if (!base) return 0; ogles_context_t *c = (ogles_context_t *)((ptrdiff_t(base) + extra + 31) & ~0x1FL); memset(c, 0, sizeof(ogles_context_t)); ggl_init_context(&(c->rasterizer)); // XXX: this should be passed as an argument sp<EGLSurfaceManager> smgr(new EGLSurfaceManager()); c->surfaceManager = smgr.get(); c->surfaceManager->incStrong(c); sp<EGLBufferObjectManager> bomgr(new EGLBufferObjectManager()); c->bufferObjectManager = bomgr.get(); c->bufferObjectManager->incStrong(c); ogles_init_array(c); ogles_init_matrix(c); ogles_init_vertex(c); ogles_init_light(c); ogles_init_texture(c); c->rasterizer.base = base; c->point.size = TRI_ONE; c->line.width = TRI_ONE; // in OpenGL, writing to the depth buffer is enabled by default. c->rasterizer.procs.depthMask(c, 1); // OpenGL enables dithering by default c->rasterizer.procs.enable(c, GL_DITHER); c->copybits.blitEngine = NULL; c->copybits.minScale = 0; c->copybits.maxScale = 0; c->copybits.drawSurfaceBuffer = 0; #ifdef LIBAGL_USE_GRALLOC_COPYBITS hw_module_t const* module; if (hw_get_module(COPYBIT_HARDWARE_MODULE_ID, &module) == 0) { struct copybit_device_t* copyBits; if (copybit_open(module, ©Bits) == 0) { c->copybits.blitEngine = copyBits; { int minLim = copyBits->get(copyBits, COPYBIT_MINIFICATION_LIMIT); if (minLim != -EINVAL && minLim > 0) { c->copybits.minScale = (1 << 16) / minLim; } } { int magLim = copyBits->get(copyBits, COPYBIT_MAGNIFICATION_LIMIT); if (magLim != -EINVAL && magLim > 0) { c->copybits.maxScale = min(32*1024-1, magLim) << 16; } } } } #endif // LIBAGL_USE_GRALLOC_COPYBITS return c; }
void NasmInsnRunner::TestInsn(yasm::Insn* insn, std::size_t golden_len, const unsigned char* golden, const llvm::StringRef& ew_msg) { // // Turn the instruction into bytes // BytecodeContainer container(0); ::testing::StrictMock<MockDiagnosticString> mock_consumer; llvm::IntrusiveRefCntPtr<DiagnosticIDs> diagids(new DiagnosticIDs); DiagnosticsEngine diags(diagids, &mock_consumer, false); FileSystemOptions opts; FileManager fmgr(opts); SourceManager smgr(diags, fmgr); diags.setSourceManager(&smgr); if (!ew_msg.empty()) { EXPECT_CALL(mock_consumer, DiagString(ew_msg)) .Times(1); } else { // expect no diagnostic calls EXPECT_CALL(mock_consumer, DiagString(::testing::_)) .Times(0); } insn->Append(container, SourceLocation(), diags); container.Finalize(diags); if (diags.hasErrorOccurred()) return; container.bytecodes_front().CalcLen(AddSpanTest, diags); ASSERT_EQ(golden_len, container.bytecodes_front().getTotalLen()); if (diags.hasErrorOccurred()) return; container.UpdateOffsets(diags); if (diags.hasErrorOccurred()) return; llvm::SmallString<64> outbytes; llvm::raw_svector_ostream outstream(outbytes); RawOutput outputter(outstream, *m_arch, diags); container.bytecodes_front().Output(outputter); outstream.flush(); // // Compare the result against the golden result // if (golden_len != outbytes.size()) goto bad; for (std::size_t i=0; i<golden_len; ++i) { if ((int)(golden[i] & 0xff) != (int)(outbytes[i] & 0xff)) goto bad; } return; bad: std::string golden_str, outbytes_str; llvm::raw_string_ostream golden_ss(golden_str), outbytes_ss(outbytes_str); for (std::size_t i=0; i<golden_len; ++i) golden_ss << llvm::format("%02x ", (int)(golden[i] & 0xff)); golden_ss.flush(); for (std::size_t i=0; i<outbytes.size(); ++i) outbytes_ss << llvm::format("%02x ", (int)(outbytes[i] & 0xff)); outbytes_ss.flush(); ASSERT_EQ(golden_str, outbytes_str); }
void NasmInsnRunner::ParseAndTestLine(const char* filename, const llvm::StringRef& line, int linenum) { SCOPED_TRACE(llvm::format("%s:%d", filename, linenum)); llvm::StringRef insn_in, golden_in; llvm::tie(insn_in, golden_in) = line.split(';'); insn_in = strip(insn_in); golden_in = strip(golden_in); // Handle bits directive if (golden_in.empty() && insn_in.startswith("[bits ")) { int bits = atoi(insn_in.substr(6, 2).str().c_str()); if (bits == 64) m_arch->setMachine("amd64"); else m_arch->setMachine("x86"); m_arch->setVar("mode_bits", bits); return; } if (insn_in.empty() || golden_in.empty()) return; // skip lines that don't have both text and a comment // // parse the golden result // llvm::SmallVector<unsigned char, 64> golden; llvm::StringRef golden_errwarn; for (;;) { // strip whitespace golden_in = strip(golden_in); if (golden_in.empty() || !isxdigit(golden_in[0])) break; unsigned int byte_val = 0x100; llvm::StringRef byte_str; llvm::tie(byte_str, golden_in) = golden_in.split(' '); if (byte_str.size() == 2) // assume hex byte_val = (fromhexdigit(byte_str[0]) << 4) | fromhexdigit(byte_str[1]); else if (byte_str.size() == 3) // assume octal byte_val = (fromoctdigit(byte_str[0]) << 6) | (fromoctdigit(byte_str[1]) << 3) | fromoctdigit(byte_str[2]); ASSERT_LE(byte_val, 0xffU) << "invalid golden value"; golden.push_back(byte_val); } // interpret string in [] as error/warning if (!golden_in.empty() && golden_in[0] == '[') llvm::tie(golden_errwarn, golden_in) = golden_in.substr(1).split(']'); // // parse the instruction // ::testing::StrictMock<MockDiagnosticString> mock_consumer; llvm::IntrusiveRefCntPtr<DiagnosticIDs> diagids(new DiagnosticIDs); DiagnosticsEngine diags(diagids, &mock_consumer, false); FileSystemOptions opts; FileManager fmgr(opts); SourceManager smgr(diags, fmgr); diags.setSourceManager(&smgr); // instruction name is the first thing on the line llvm::StringRef insn_name; llvm::tie(insn_name, insn_in) = insn_in.split(' '); Arch::InsnPrefix insnprefix = m_arch->ParseCheckInsnPrefix(insn_name, SourceLocation(), diags); ASSERT_TRUE(insnprefix.isType(Arch::InsnPrefix::INSN)); std::auto_ptr<Insn> insn = m_arch->CreateInsn(insnprefix.getInsn()); ASSERT_TRUE(insn.get() != 0) << "unrecognized instruction '" << insn_name.str() << "'"; // parse insn arguments unsigned int wsize = m_arch_module->getWordSize(); // strip whitespace from arguments insn_in = strip(insn_in); while (!insn_in.empty()) { llvm::StringRef arg_str; llvm::tie(arg_str, insn_in) = insn_in.split(','); // strip whitespace from arg arg_str = strip(arg_str); unsigned int size = 0; bool strict = false; for (;;) { int next; int nsize = 0; // operand overrides (size and strict) if (arg_str.startswith("byte ")) { nsize = 8; next = 5; } else if (arg_str.startswith("hword ")) { nsize = wsize/2; next = 6; } else if (arg_str.startswith("word ")) { nsize = wsize; next = 5; } else if (arg_str.startswith("dword ")) { nsize = wsize*2; next = 6; } else if (arg_str.startswith("qword ")) { nsize = wsize*4; next = 6; } else if (arg_str.startswith("tword ")) { nsize = 80; next = 6; } else if (arg_str.startswith("dqword ")) { nsize = wsize*8; next = 7; } else if (arg_str.startswith("oword ")) { nsize = wsize*8; next = 6; } else if (arg_str.startswith("yword ")) { nsize = 256; next = 6; } else if (arg_str.startswith("strict ")) { strict = true; next = 7; } else break; if (size == 0) size = nsize; arg_str = arg_str.substr(next); } if (arg_str[0] == '[') { // Very simple int/reg expression parser. Does not handle parens or // order of operations; simply builds expr from left to right. // This means r8*4+r9 will have a different result than r9+r8*4! // Also only handles binary operators * and +. llvm::StringRef estr = arg_str.slice(1, arg_str.find(']')+1); std::auto_ptr<Expr> e(new Expr); char pendingop = '\0'; std::size_t tokstart = 0; for (std::size_t pos = 0; pos < estr.size(); ++pos) { if (estr[pos] == '*' || estr[pos] == '+' || estr[pos] == ']') { // figure out this token llvm::StringRef tok = strip(estr.slice(tokstart, pos)); if (isdigit(estr[tokstart])) e->Append(strtoint(tok)); else { Arch::RegTmod regtmod = m_arch->ParseCheckRegTmod(tok, SourceLocation(), diags); ASSERT_TRUE(regtmod.isType(Arch::RegTmod::REG)) << "cannot handle label '" << tok.str() << "'"; e->Append(*regtmod.getReg()); } // append pending operator if (pendingop == '*') e->AppendOp(Op::MUL, 2); else if (pendingop == '+') e->AppendOp(Op::ADD, 2); // store new operator pendingop = estr[pos]; tokstart = pos+1; } } Operand operand(m_arch->CreateEffAddr(e)); operand.setSize(size); operand.setStrict(strict); insn->AddOperand(operand); continue; } // TODO: split by space to allow target modifiers // Test for registers Arch::RegTmod regtmod = m_arch->ParseCheckRegTmod(arg_str, SourceLocation(), diags); if (const Register* reg = regtmod.getReg()) { Operand operand(reg); operand.setSize(size); operand.setStrict(strict); insn->AddOperand(operand); continue; } else if (const SegmentRegister* segreg = regtmod.getSegReg()) { Operand operand(segreg); operand.setSize(size); operand.setStrict(strict); insn->AddOperand(operand); continue; } else if (regtmod.getTargetMod()) { FAIL() << "cannot handle target modifier"; } else if (regtmod.getRegGroup()) { FAIL() << "cannot handle register group"; } // Can't handle labels ASSERT_TRUE(isdigit(arg_str[0]) || arg_str[0] == '-') << "cannot handle label '" << arg_str.str() << "'"; // Convert to integer expression Operand intop(Expr::Ptr(new Expr(strtoint(arg_str)))); intop.setSize(size); intop.setStrict(strict); insn->AddOperand(intop); } TestInsn(insn.get(), golden.size(), golden.data(), golden_errwarn); }