Value* NotEqualExpression::getValue() { assert(leftExpression != NULL); assert(rightExpression != NULL); assert(leftExpression->getType() == rightExpression->getType()); IRBuilder<>* builder = codegen::getBuilder(); int c; if(leftExpression->getType() != COLEXPRESSION) { c = leftExpression->getType(); } else { c = convertDTtoET(leftExpression->getDataType()); } switch(c) { case LONGVALUEEXPRESSION: return builder->CreateICmpNE(leftExpression->getValue(), rightExpression->getValue()); case DOUBLEVALUEEXPRESSION: return builder->CreateFCmpONE(leftExpression->getValue(), rightExpression->getValue()); case STRINGVALUEEXPRESSION: case DATEVALUEEXPRESSION: return codegen::stringCmp(leftExpression->getValue(), rightExpression->getValue(), NOTEQUALEXPRESSION); default: cout << "Unknown expression type!" << endl; exit(-1); } return NULL; }
void AddressSanitizer::instrumentAddress(Instruction *OrigIns, IRBuilder<> &IRB, Value *Addr, uint32_t TypeSize, bool IsWrite) { Value *AddrLong = IRB.CreatePointerCast(Addr, IntptrTy); Type *ShadowTy = IntegerType::get( *C, std::max(8U, TypeSize >> MappingScale)); Type *ShadowPtrTy = PointerType::get(ShadowTy, 0); Value *ShadowPtr = memToShadow(AddrLong, IRB); Value *CmpVal = Constant::getNullValue(ShadowTy); Value *ShadowValue = IRB.CreateLoad( IRB.CreateIntToPtr(ShadowPtr, ShadowPtrTy)); Value *Cmp = IRB.CreateICmpNE(ShadowValue, CmpVal); Instruction *CheckTerm = splitBlockAndInsertIfThen( cast<Instruction>(Cmp)->getNextNode(), Cmp); IRBuilder<> IRB2(CheckTerm); size_t Granularity = 1 << MappingScale; if (TypeSize < 8 * Granularity) { // Addr & (Granularity - 1) Value *Lower3Bits = IRB2.CreateAnd( AddrLong, ConstantInt::get(IntptrTy, Granularity - 1)); // (Addr & (Granularity - 1)) + size - 1 Value *LastAccessedByte = IRB2.CreateAdd( Lower3Bits, ConstantInt::get(IntptrTy, TypeSize / 8 - 1)); // (uint8_t) ((Addr & (Granularity-1)) + size - 1) LastAccessedByte = IRB2.CreateIntCast( LastAccessedByte, IRB.getInt8Ty(), false); // ((uint8_t) ((Addr & (Granularity-1)) + size - 1)) >= ShadowValue Value *Cmp2 = IRB2.CreateICmpSGE(LastAccessedByte, ShadowValue); CheckTerm = splitBlockAndInsertIfThen(CheckTerm, Cmp2); } IRBuilder<> IRB1(CheckTerm); Instruction *Crash = generateCrashCode(IRB1, AddrLong, IsWrite, TypeSize); Crash->setDebugLoc(OrigIns->getDebugLoc()); ReplaceInstWithInst(CheckTerm, new UnreachableInst(*C)); }
void AddressSanitizer::instrumentAddress(AsanFunctionContext &AFC, Instruction *OrigIns, IRBuilder<> &IRB, Value *Addr, uint32_t TypeSize, bool IsWrite) { Value *AddrLong = IRB.CreatePointerCast(Addr, IntptrTy); Type *ShadowTy = IntegerType::get( *C, std::max(8U, TypeSize >> MappingScale)); Type *ShadowPtrTy = PointerType::get(ShadowTy, 0); Value *ShadowPtr = memToShadow(AddrLong, IRB); Value *CmpVal = Constant::getNullValue(ShadowTy); Value *ShadowValue = IRB.CreateLoad( IRB.CreateIntToPtr(ShadowPtr, ShadowPtrTy)); Value *Cmp = IRB.CreateICmpNE(ShadowValue, CmpVal); size_t AccessSizeIndex = TypeSizeToSizeIndex(TypeSize); size_t Granularity = 1 << MappingScale; TerminatorInst *CrashTerm = 0; if (ClAlwaysSlowPath || (TypeSize < 8 * Granularity)) { TerminatorInst *CheckTerm = splitBlockAndInsertIfThen(Cmp, false); assert(dyn_cast<BranchInst>(CheckTerm)->isUnconditional()); BasicBlock *NextBB = CheckTerm->getSuccessor(0); IRB.SetInsertPoint(CheckTerm); Value *Cmp2 = createSlowPathCmp(IRB, AddrLong, ShadowValue, TypeSize); BasicBlock *CrashBlock = BasicBlock::Create(*C, "", &AFC.F, NextBB); CrashTerm = new UnreachableInst(*C, CrashBlock); BranchInst *NewTerm = BranchInst::Create(CrashBlock, NextBB, Cmp2); ReplaceInstWithInst(CheckTerm, NewTerm); } else { CrashTerm = splitBlockAndInsertIfThen(Cmp, true); } Instruction *Crash = generateCrashCode(CrashTerm, AddrLong, IsWrite, AccessSizeIndex); Crash->setDebugLoc(OrigIns->getDebugLoc()); }
static Value* emitCond(IRBuilder<>& builder, Value* arg) { return builder.CreateICmpNE(builder.CreateAnd(arg, builder.getInt64(1)), builder.getInt64(0)); }
void code_emitter::emit_stmts (statement_t *stmt, unsigned int slice_flag) { for (; stmt != NULL; stmt = stmt->next) { if (!must_emit_stmt(stmt, slice_flag)) continue; switch (stmt->kind) { case STMT_NIL : g_assert(slice_flag == SLICE_IGNORE); break; case STMT_ASSIGN : #ifdef DEBUG_OUTPUT compiler_print_assign_statement(stmt); printf("\n"); #endif if (stmt->v.assign.rhs->kind == RHS_OP && stmt->v.assign.rhs->v.op.op->index == OP_OUTPUT_TUPLE) builder->CreateRet(emit_primary(&stmt->v.assign.rhs->v.op.args[0])); else set_value(stmt->v.assign.lhs, emit_rhs(stmt->v.assign.rhs)); break; case STMT_IF_COND : { Value *condition_number = emit_rhs(stmt->v.if_cond.condition); Value *condition; map<rhs_t*, Value*> rhs_map; if (condition_number->getType() == Type::Int32Ty) condition = builder->CreateICmpNE(condition_number, make_int_const(0)); else if (condition_number->getType() == Type::FloatTy) condition = builder->CreateFCmpONE(condition_number, make_float_const(0.0)); else g_assert_not_reached(); BasicBlock *then_bb = BasicBlock::Create("then", current_function); BasicBlock *else_bb = BasicBlock::Create("else"); BasicBlock *merge_bb = BasicBlock::Create("ifcont"); builder->CreateCondBr(condition, then_bb, else_bb); builder->SetInsertPoint(then_bb); emit_stmts(stmt->v.if_cond.consequent, slice_flag); emit_phi_rhss(stmt->v.if_cond.exit, true, &rhs_map, slice_flag); builder->CreateBr(merge_bb); then_bb = builder->GetInsertBlock(); current_function->getBasicBlockList().push_back(else_bb); builder->SetInsertPoint(else_bb); emit_stmts(stmt->v.if_cond.alternative, slice_flag); emit_phi_rhss(stmt->v.if_cond.exit, false, &rhs_map, slice_flag); builder->CreateBr(merge_bb); else_bb = builder->GetInsertBlock(); current_function->getBasicBlockList().push_back(merge_bb); builder->SetInsertPoint(merge_bb); emit_phis(stmt->v.if_cond.exit, then_bb, else_bb, rhs_map, slice_flag); } break; case STMT_WHILE_LOOP: { BasicBlock *start_bb = builder->GetInsertBlock(); BasicBlock *entry_bb = BasicBlock::Create("entry", current_function); BasicBlock *body_bb = BasicBlock::Create("body"); BasicBlock *exit_bb = BasicBlock::Create("exit"); map<rhs_t*, Value*> rhs_map; emit_phi_rhss(stmt->v.while_loop.entry, true, &rhs_map, slice_flag); builder->CreateBr(entry_bb); builder->SetInsertPoint(entry_bb); emit_phis(stmt->v.while_loop.entry, start_bb, NULL, rhs_map, slice_flag); Value *invariant_number = emit_rhs(stmt->v.while_loop.invariant); Value *invariant; if (invariant_number->getType() == Type::Int32Ty) invariant = builder->CreateICmpNE(invariant_number, make_int_const(0)); else if (invariant_number->getType() == Type::FloatTy) invariant = builder->CreateFCmpONE(invariant_number, make_float_const(0.0)); else g_assert_not_reached(); builder->CreateCondBr(invariant, body_bb, exit_bb); current_function->getBasicBlockList().push_back(body_bb); builder->SetInsertPoint(body_bb); emit_stmts(stmt->v.while_loop.body, slice_flag); body_bb = builder->GetInsertBlock(); emit_phi_rhss(stmt->v.while_loop.entry, false, &rhs_map, slice_flag); emit_phis(stmt->v.while_loop.entry, NULL, body_bb, rhs_map, slice_flag); builder->CreateBr(entry_bb); current_function->getBasicBlockList().push_back(exit_bb); builder->SetInsertPoint(exit_bb); } break; default: g_assert_not_reached(); break; } } }