Changeset 6220


Ignore:
Timestamp:
Dec 8, 2018, 10:35:24 AM (6 months ago)
Author:
cameron
Message:

Trace facility initial check-in

Location:
icGREP/icgrep-devel/icgrep
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • icGREP/icgrep-devel/icgrep/IR_Gen/idisa_builder.cpp

    r6189 r6220  
    896896}
    897897
    898 Value * IDISA_Builder::simd_and(Value * a, Value * b) {
    899     return a->getType() == b->getType() ? CreateAnd(a, b) : CreateAnd(bitCast(a), bitCast(b));
    900 }
    901 
    902 Value * IDISA_Builder::simd_or(Value * a, Value * b) {
    903     return a->getType() == b->getType() ? CreateOr(a, b) : CreateOr(bitCast(a), bitCast(b));
     898Value * IDISA_Builder::simd_and(Value * a, Value * b, StringRef s) {
     899    return a->getType() == b->getType() ? CreateAnd(a, b, s) : CreateAnd(bitCast(a), bitCast(b), s);
     900}
     901
     902Value * IDISA_Builder::simd_or(Value * a, Value * b, StringRef s) {
     903    return a->getType() == b->getType() ? CreateOr(a, b, s) : CreateOr(bitCast(a), bitCast(b), s);
    904904}
    905905   
    906 Value * IDISA_Builder::simd_xor(Value * a, Value * b) {
    907     return a->getType() == b->getType() ? CreateXor(a, b) : CreateXor(bitCast(a), bitCast(b));
    908 }
    909 
    910 Value * IDISA_Builder::simd_not(Value * a) {
    911     return simd_xor(a, Constant::getAllOnesValue(a->getType()));
     906Value * IDISA_Builder::simd_xor(Value * a, Value * b, StringRef s) {
     907    return a->getType() == b->getType() ? CreateXor(a, b, s) : CreateXor(bitCast(a), bitCast(b), s);
     908}
     909
     910Value * IDISA_Builder::simd_not(Value * a, StringRef s) {
     911    return simd_xor(a, Constant::getAllOnesValue(a->getType()), s);
    912912}
    913913
  • icGREP/icgrep-devel/icgrep/IR_Gen/idisa_builder.h

    r6189 r6220  
    1313namespace llvm { class Module; }
    1414namespace llvm { class Value; }
     15namespace llvm { class StringRef; }
    1516
    1617namespace IDISA {
     
    181182    virtual void CreateBaseFunctions() {}
    182183   
    183     llvm::Value * simd_and(llvm::Value * a, llvm::Value * b);
    184     llvm::Value * simd_or(llvm::Value * a, llvm::Value * b);
    185     llvm::Value * simd_xor(llvm::Value * a, llvm::Value * b);
    186     llvm::Value * simd_not(llvm::Value * a);
     184    llvm::Value * simd_and(llvm::Value * a, llvm::Value * b, llvm::StringRef s = llvm::StringRef());
     185    llvm::Value * simd_or(llvm::Value * a, llvm::Value * b, llvm::StringRef s = llvm::StringRef());
     186    llvm::Value * simd_xor(llvm::Value * a, llvm::Value * b, llvm::StringRef s = llvm::StringRef());
     187    llvm::Value * simd_not(llvm::Value * a, llvm::StringRef s = llvm::StringRef());
    187188    llvm::Value * fwCast(unsigned fw, llvm::Value * a);
    188189   
  • icGREP/icgrep-devel/icgrep/kernels/s2p_kernel.cpp

    r6216 r6220  
    173173        Value * byteStreamBasePtr = kb->getInputStreamBlockPtr("byteStream", ZERO, ZERO);
    174174        Value * ptrToNull = kb->CreateMemChr(kb->CreatePointerCast(byteStreamBasePtr, voidPtrTy), kb->getInt32(0), itemsToDo);
    175         Value * nullInFile = kb->CreateICmpNE(ptrToNull, ZERO);
     175        Value * nullInFile = kb->CreateICmpNE(ptrToNull, ConstantPointerNull::get(cast<PointerType>(ptrToNull->getType())));
    176176        kb->CreateCondBr(nullInFile, nullInFileDetected, s2pExit);
    177177        kb->SetInsertPoint(nullInFileDetected);
  • icGREP/icgrep-devel/icgrep/pablo/pablo_compiler.cpp

    r6216 r6220  
    428428            Value * const op0 = compileExpression(b, stmt->getOperand(0));
    429429            Value * const op1 = compileExpression(b, stmt->getOperand(1));
    430             value = b->simd_and(op0, op1);
     430            value = b->simd_and(op0, op1, stmt->getName());
    431431        } else if (isa<Or>(stmt)) {
    432432            Value * const op0 = compileExpression(b, stmt->getOperand(0));
    433433            Value * const op1 = compileExpression(b, stmt->getOperand(1));
    434             value = b->simd_or(op0, op1);
     434            value = b->simd_or(op0, op1, stmt->getName());
    435435        } else if (isa<Xor>(stmt)) {
    436436            Value * const op0 = compileExpression(b, stmt->getOperand(0));
    437437            Value * const op1 = compileExpression(b, stmt->getOperand(1));
    438             value = b->simd_xor(op0, op1);
     438            value = b->simd_xor(op0, op1, stmt->getName());
    439439        } else if (const Sel * sel = dyn_cast<Sel>(stmt)) {
    440440            Value* ifMask = compileExpression(b, sel->getCondition());
     
    443443            value = b->simd_or(ifTrue, ifFalse);
    444444        } else if (isa<Not>(stmt)) {
    445             value = b->simd_not(compileExpression(b, stmt->getOperand(0)));
     445            value = b->simd_not(compileExpression(b, stmt->getOperand(0)), stmt->getName());
    446446        } else if (isa<Advance>(stmt)) {
    447447            const Advance * const adv = cast<Advance>(stmt);
     
    461461            Value * const marker_and_cc = b->simd_and(marker, cc);
    462462            Value * const sum = mCarryManager->addCarryInCarryOut(b, mstar, marker_and_cc, cc);
    463             value = b->simd_or(b->simd_xor(sum, cc), marker);
     463            value = b->simd_or(b->simd_xor(sum, cc), marker, mstar->getName());
    464464        } else if (const ScanThru * sthru = dyn_cast<ScanThru>(stmt)) {
    465465            Value * const from = compileExpression(b, sthru->getScanFrom());
    466466            Value * const thru = compileExpression(b, sthru->getScanThru());
    467467            Value * const sum = mCarryManager->addCarryInCarryOut(b, sthru, from, thru);
    468             value = b->simd_and(sum, b->simd_not(thru));
     468            value = b->simd_and(sum, b->simd_not(thru), sthru->getName());
    469469        } else if (const ScanTo * sthru = dyn_cast<ScanTo>(stmt)) {
    470470            Value * const marker_expr = compileExpression(b, sthru->getScanFrom());
    471471            Value * const to = b->simd_xor(compileExpression(b, sthru->getScanTo()), b->getScalarField("EOFmask"));
    472472            Value * const sum = mCarryManager->addCarryInCarryOut(b, sthru, marker_expr, b->simd_not(to));
    473             value = b->simd_and(sum, to);
     473            value = b->simd_and(sum, to, sthru->getName());
    474474        } else if (const AdvanceThenScanThru * sthru = dyn_cast<AdvanceThenScanThru>(stmt)) {
    475475            Value * const from = compileExpression(b, sthru->getScanFrom());
    476476            Value * const thru = compileExpression(b, sthru->getScanThru());
    477477            Value * const sum = mCarryManager->addCarryInCarryOut(b, sthru, from, b->simd_or(from, thru));
    478             value = b->simd_and(sum, b->simd_not(thru));
     478            value = b->simd_and(sum, b->simd_not(thru), sthru->getName());
    479479        } else if (const AdvanceThenScanTo * sthru = dyn_cast<AdvanceThenScanTo>(stmt)) {
    480480            Value * const from = compileExpression(b, sthru->getScanFrom());
    481481            Value * const to = b->simd_xor(compileExpression(b, sthru->getScanTo()), b->getScalarField("EOFmask"));
    482482            Value * const sum = mCarryManager->addCarryInCarryOut(b, sthru, from, b->simd_or(from, b->simd_not(to)));
    483             value = b->simd_and(sum, to);
     483            value = b->simd_and(sum, to, sthru->getName());
    484484        } else if (const TerminateAt * s = dyn_cast<TerminateAt>(stmt)) {
    485485            Value * signal_strm = compileExpression(b, s->getExpr());
  • icGREP/icgrep-devel/icgrep/toolchain/cpudriver.cpp

    r6209 r6220  
    1111#include <llvm/InitializePasses.h>                 // for initializeCodeGencd .
    1212#include <llvm/PassRegistry.h>                     // for PassRegistry
     13#include <llvm/Support/raw_ostream.h>              // for errs()
    1314#include <llvm/Support/CodeGen.h>                  // for Level, Level::None
    1415#include <llvm/Support/Compiler.h>                 // for LLVM_UNLIKELY
     
    198199        PM.add(createCFGSimplificationPass());
    199200    }
     201    if (LLVM_UNLIKELY(!codegen::TraceOption.empty())) {
     202        PM.add(createTracePass(iBuilder.get(), codegen::TraceOption));
     203    }
    200204    if (LLVM_UNLIKELY(codegen::ShowIROption != codegen::OmittedOption)) {
    201205        if (LLVM_LIKELY(mIROutputStream == nullptr)) {
     
    222226    }
    223227    #endif
     228
    224229    return PM;
    225230}
     
    314319    delete mTarget;
    315320}
     321
     322
     323class TracePass : public ModulePass {
     324public:
     325    static char ID;
     326    TracePass(kernel::KernelBuilder * kb, StringRef to_trace) : ModulePass(ID), iBuilder(kb), mToTrace(to_trace) { }
     327   
     328    virtual bool runOnModule(Module &M) override;
     329private:
     330    kernel::KernelBuilder * iBuilder;
     331    StringRef mToTrace;
     332};
     333
     334char TracePass::ID = 0;
     335
     336bool TracePass::runOnModule(Module & M) {
     337    Module * saveModule = iBuilder->getModule();
     338    iBuilder->setModule(&M);
     339    bool modified = false;
     340    for (auto & F : M) {
     341        for (auto & B : F) {
     342            for (BasicBlock::iterator i = B.begin(); i != B.end(); ) {
     343                auto i0 = i;
     344                ++i;
     345                if (!isa<Value>(*i0)) continue;
     346                StringRef theName = (*i0).getName();
     347                if (theName.startswith(mToTrace)) {
     348                    //errs() << theName << "\n";
     349                    Type * t = (*i0).getType();
     350                    //t->dump();
     351                    if (t == iBuilder->getBitBlockType()) {
     352                        iBuilder->SetInsertPoint(&B, i);
     353                        iBuilder->CallPrintRegister(theName, &*i0);
     354                        modified = true;
     355                    }
     356                    else if (t == iBuilder->getInt64Ty()) {
     357                        iBuilder->SetInsertPoint(&B, i);
     358                        iBuilder->CallPrintInt(theName, &*i0);
     359                        modified = true;
     360                    }
     361                }
     362            }
     363        }
     364    }
     365    //if (modified) M.dump();
     366    iBuilder->setModule(saveModule);
     367    return modified;
     368}
     369
     370ModulePass * CPUDriver::createTracePass(kernel::KernelBuilder * kb, StringRef to_trace) {
     371    return new TracePass(iBuilder.get(), to_trace);
     372}
     373                   
  • icGREP/icgrep-devel/icgrep/toolchain/cpudriver.h

    r6209 r6220  
    66namespace llvm { class TargetMachine; }
    77namespace llvm { class raw_fd_ostream; }
     8namespace llvm { class ModulePass; }
     9namespace kernel { class KernelBuilder; }
    810
    911#include <llvm/IR/LegacyPassManager.h>
     
    4547
    4648    bool hasExternalFunction(const llvm::StringRef functionName) const override;
     49   
     50    llvm::ModulePass * createTracePass(kernel::KernelBuilder * kb, llvm::StringRef to_trace);
     51
    4752
    4853private:
  • icGREP/icgrep-devel/icgrep/toolchain/toolchain.cpp

    r6184 r6220  
    9494                                         cl::desc("NUmber of groups declared on GPU"), cl::value_desc("positive integer"), cl::cat(CodeGenOptions));
    9595
     96std::string TraceOption = "";
     97static cl::opt<std::string, true> TraceValueOption("trace", cl::location(TraceOption),
     98                                            cl::desc("Instrument programs to trace values beginning prefix"), cl::value_desc("prefix"), cl::cat(CodeGenOptions));
     99
    96100CodeGenOpt::Level OptLevel;
    97101
  • icGREP/icgrep-devel/icgrep/toolchain/toolchain.h

    r6184 r6220  
    5151extern std::string ShowUnoptimizedIROption;
    5252extern std::string ShowIROption;
     53extern std::string TraceOption;
    5354#if LLVM_VERSION_INTEGER >= LLVM_VERSION_CODE(3, 7, 0)
    5455extern std::string ShowASMOption;
Note: See TracChangeset for help on using the changeset viewer.