/// @brief Platform-level implementation called by modifyRing() ReturnCode platModifyRing(const Target<TARGET_TYPE_ALL>& i_target, const scanRingId_t i_address, const variable_buffer& i_data, const ChipOpModifyMode i_modifyMode, const RingMode i_ringMode) { FAPI_DBG(ENTER_MRK "platModifyRing"); // TODO RTC:152489 - story to finish this modifyRing FAPI_ERR("platModifyRing: not supported yet"); assert(0,"platModifyRing not supported yet."); ReturnCode l_rc; errlHndl_t l_err = NULL; variable_buffer l_current_data(i_data); // Note: Trace is placed here in plat code because PPE doesn't support // trace in common fapi2_hw_access.H bool l_traceit = platIsScanTraceEnabled(); // Grab the name of the target TARGETING::ATTR_FAPI_NAME_type l_targName = {0}; fapi2::toString(i_target, l_targName, sizeof(l_targName)); do { // Extract the component pointer TARGETING::Target* l_target = reinterpret_cast<TARGETING::Target*>(i_target.get()); // -------------------- // Read current value // -------------------- uint64_t l_ringLen = l_current_data.getBitLength(); uint64_t l_flag = platGetDDScanMode(i_ringMode); size_t l_size = l_current_data.getLength<uint8_t>(); l_err = deviceRead(l_target, l_current_data.pointer(), l_size, DEVICE_SCAN_ADDRESS(i_address, l_ringLen, l_flag)); if (l_err) { FAPI_ERR("platModifyRing: deviceRead returns error!"); FAPI_ERR("platModifyRing failed - Target %s, Addr %.16llX", l_targName, i_address); // Add the error log pointer as data to the ReturnCode l_rc.setPlatDataPtr(reinterpret_cast<void *> (l_err)); // break out if read fails break; } // ---------------------- // Applying modification // ---------------------- /* TODO-RTC:151261 - re-enable when variable_buffer operations supported if (fapi2::CHIP_OP_MODIFY_MODE_OR == i_modifyMode) { l_current_data |= i_data; } else if (fapi2::CHIP_OP_MODIFY_MODE_AND == i_modifyMode) { l_current_data &= i_data; } else { l_current_data ^= i_data; } */ // ------------------------- // Write back updated data // ------------------------- l_err = deviceWrite(l_target, l_current_data.pointer(), l_size, DEVICE_SCAN_ADDRESS(i_address, l_ringLen, l_flag)); if (l_err) { FAPI_ERR("platModifyRing: deviceWrite returns error!"); FAPI_ERR("platModifyRing failed - Target %s, Addr %.16llX", l_targName, i_address); // Add the error log pointer as data to the ReturnCode l_rc.setPlatDataPtr(reinterpret_cast<void *> (l_err)); break; } } while (0); if (l_traceit) { uint64_t l_data = l_current_data.get<uint64_t>(); FAPI_SCAN("TRACE : MODIFYRING : %s : %.16llX %.16llX", l_targName, i_address, l_data); } FAPI_DBG(EXIT_MRK "platModifyRing"); return l_rc; }
Error ClangExpressionParser::PrepareForExecution (lldb::addr_t &func_addr, lldb::addr_t &func_end, std::shared_ptr<IRExecutionUnit> &execution_unit_sp, ExecutionContext &exe_ctx, bool &can_interpret, ExecutionPolicy execution_policy) { func_addr = LLDB_INVALID_ADDRESS; func_end = LLDB_INVALID_ADDRESS; Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); Error err; std::unique_ptr<llvm::Module> llvm_module_ap (m_code_generator->ReleaseModule()); if (!llvm_module_ap.get()) { err.SetErrorToGenericError(); err.SetErrorString("IR doesn't contain a module"); return err; } // Find the actual name of the function (it's often mangled somehow) ConstString function_name; if (!FindFunctionInModule(function_name, llvm_module_ap.get(), m_expr.FunctionName())) { err.SetErrorToGenericError(); err.SetErrorStringWithFormat("Couldn't find %s() in the module", m_expr.FunctionName()); return err; } else { if (log) log->Printf("Found function %s for %s", function_name.AsCString(), m_expr.FunctionName()); } execution_unit_sp.reset(new IRExecutionUnit (m_llvm_context, // handed off here llvm_module_ap, // handed off here function_name, exe_ctx.GetTargetSP(), m_compiler->getTargetOpts().Features)); ClangExpressionDeclMap *decl_map = m_expr.DeclMap(); // result can be NULL if (decl_map) { Stream *error_stream = NULL; Target *target = exe_ctx.GetTargetPtr(); if (target) error_stream = target->GetDebugger().GetErrorFile().get(); IRForTarget ir_for_target(decl_map, m_expr.NeedsVariableResolution(), *execution_unit_sp, error_stream, function_name.AsCString()); bool ir_can_run = ir_for_target.runOnModule(*execution_unit_sp->GetModule()); Error interpret_error; can_interpret = IRInterpreter::CanInterpret(*execution_unit_sp->GetModule(), *execution_unit_sp->GetFunction(), interpret_error); Process *process = exe_ctx.GetProcessPtr(); if (!ir_can_run) { err.SetErrorString("The expression could not be prepared to run in the target"); return err; } if (!can_interpret && execution_policy == eExecutionPolicyNever) { err.SetErrorStringWithFormat("Can't run the expression locally: %s", interpret_error.AsCString()); return err; } if (!process && execution_policy == eExecutionPolicyAlways) { err.SetErrorString("Expression needed to run in the target, but the target can't be run"); return err; } if (execution_policy == eExecutionPolicyAlways || !can_interpret) { if (m_expr.NeedsValidation() && process) { if (!process->GetDynamicCheckers()) { DynamicCheckerFunctions *dynamic_checkers = new DynamicCheckerFunctions(); StreamString install_errors; if (!dynamic_checkers->Install(install_errors, exe_ctx)) { if (install_errors.GetString().empty()) err.SetErrorString ("couldn't install checkers, unknown error"); else err.SetErrorString (install_errors.GetString().c_str()); return err; } process->SetDynamicCheckers(dynamic_checkers); if (log) log->Printf("== [ClangUserExpression::Evaluate] Finished installing dynamic checkers =="); } IRDynamicChecks ir_dynamic_checks(*process->GetDynamicCheckers(), function_name.AsCString()); if (!ir_dynamic_checks.runOnModule(*execution_unit_sp->GetModule())) { err.SetErrorToGenericError(); err.SetErrorString("Couldn't add dynamic checks to the expression"); return err; } } execution_unit_sp->GetRunnableInfo(err, func_addr, func_end); } } else { execution_unit_sp->GetRunnableInfo(err, func_addr, func_end); } return err; }
bool ValueObjectDynamicValue::UpdateValue () { SetValueIsValid (false); m_error.Clear(); if (!m_parent->UpdateValueIfNeeded(false)) { // The dynamic value failed to get an error, pass the error along if (m_error.Success() && m_parent->GetError().Fail()) m_error = m_parent->GetError(); return false; } // Setting our type_sp to NULL will route everything back through our // parent which is equivalent to not using dynamic values. if (m_use_dynamic == lldb::eNoDynamicValues) { m_dynamic_type_info.Clear(); return true; } ExecutionContext exe_ctx (GetExecutionContextRef()); Target *target = exe_ctx.GetTargetPtr(); if (target) { m_data.SetByteOrder(target->GetArchitecture().GetByteOrder()); m_data.SetAddressByteSize(target->GetArchitecture().GetAddressByteSize()); } // First make sure our Type and/or Address haven't changed: Process *process = exe_ctx.GetProcessPtr(); if (!process) return false; TypeAndOrName class_type_or_name; Address dynamic_address; bool found_dynamic_type = false; lldb::LanguageType known_type = m_parent->GetObjectRuntimeLanguage(); if (known_type != lldb::eLanguageTypeUnknown && known_type != lldb::eLanguageTypeC) { LanguageRuntime *runtime = process->GetLanguageRuntime (known_type); if (runtime) found_dynamic_type = runtime->GetDynamicTypeAndAddress (*m_parent, m_use_dynamic, class_type_or_name, dynamic_address); } else { LanguageRuntime *cpp_runtime = process->GetLanguageRuntime (lldb::eLanguageTypeC_plus_plus); if (cpp_runtime) found_dynamic_type = cpp_runtime->GetDynamicTypeAndAddress (*m_parent, m_use_dynamic, class_type_or_name, dynamic_address); if (!found_dynamic_type) { LanguageRuntime *objc_runtime = process->GetLanguageRuntime (lldb::eLanguageTypeObjC); if (objc_runtime) found_dynamic_type = objc_runtime->GetDynamicTypeAndAddress (*m_parent, m_use_dynamic, class_type_or_name, dynamic_address); } } // Getting the dynamic value may have run the program a bit, and so marked us as needing updating, but we really // don't... m_update_point.SetUpdated(); if (found_dynamic_type) { if (class_type_or_name.HasType()) { m_type_impl = TypeImpl(m_parent->GetClangType(),FixupTypeAndOrName(class_type_or_name, *m_parent).GetClangASTType()); } else { m_type_impl.Clear(); } } else { m_type_impl.Clear(); } // If we don't have a dynamic type, then make ourselves just a echo of our parent. // Or we could return false, and make ourselves an echo of our parent? if (!found_dynamic_type) { if (m_dynamic_type_info) SetValueDidChange(true); ClearDynamicTypeInformation(); m_dynamic_type_info.Clear(); m_value = m_parent->GetValue(); m_error = m_value.GetValueAsData (&exe_ctx, m_data, 0, GetModule().get()); return m_error.Success(); } Value old_value(m_value); Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TYPES)); bool has_changed_type = false; if (!m_dynamic_type_info) { m_dynamic_type_info = class_type_or_name; has_changed_type = true; } else if (class_type_or_name != m_dynamic_type_info) { // We are another type, we need to tear down our children... m_dynamic_type_info = class_type_or_name; SetValueDidChange (true); has_changed_type = true; } if (has_changed_type) ClearDynamicTypeInformation (); if (!m_address.IsValid() || m_address != dynamic_address) { if (m_address.IsValid()) SetValueDidChange (true); // We've moved, so we should be fine... m_address = dynamic_address; lldb::TargetSP target_sp (GetTargetSP()); lldb::addr_t load_address = m_address.GetLoadAddress(target_sp.get()); m_value.GetScalar() = load_address; } m_dynamic_type_info = FixupTypeAndOrName(m_dynamic_type_info, *m_parent); //m_value.SetContext (Value::eContextTypeClangType, corrected_type); m_value.SetClangType (m_dynamic_type_info.GetClangASTType()); // Our address is the location of the dynamic type stored in memory. It isn't a load address, // because we aren't pointing to the LOCATION that stores the pointer to us, we're pointing to us... m_value.SetValueType(Value::eValueTypeScalar); if (has_changed_type && log) log->Printf("[%s %p] has a new dynamic type %s", GetName().GetCString(), static_cast<void*>(this), GetTypeName().GetCString()); if (m_address.IsValid() && m_dynamic_type_info) { // The variable value is in the Scalar value inside the m_value. // We can point our m_data right to it. m_error = m_value.GetValueAsData (&exe_ctx, m_data, 0, GetModule().get()); if (m_error.Success()) { if (!CanProvideValue()) { // this value object represents an aggregate type whose // children have values, but this object does not. So we // say we are changed if our location has changed. SetValueDidChange (m_value.GetValueType() != old_value.GetValueType() || m_value.GetScalar() != old_value.GetScalar()); } SetValueIsValid (true); return true; } } // We get here if we've failed above... SetValueIsValid (false); return false; }
void MoonEGLContext::SyncDrawable () { Target *target = Top ()->GetTarget (); Target *cairo = target->GetCairoTarget (); MoonSurface *ms; Rect r = target->GetData (&ms); MoonEGLSurface *dst = (MoonEGLSurface *) ms; // clear target contents if (!target->GetInit ()) { if (!dst->GetEGLDisplay ()) GLContext::SetFramebuffer (); glClearColor (0.0, 0.0, 0.0, 0.0); glClear (GL_COLOR_BUFFER_BIT); // mark target contents as initialized target->SetInit (ms); } // initialize target contents with surface if (target->GetInit () != ms) { MoonEGLSurface *src = (MoonEGLSurface *) target->GetInit (); GLuint texture0 = src->Texture (); GLuint program = GetProjectProgram (1.0, 0); GLsizei width0 = src->Width (); GLsizei height0 = src->Height (); if (!dst->GetEGLDisplay ()) GLContext::SetFramebuffer (); SetViewport (); glUseProgram (program); SetupVertexData (NULL, 0, 0, width0, height0); SetupTexCoordData (); glVertexAttribPointer (0, 4, GL_FLOAT, GL_FALSE, 0, vertices); glVertexAttribPointer (1, 4, GL_FLOAT, GL_FALSE, 0, texcoords); glBindTexture (GL_TEXTURE_2D, texture0); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glUniform1i (glGetUniformLocation (program, "sampler0"), 0); glEnableVertexAttribArray (0); glEnableVertexAttribArray (1); glDrawArrays (GL_TRIANGLE_FAN, 0, 4); glDisableVertexAttribArray (1); glDisableVertexAttribArray (0); glBindTexture (GL_TEXTURE_2D, 0); glUseProgram (0); glBindFramebuffer (GL_FRAMEBUFFER, 0); // mark target contents as initialized target->SetInit (ms); } // render any cairo contents onto target if (cairo) { MoonSurface *mSrc; Rect rSrc = cairo->GetData (&mSrc); MoonEGLSurface *src = (MoonEGLSurface *) mSrc; GLuint texture0 = src->Texture (); GLuint program = GetProjectProgram (1.0, 0); GLsizei width0 = src->Width (); GLsizei height0 = src->Height (); if (!dst->GetEGLDisplay ()) GLContext::SetFramebuffer (); SetViewport (); glUseProgram (program); SetupVertexData (NULL, rSrc.x - r.x, rSrc.y - r.y, width0, height0); SetupTexCoordData (); glVertexAttribPointer (0, 4, GL_FLOAT, GL_FALSE, 0, vertices); glVertexAttribPointer (1, 4, GL_FLOAT, GL_FALSE, 0, texcoords); glBindTexture (GL_TEXTURE_2D, texture0); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); glUniform1i (glGetUniformLocation (program, "sampler0"), 0); glEnableVertexAttribArray (0); glEnableVertexAttribArray (1); glEnable (GL_BLEND); glBlendFunc (GL_ONE, GL_ONE_MINUS_SRC_ALPHA); glDrawArrays (GL_TRIANGLE_FAN, 0, 4); glDisable (GL_BLEND); glDisableVertexAttribArray (1); glDisableVertexAttribArray (0); glBindTexture (GL_TEXTURE_2D, 0); glUseProgram (0); glBindFramebuffer (GL_FRAMEBUFFER, 0); mSrc->unref (); target->SetCairoTarget (NULL); } ms->unref (); }
int main(int argc, char **argv) { Target target = get_jit_target_from_environment(); // We want to test all possible data flows for a buffer: // input -> host // input -> dev // host -> host // host -> dev // dev -> host // dev -> dev // dev -> output // host -> output // We can't really test the last two in the same routine, so we'll // run two routines. { // Pipeline 1 will do input -> host -> dev -> host -> output ImageParam in(Int(32), 1); Func f, g, out; Var x, xi; f(x) = in(x) + 1; g(x) = f(x) * 2; out(x) = g(x) + 3; f.compute_root(); if (target.has_gpu_feature()) { g.compute_root().gpu_tile(x, xi, 16); } else if (target.features_any_of({Target::HVX_64, Target::HVX_128})) { g.compute_root().hexagon(); } out.compute_root(); Buffer<int> input(1024); lambda(x, x * 17 + 83).realize(input); in.set(input); Buffer<int> output1(1024); out.realize(output1); output1.copy_to_host(); for (int x = 0; x < 1024; x++) { int correct = (input(x) + 1) * 2 + 3; if (output1(x) != correct) { printf("output1(%d) = %d instead of %d\n", x, output1(x), correct); return -1; } } } { // Pipeline 2 will do input -> dev -> dev -> output ImageParam in(Int(32), 1); Func f, out; Var x, xi; f(x) = in(x) + 1; out(x) = f(x) * 2; if (target.has_gpu_feature()) { f.compute_root().gpu_tile(x, xi, 16); out.compute_root().gpu_tile(x, xi, 16); } else if (target.features_any_of({Target::HVX_64, Target::HVX_128})) { f.compute_root().hexagon(); out.compute_root().hexagon(); } Buffer<int> input(1024); lambda(x, x * 17 + 83).realize(input); in.set(input); Buffer<int> output2(1024); out.realize(output2); output2.copy_to_host(); for (int x = 0; x < 1024; x++) { int correct = (input(x) + 1) * 2; if (output2(x) != correct) { printf("output2(%d) = %d instead of %d\n", x, output2(x), correct); return -1; } } } printf("Success!\n"); return 0; }
LLVMTargetMachine::LLVMTargetMachine(const Target &T, const std::string &Triple) : TargetMachine(T), TargetTriple(Triple) { AsmInfo = T.createAsmInfo(TargetTriple); }
bool AppleObjCRuntime::GetObjectDescription (Stream &strm, Value &value, ExecutionContextScope *exe_scope) { if (!m_read_objc_library) return false; ExecutionContext exe_ctx; exe_scope->CalculateExecutionContext(exe_ctx); Process *process = exe_ctx.GetProcessPtr(); if (!process) return false; // We need other parts of the exe_ctx, but the processes have to match. assert (m_process == process); // Get the function address for the print function. const Address *function_address = GetPrintForDebuggerAddr(); if (!function_address) return false; Target *target = exe_ctx.GetTargetPtr(); ClangASTType clang_type = value.GetClangType(); if (clang_type) { if (!clang_type.IsObjCObjectPointerType()) { strm.Printf ("Value doesn't point to an ObjC object.\n"); return false; } } else { // If it is not a pointer, see if we can make it into a pointer. ClangASTContext *ast_context = target->GetScratchClangASTContext(); ClangASTType opaque_type = ast_context->GetBasicType(eBasicTypeObjCID); if (!opaque_type) opaque_type = ast_context->GetBasicType(eBasicTypeVoid).GetPointerType(); //value.SetContext(Value::eContextTypeClangType, opaque_type_ptr); value.SetClangType (opaque_type); } ValueList arg_value_list; arg_value_list.PushValue(value); // This is the return value: ClangASTContext *ast_context = target->GetScratchClangASTContext(); ClangASTType return_clang_type = ast_context->GetCStringType(true); Value ret; // ret.SetContext(Value::eContextTypeClangType, return_clang_type); ret.SetClangType (return_clang_type); if (exe_ctx.GetFramePtr() == NULL) { Thread *thread = exe_ctx.GetThreadPtr(); if (thread == NULL) { exe_ctx.SetThreadSP(process->GetThreadList().GetSelectedThread()); thread = exe_ctx.GetThreadPtr(); } if (thread) { exe_ctx.SetFrameSP(thread->GetSelectedFrame()); } } // Now we're ready to call the function: ClangFunction func (*exe_ctx.GetBestExecutionContextScope(), return_clang_type, *function_address, arg_value_list); StreamString error_stream; lldb::addr_t wrapper_struct_addr = LLDB_INVALID_ADDRESS; func.InsertFunction(exe_ctx, wrapper_struct_addr, error_stream); EvaluateExpressionOptions options; options.SetUnwindOnError(true); options.SetTryAllThreads(true); options.SetStopOthers(true); options.SetIgnoreBreakpoints(true); options.SetTimeoutUsec(PO_FUNCTION_TIMEOUT_USEC); ExecutionResults results = func.ExecuteFunction (exe_ctx, &wrapper_struct_addr, options, error_stream, ret); if (results != eExecutionCompleted) { strm.Printf("Error evaluating Print Object function: %d.\n", results); return false; } addr_t result_ptr = ret.GetScalar().ULongLong(LLDB_INVALID_ADDRESS); char buf[512]; size_t cstr_len = 0; size_t full_buffer_len = sizeof (buf) - 1; size_t curr_len = full_buffer_len; while (curr_len == full_buffer_len) { Error error; curr_len = process->ReadCStringFromMemory(result_ptr + cstr_len, buf, sizeof(buf), error); strm.Write (buf, curr_len); cstr_len += curr_len; } return cstr_len > 0; }
void BreakpointLocation::GetDescription (Stream *s, lldb::DescriptionLevel level) { SymbolContext sc; s->Indent(); BreakpointID::GetCanonicalReference(s, m_owner.GetID(), GetID()); if (level == lldb::eDescriptionLevelBrief) return; s->PutCString(": "); if (level == lldb::eDescriptionLevelVerbose) s->IndentMore(); if (m_address.IsSectionOffset()) { m_address.CalculateSymbolContext(&sc); if (level == lldb::eDescriptionLevelFull) { s->PutCString("where = "); sc.DumpStopContext (s, m_owner.GetTarget().GetProcessSP().get(), m_address, false, true, false); } else { if (sc.module_sp) { s->EOL(); s->Indent("module = "); sc.module_sp->GetFileSpec().Dump (s); } if (sc.comp_unit != NULL) { s->EOL(); s->Indent("compile unit = "); static_cast<FileSpec*>(sc.comp_unit)->GetFilename().Dump (s); if (sc.function != NULL) { s->EOL(); s->Indent("function = "); s->PutCString (sc.function->GetMangled().GetName().AsCString("<unknown>")); } if (sc.line_entry.line > 0) { s->EOL(); s->Indent("location = "); sc.line_entry.DumpStopContext (s, true); } } else { // If we don't have a comp unit, see if we have a symbol we can print. if (sc.symbol) { s->EOL(); s->Indent("symbol = "); s->PutCString(sc.symbol->GetMangled().GetName().AsCString("<unknown>")); } } } } if (level == lldb::eDescriptionLevelVerbose) { s->EOL(); s->Indent(); } s->Printf ("%saddress = ", (level == lldb::eDescriptionLevelFull && m_address.IsSectionOffset()) ? ", " : ""); ExecutionContextScope *exe_scope = NULL; Target *target = &m_owner.GetTarget(); if (target) exe_scope = target->GetProcessSP().get(); if (exe_scope == NULL) exe_scope = target; m_address.Dump(s, exe_scope, Address::DumpStyleLoadAddress, Address::DumpStyleModuleWithFileAddress); if (level == lldb::eDescriptionLevelVerbose) { s->EOL(); s->Indent(); s->Printf("resolved = %s\n", IsResolved() ? "true" : "false"); s->Indent(); s->Printf ("hit count = %-4u\n", GetHitCount()); if (m_options_ap.get()) { s->Indent(); m_options_ap->GetDescription (s, level); s->EOL(); } s->IndentLess(); } else { s->Printf(", %sresolved, hit count = %u ", (IsResolved() ? "" : "un"), GetHitCount()); if (m_options_ap.get()) { m_options_ap->GetDescription (s, level); } } }
bool ClangUserExpression::Parse (Stream &error_stream, ExecutionContext &exe_ctx, lldb_private::ExecutionPolicy execution_policy, bool keep_result_in_memory, bool generate_debug_info) { Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS)); Error err; InstallContext(exe_ctx); if (Target *target = exe_ctx.GetTargetPtr()) { if (PersistentExpressionState *persistent_state = target->GetPersistentExpressionStateForLanguage(lldb::eLanguageTypeC)) { m_result_delegate.RegisterPersistentState(persistent_state); } else { error_stream.PutCString ("error: couldn't start parsing (no persistent data)"); return false; } } else { error_stream.PutCString ("error: couldn't start parsing (no target)"); return false; } ScanContext(exe_ctx, err); if (!err.Success()) { error_stream.Printf("warning: %s\n", err.AsCString()); } StreamString m_transformed_stream; //////////////////////////////////// // Generate the expression // ApplyObjcCastHack(m_expr_text); //ApplyUnicharHack(m_expr_text); std::string prefix = m_expr_prefix; if (ClangModulesDeclVendor *decl_vendor = m_target->GetClangModulesDeclVendor()) { const ClangModulesDeclVendor::ModuleVector &hand_imported_modules = llvm::cast<ClangPersistentVariables>(m_target->GetPersistentExpressionStateForLanguage(lldb::eLanguageTypeC))->GetHandLoadedClangModules(); ClangModulesDeclVendor::ModuleVector modules_for_macros; for (ClangModulesDeclVendor::ModuleID module : hand_imported_modules) { modules_for_macros.push_back(module); } if (m_target->GetEnableAutoImportClangModules()) { if (StackFrame *frame = exe_ctx.GetFramePtr()) { if (Block *block = frame->GetFrameBlock()) { SymbolContext sc; block->CalculateSymbolContext(&sc); if (sc.comp_unit) { StreamString error_stream; decl_vendor->AddModulesForCompileUnit(*sc.comp_unit, modules_for_macros, error_stream); } } } } } std::unique_ptr<ExpressionSourceCode> source_code (ExpressionSourceCode::CreateWrapped(prefix.c_str(), m_expr_text.c_str())); lldb::LanguageType lang_type; if (m_in_cplusplus_method) lang_type = lldb::eLanguageTypeC_plus_plus; else if (m_in_objectivec_method) lang_type = lldb::eLanguageTypeObjC; else lang_type = lldb::eLanguageTypeC; if (!source_code->GetText(m_transformed_text, lang_type, m_const_object, m_in_static_method, exe_ctx)) { error_stream.PutCString ("error: couldn't construct expression body"); return false; } if (log) log->Printf("Parsing the following code:\n%s", m_transformed_text.c_str()); //////////////////////////////////// // Set up the target and compiler // Target *target = exe_ctx.GetTargetPtr(); if (!target) { error_stream.PutCString ("error: invalid target\n"); return false; } ////////////////////////// // Parse the expression // m_materializer_ap.reset(new Materializer()); ResetDeclMap(exe_ctx, m_result_delegate, keep_result_in_memory); class OnExit { public: typedef std::function <void (void)> Callback; OnExit (Callback const &callback) : m_callback(callback) { } ~OnExit () { m_callback(); } private: Callback m_callback; }; OnExit on_exit([this]() { ResetDeclMap(); }); if (!DeclMap()->WillParse(exe_ctx, m_materializer_ap.get())) { error_stream.PutCString ("error: current process state is unsuitable for expression parsing\n"); ResetDeclMap(); // We are being careful here in the case of breakpoint conditions. return false; } Process *process = exe_ctx.GetProcessPtr(); ExecutionContextScope *exe_scope = process; if (!exe_scope) exe_scope = exe_ctx.GetTargetPtr(); ClangExpressionParser parser(exe_scope, *this, generate_debug_info); unsigned num_errors = parser.Parse (error_stream); if (num_errors) { error_stream.Printf ("error: %d errors parsing expression\n", num_errors); ResetDeclMap(); // We are being careful here in the case of breakpoint conditions. return false; } ////////////////////////////////////////////////////////////////////////////////////////// // Prepare the output of the parser for execution, evaluating it statically if possible // Error jit_error = parser.PrepareForExecution (m_jit_start_addr, m_jit_end_addr, m_execution_unit_sp, exe_ctx, m_can_interpret, execution_policy); if (generate_debug_info) { lldb::ModuleSP jit_module_sp ( m_execution_unit_sp->GetJITModule()); if (jit_module_sp) { ConstString const_func_name(FunctionName()); FileSpec jit_file; jit_file.GetFilename() = const_func_name; jit_module_sp->SetFileSpecAndObjectName (jit_file, ConstString()); m_jit_module_wp = jit_module_sp; target->GetImages().Append(jit_module_sp); } // lldb_private::ObjectFile *jit_obj_file = jit_module_sp->GetObjectFile(); // StreamFile strm (stdout, false); // if (jit_obj_file) // { // jit_obj_file->GetSectionList(); // jit_obj_file->GetSymtab(); // jit_obj_file->Dump(&strm); // } // lldb_private::SymbolVendor *jit_sym_vendor = jit_module_sp->GetSymbolVendor(); // if (jit_sym_vendor) // { // lldb_private::SymbolContextList sc_list; // jit_sym_vendor->FindFunctions(const_func_name, NULL, lldb::eFunctionNameTypeFull, true, false, sc_list); // sc_list.Dump(&strm, target); // jit_sym_vendor->Dump(&strm); // } } ResetDeclMap(); // Make this go away since we don't need any of its state after parsing. This also gets rid of any ClangASTImporter::Minions. if (jit_error.Success()) { if (process && m_jit_start_addr != LLDB_INVALID_ADDRESS) m_jit_process_wp = lldb::ProcessWP(process->shared_from_this()); return true; } else { const char *error_cstr = jit_error.AsCString(); if (error_cstr && error_cstr[0]) error_stream.Printf ("error: %s\n", error_cstr); else error_stream.Printf ("error: expression can't be interpreted or run\n"); return false; } }
bool CFPatch::apply(codeGen &gen, CodeBuffer *buf) { if (needsTOCUpdate()) { relocation_cerr << "\t\t\t isSpecialCase..." << endl; gen.setFunction(const_cast<func_instance *>(func)); if (!handleTOCUpdate(gen)) { relocation_cerr << "TOC special case handling in PPC64 failed" << endl; return false; } return true; } // Question: are we doing an inter-module static control transfer? // If so, things get... complicated if (isPLT(gen)) { relocation_cerr << "\t\t\t isPLT..." << endl; if (!applyPLT(gen, buf)) { relocation_cerr << "PLT special case handling in PPC64" << endl; return false; } return true; } // Otherwise this is a classic, and therefore easy. int targetLabel = target->label(buf); Address targetAddr = buf->predictedAddr(targetLabel); relocation_cerr << "\t\t CFPatch::apply, type " << type << ", origAddr " << hex << origAddr_ << ", and label " << dec << targetLabel << endl; if (orig_insn.isValid()) { relocation_cerr << "\t\t\t Currently at " << hex << gen.currAddr() << " and targeting predicted " << targetAddr << dec << endl; switch(type) { case CFPatch::Jump: { relocation_cerr << "\t\t\t Generating CFPatch::Jump from " << hex << gen.currAddr() << " to " << targetAddr << dec << endl; if (!insnCodeGen::modifyJump(targetAddr, *ugly_insn, gen)) { relocation_cerr << "modifyJump failed, ret false" << endl; return false; } return true; } case CFPatch::JCC: { relocation_cerr << "\t\t\t Generating CFPatch::JCC from " << hex << gen.currAddr() << " to " << targetAddr << dec << endl; if (!insnCodeGen::modifyJcc(targetAddr, *ugly_insn, gen)) { relocation_cerr << "modifyJcc failed, ret false" << endl; return false; } return true; } case CFPatch::Call: { // Special handling for function call replacement: // // Here we are certain that we are dealing with // an intra-module call. For PIE code, the global entry of // the callee will use R12 to set up R2. Since we do not // set R12 to be the global entry, we should use the local entry if (target->type() == TargetInt::BlockTarget) { Target<block_instance *> *t = static_cast<Target<block_instance *> *>(target); block_instance *tb = t->t(); func_instance *callee = tb->entryOfFunc(); if (callee->ifunc()->containsPowerPreamble() && callee->addr() == targetAddr) targetAddr += 8; } if (!insnCodeGen::modifyCall(targetAddr, *ugly_insn, gen)) { relocation_cerr << "modifyCall failed, ret false" << endl; return false; } return true; } case CFPatch::Data: { if (!insnCodeGen::modifyData(targetAddr, *ugly_insn, gen)) { relocation_cerr << "modifyData failed, ret false" << endl; return false; } return true; } } } else { switch(type) { case CFPatch::Jump: insnCodeGen::generateBranch(gen, gen.currAddr(), targetAddr); break; case CFPatch::Call: insnCodeGen::generateCall(gen, gen.currAddr(), targetAddr); break; default: assert(0); } } return true; }
int main(int argc, char **argv) { if (1) { // Test a tuple reduction on the gpu Func f; Var x, y; f(x, y) = Tuple(x + y, x - y); // Updates to a reduction are atomic. f(x, y) = Tuple(f(x, y)[1]*2, f(x, y)[0]*2); // now equals ((x - y)*2, (x + y)*2) Target target = get_jit_target_from_environment(); if (target.has_gpu_feature()) { f.gpu_tile(x, y, 16, 16, GPU_DEFAULT); f.update().gpu_tile(x, y, 16, 16, GPU_DEFAULT); } Realization result = f.realize(1024, 1024); Image<int> a = result[0], b = result[1]; for (int y = 0; y < a.height(); y++) { for (int x = 0; x < a.width(); x++) { int correct_a = (x - y)*2; int correct_b = (x + y)*2; if (a(x, y) != correct_a || b(x, y) != correct_b) { printf("result(%d, %d) = (%d, %d) instead of (%d, %d)\n", x, y, a(x, y), b(x, y), correct_a, correct_b); return -1; } } } } if (1) { // Now test one that alternates between cpu and gpu per update step Func f; Var x, y; f(x, y) = Tuple(x + y, x - y); for (size_t i = 0; i < 10; i++) { // Swap the tuple elements and increment both f(x, y) = Tuple(f(x, y)[1] + 1, f(x, y)[0] + 1); } // Schedule the pure step and the odd update steps on the gpu f.gpu_tile(x, y, 16, 16, GPU_DEFAULT); for (int i = 0; i < 10; i ++) { if (i & 1) { f.update(i).gpu_tile(x, y, 16, 16, GPU_DEFAULT); } else { f.update(i); } } Realization result = f.realize(1024, 1024); Image<int> a = result[0], b = result[1]; for (int y = 0; y < a.height(); y++) { for (int x = 0; x < a.width(); x++) { int correct_a = (x + y) + 10; int correct_b = (x - y) + 10; if (a(x, y) != correct_a || b(x, y) != correct_b) { printf("result(%d, %d) = (%d, %d) instead of (%d, %d)\n", x, y, a(x, y), b(x, y), correct_a, correct_b); return -1; } } } } if (1) { // Same as above, but switches which steps are gpu and cpu Func f; Var x, y; f(x, y) = Tuple(x + y, x - y); for (size_t i = 0; i < 10; i++) { // Swap the tuple elements and increment both f(x, y) = Tuple(f(x, y)[1] + 1, f(x, y)[0] + 1); } // Schedule the even update steps on the gpu for (int i = 0; i < 10; i ++) { if (i & 1) { f.update(i).gpu_tile(x, y, 16, 16, GPU_DEFAULT); } else { f.update(i); } } Realization result = f.realize(1024, 1024); Image<int> a = result[0], b = result[1]; for (int y = 0; y < a.height(); y++) { for (int x = 0; x < a.width(); x++) { int correct_a = (x + y) + 10; int correct_b = (x - y) + 10; if (a(x, y) != correct_a || b(x, y) != correct_b) { printf("result(%d, %d) = (%d, %d) instead of (%d, %d)\n", x, y, a(x, y), b(x, y), correct_a, correct_b); return -1; } } } } if (1) { // In this one, each step only uses one of the tuple elements // of the previous step, so only that buffer should get copied // back to host or copied to device. Func f; Var x, y; f(x, y) = Tuple(x + y - 1000, x - y + 1000); for (size_t i = 0; i < 10; i++) { f(x, y) = Tuple(f(x, y)[1] - 1, f(x, y)[1] + 1); } // Schedule the even update steps on the gpu for (int i = 0; i < 10; i++) { if (i & 1) { f.update(i); } else { f.update(i).gpu_tile(x, y, 16, 16, GPU_DEFAULT); } } Realization result = f.realize(1024, 1024); Image<int> a = result[0], b = result[1]; for (int y = 0; y < a.height(); y++) { for (int x = 0; x < a.width(); x++) { int correct_a = (x - y + 1000) + 8; int correct_b = (x - y + 1000) + 10; if (a(x, y) != correct_a || b(x, y) != correct_b) { printf("result(%d, %d) = (%d, %d) instead of (%d, %d)\n", x, y, a(x, y), b(x, y), correct_a, correct_b); return -1; } } } } return 0; }
//------------------------------------------------------------------ /// Install the utility function into a process /// /// @param[in] diagnostic_manager /// A diagnostic manager to report errors and warnings to. /// /// @param[in] exe_ctx /// The execution context to install the utility function to. /// /// @return /// True on success (no errors); false otherwise. //------------------------------------------------------------------ bool ClangUtilityFunction::Install(DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx) { if (m_jit_start_addr != LLDB_INVALID_ADDRESS) { diagnostic_manager.PutCString(eDiagnosticSeverityWarning, "already installed"); return false; } //////////////////////////////////// // Set up the target and compiler // Target *target = exe_ctx.GetTargetPtr(); if (!target) { diagnostic_manager.PutCString(eDiagnosticSeverityError, "invalid target"); return false; } Process *process = exe_ctx.GetProcessPtr(); if (!process) { diagnostic_manager.PutCString(eDiagnosticSeverityError, "invalid process"); return false; } ////////////////////////// // Parse the expression // bool keep_result_in_memory = false; ResetDeclMap(exe_ctx, keep_result_in_memory); if (!DeclMap()->WillParse(exe_ctx, NULL)) { diagnostic_manager.PutCString( eDiagnosticSeverityError, "current process state is unsuitable for expression parsing"); return false; } const bool generate_debug_info = true; ClangExpressionParser parser(exe_ctx.GetBestExecutionContextScope(), *this, generate_debug_info); unsigned num_errors = parser.Parse(diagnostic_manager); if (num_errors) { ResetDeclMap(); return false; } ////////////////////////////////// // JIT the output of the parser // bool can_interpret = false; // should stay that way Error jit_error = parser.PrepareForExecution( m_jit_start_addr, m_jit_end_addr, m_execution_unit_sp, exe_ctx, can_interpret, eExecutionPolicyAlways); if (m_jit_start_addr != LLDB_INVALID_ADDRESS) { m_jit_process_wp = process->shared_from_this(); if (parser.GetGenerateDebugInfo()) { lldb::ModuleSP jit_module_sp(m_execution_unit_sp->GetJITModule()); if (jit_module_sp) { ConstString const_func_name(FunctionName()); FileSpec jit_file; jit_file.GetFilename() = const_func_name; jit_module_sp->SetFileSpecAndObjectName(jit_file, ConstString()); m_jit_module_wp = jit_module_sp; target->GetImages().Append(jit_module_sp); } } } #if 0 // jingham: look here StreamFile logfile ("/tmp/exprs.txt", "a"); logfile.Printf ("0x%16.16" PRIx64 ": func = %s, source =\n%s\n", m_jit_start_addr, m_function_name.c_str(), m_function_text.c_str()); #endif DeclMap()->DidParse(); ResetDeclMap(); if (jit_error.Success()) { return true; } else { const char *error_cstr = jit_error.AsCString(); if (error_cstr && error_cstr[0]) { diagnostic_manager.Printf(eDiagnosticSeverityError, "%s", error_cstr); } else { diagnostic_manager.PutCString(eDiagnosticSeverityError, "expression can't be interpreted or run"); } return false; } }
bool close() { target.stop(); return true; }
int main(int argc, char **argv) { if (argc < 2) { printf("Usage: bilateral_grid <s_sigma>\n"); // printf("Spatial sigma is a compile-time parameter, please provide it as an argument.\n" // "(llvm's ptx backend doesn't handle integer mods by non-consts yet)\n"); return 0; } ImageParam input(Float(32), 2); Param<float> r_sigma("r_sigma"); int s_sigma = atoi(argv[1]); Var x("x"), y("y"), z("z"), c("c"); // Add a boundary condition Func clamped("clamped"); clamped(x, y) = input(clamp(x, 0, input.width()-1), clamp(y, 0, input.height()-1)); // Construct the bilateral grid RDom r(0, s_sigma, 0, s_sigma); Expr val = clamped(x * s_sigma + r.x - s_sigma/2, y * s_sigma + r.y - s_sigma/2); val = clamp(val, 0.0f, 1.0f); Expr zi = cast<int>(val * (1.0f/r_sigma) + 0.5f); Func histogram("histogram"); histogram(x, y, z, c) = 0.0f; histogram(x, y, zi, c) += select(c == 0, val, 1.0f); // Blur the grid using a five-tap filter Func blurx("blurx"), blury("blury"), blurz("blurz"); blurz(x, y, z, c) = (histogram(x, y, z-2, c) + histogram(x, y, z-1, c)*4 + histogram(x, y, z , c)*6 + histogram(x, y, z+1, c)*4 + histogram(x, y, z+2, c)); blurx(x, y, z, c) = (blurz(x-2, y, z, c) + blurz(x-1, y, z, c)*4 + blurz(x , y, z, c)*6 + blurz(x+1, y, z, c)*4 + blurz(x+2, y, z, c)); blury(x, y, z, c) = (blurx(x, y-2, z, c) + blurx(x, y-1, z, c)*4 + blurx(x, y , z, c)*6 + blurx(x, y+1, z, c)*4 + blurx(x, y+2, z, c)); // Take trilinear samples to compute the output val = clamp(input(x, y), 0.0f, 1.0f); Expr zv = val * (1.0f/r_sigma); zi = cast<int>(zv); Expr zf = zv - zi; Expr xf = cast<float>(x % s_sigma) / s_sigma; Expr yf = cast<float>(y % s_sigma) / s_sigma; Expr xi = x/s_sigma; Expr yi = y/s_sigma; Func interpolated("interpolated"); interpolated(x, y, c) = lerp(lerp(lerp(blury(xi, yi, zi, c), blury(xi+1, yi, zi, c), xf), lerp(blury(xi, yi+1, zi, c), blury(xi+1, yi+1, zi, c), xf), yf), lerp(lerp(blury(xi, yi, zi+1, c), blury(xi+1, yi, zi+1, c), xf), lerp(blury(xi, yi+1, zi+1, c), blury(xi+1, yi+1, zi+1, c), xf), yf), zf); // Normalize Func bilateral_grid("bilateral_grid"); bilateral_grid(x, y) = interpolated(x, y, 0)/interpolated(x, y, 1); Target target = get_target_from_environment(); if (target.has_gpu_feature()) { histogram.compute_root().reorder(c, z, x, y).gpu_tile(x, y, 8, 8); histogram.update().reorder(c, r.x, r.y, x, y).gpu_tile(x, y, 8, 8).unroll(c); blurx.compute_root().gpu_tile(x, y, z, 16, 16, 1); blury.compute_root().gpu_tile(x, y, z, 16, 16, 1); blurz.compute_root().gpu_tile(x, y, z, 8, 8, 4); bilateral_grid.compute_root().gpu_tile(x, y, s_sigma, s_sigma); } else { // CPU schedule histogram.compute_at(blurz, y); histogram.update().reorder(c, r.x, r.y, x, y).unroll(c); blurz.compute_root().reorder(c, z, x, y).parallel(y).vectorize(x, 4).unroll(c); blurx.compute_root().reorder(c, x, y, z).parallel(z).vectorize(x, 4).unroll(c); blury.compute_root().reorder(c, x, y, z).parallel(z).vectorize(x, 4).unroll(c); bilateral_grid.compute_root().parallel(y).vectorize(x, 4); } bilateral_grid.compile_to_file("bilateral_grid", r_sigma, input, target); return 0; }
ValueObjectSP ABISysV_ppc64::GetReturnValueObjectImpl( Thread &thread, CompilerType &return_compiler_type) const { ValueObjectSP return_valobj_sp; if (!return_compiler_type) return return_valobj_sp; ExecutionContext exe_ctx(thread.shared_from_this()); return_valobj_sp = GetReturnValueObjectSimple(thread, return_compiler_type); if (return_valobj_sp) return return_valobj_sp; RegisterContextSP reg_ctx_sp = thread.GetRegisterContext(); if (!reg_ctx_sp) return return_valobj_sp; const size_t bit_width = return_compiler_type.GetBitSize(&thread); if (return_compiler_type.IsAggregateType()) { Target *target = exe_ctx.GetTargetPtr(); bool is_memory = true; if (bit_width <= 128) { ByteOrder target_byte_order = target->GetArchitecture().GetByteOrder(); DataBufferSP data_sp(new DataBufferHeap(16, 0)); DataExtractor return_ext(data_sp, target_byte_order, target->GetArchitecture().GetAddressByteSize()); const RegisterInfo *r3_info = reg_ctx_sp->GetRegisterInfoByName("r3", 0); const RegisterInfo *rdx_info = reg_ctx_sp->GetRegisterInfoByName("rdx", 0); RegisterValue r3_value, rdx_value; reg_ctx_sp->ReadRegister(r3_info, r3_value); reg_ctx_sp->ReadRegister(rdx_info, rdx_value); DataExtractor r3_data, rdx_data; r3_value.GetData(r3_data); rdx_value.GetData(rdx_data); uint32_t fp_bytes = 0; // Tracks how much of the xmm registers we've consumed so far uint32_t integer_bytes = 0; // Tracks how much of the r3/rds registers we've consumed so far const uint32_t num_children = return_compiler_type.GetNumFields(); // Since we are in the small struct regime, assume we are not in memory. is_memory = false; for (uint32_t idx = 0; idx < num_children; idx++) { std::string name; uint64_t field_bit_offset = 0; bool is_signed; bool is_complex; uint32_t count; CompilerType field_compiler_type = return_compiler_type.GetFieldAtIndex( idx, name, &field_bit_offset, nullptr, nullptr); const size_t field_bit_width = field_compiler_type.GetBitSize(&thread); // If there are any unaligned fields, this is stored in memory. if (field_bit_offset % field_bit_width != 0) { is_memory = true; break; } uint32_t field_byte_width = field_bit_width / 8; uint32_t field_byte_offset = field_bit_offset / 8; DataExtractor *copy_from_extractor = nullptr; uint32_t copy_from_offset = 0; if (field_compiler_type.IsIntegerOrEnumerationType(is_signed) || field_compiler_type.IsPointerType()) { if (integer_bytes < 8) { if (integer_bytes + field_byte_width <= 8) { // This is in RAX, copy from register to our result structure: copy_from_extractor = &r3_data; copy_from_offset = integer_bytes; integer_bytes += field_byte_width; } else { // The next field wouldn't fit in the remaining space, so we // pushed it to rdx. copy_from_extractor = &rdx_data; copy_from_offset = 0; integer_bytes = 8 + field_byte_width; } } else if (integer_bytes + field_byte_width <= 16) { copy_from_extractor = &rdx_data; copy_from_offset = integer_bytes - 8; integer_bytes += field_byte_width; } else { // The last field didn't fit. I can't see how that would happen w/o // the overall size being // greater than 16 bytes. For now, return a nullptr return value // object. return return_valobj_sp; } } else if (field_compiler_type.IsFloatingPointType(count, is_complex)) { // Structs with long doubles are always passed in memory. if (field_bit_width == 128) { is_memory = true; break; } else if (field_bit_width == 64) { copy_from_offset = 0; fp_bytes += field_byte_width; } else if (field_bit_width == 32) { // This one is kind of complicated. If we are in an "eightbyte" // with another float, we'll // be stuffed into an xmm register with it. If we are in an // "eightbyte" with one or more ints, // then we will be stuffed into the appropriate GPR with them. bool in_gpr; if (field_byte_offset % 8 == 0) { // We are at the beginning of one of the eightbytes, so check the // next element (if any) if (idx == num_children - 1) in_gpr = false; else { uint64_t next_field_bit_offset = 0; CompilerType next_field_compiler_type = return_compiler_type.GetFieldAtIndex(idx + 1, name, &next_field_bit_offset, nullptr, nullptr); if (next_field_compiler_type.IsIntegerOrEnumerationType( is_signed)) in_gpr = true; else { copy_from_offset = 0; in_gpr = false; } } } else if (field_byte_offset % 4 == 0) { // We are inside of an eightbyte, so see if the field before us is // floating point: // This could happen if somebody put padding in the structure. if (idx == 0) in_gpr = false; else { uint64_t prev_field_bit_offset = 0; CompilerType prev_field_compiler_type = return_compiler_type.GetFieldAtIndex(idx - 1, name, &prev_field_bit_offset, nullptr, nullptr); if (prev_field_compiler_type.IsIntegerOrEnumerationType( is_signed)) in_gpr = true; else { copy_from_offset = 4; in_gpr = false; } } } else { is_memory = true; continue; } // Okay, we've figured out whether we are in GPR or XMM, now figure // out which one. if (in_gpr) { if (integer_bytes < 8) { // This is in RAX, copy from register to our result structure: copy_from_extractor = &r3_data; copy_from_offset = integer_bytes; integer_bytes += field_byte_width; } else { copy_from_extractor = &rdx_data; copy_from_offset = integer_bytes - 8; integer_bytes += field_byte_width; } } else { fp_bytes += field_byte_width; } } } // These two tests are just sanity checks. If I somehow get the // type calculation wrong above it is better to just return nothing // than to assert or crash. if (!copy_from_extractor) return return_valobj_sp; if (copy_from_offset + field_byte_width > copy_from_extractor->GetByteSize()) return return_valobj_sp; copy_from_extractor->CopyByteOrderedData( copy_from_offset, field_byte_width, data_sp->GetBytes() + field_byte_offset, field_byte_width, target_byte_order); } if (!is_memory) { // The result is in our data buffer. Let's make a variable object out // of it: return_valobj_sp = ValueObjectConstResult::Create( &thread, return_compiler_type, ConstString(""), return_ext); } } // FIXME: This is just taking a guess, r3 may very well no longer hold the // return storage location. // If we are going to do this right, when we make a new frame we should // check to see if it uses a memory // return, and if we are at the first instruction and if so stash away the // return location. Then we would // only return the memory return value if we know it is valid. if (is_memory) { unsigned r3_id = reg_ctx_sp->GetRegisterInfoByName("r3", 0)->kinds[eRegisterKindLLDB]; lldb::addr_t storage_addr = (uint64_t)thread.GetRegisterContext()->ReadRegisterAsUnsigned(r3_id, 0); return_valobj_sp = ValueObjectMemory::Create( &thread, "", Address(storage_addr, nullptr), return_compiler_type); } } return return_valobj_sp; }
void LaunchDaemon::_AddInitJob(BJob* job) { fInitTarget->AddDependency(job); fJobQueue.AddJob(job); }
bool AppleObjCRuntime::GetObjectDescription (Stream &strm, Value &value, ExecutionContextScope *exe_scope) { if (!m_read_objc_library) return false; ExecutionContext exe_ctx; exe_scope->CalculateExecutionContext(exe_ctx); Process *process = exe_ctx.GetProcessPtr(); if (!process) return false; // We need other parts of the exe_ctx, but the processes have to match. assert (m_process == process); // Get the function address for the print function. const Address *function_address = GetPrintForDebuggerAddr(); if (!function_address) return false; Target *target = exe_ctx.GetTargetPtr(); if (value.GetClangType()) { clang::QualType value_type = clang::QualType::getFromOpaquePtr (value.GetClangType()); if (!value_type->isObjCObjectPointerType()) { strm.Printf ("Value doesn't point to an ObjC object.\n"); return false; } } else { // If it is not a pointer, see if we can make it into a pointer. ClangASTContext *ast_context = target->GetScratchClangASTContext(); void *opaque_type_ptr = ast_context->GetBuiltInType_objc_id(); if (opaque_type_ptr == NULL) opaque_type_ptr = ast_context->GetVoidPtrType(false); value.SetContext(Value::eContextTypeClangType, opaque_type_ptr); } ValueList arg_value_list; arg_value_list.PushValue(value); // This is the return value: ClangASTContext *ast_context = target->GetScratchClangASTContext(); void *return_qualtype = ast_context->GetCStringType(true); Value ret; ret.SetContext(Value::eContextTypeClangType, return_qualtype); // Now we're ready to call the function: ClangFunction func (*exe_ctx.GetBestExecutionContextScope(), ast_context, return_qualtype, *function_address, arg_value_list); StreamString error_stream; lldb::addr_t wrapper_struct_addr = LLDB_INVALID_ADDRESS; func.InsertFunction(exe_ctx, wrapper_struct_addr, error_stream); bool unwind_on_error = true; bool try_all_threads = true; bool stop_others = true; ExecutionResults results = func.ExecuteFunction (exe_ctx, &wrapper_struct_addr, error_stream, stop_others, 1000000, try_all_threads, unwind_on_error, ret); if (results != eExecutionCompleted) { strm.Printf("Error evaluating Print Object function: %d.\n", results); return false; } addr_t result_ptr = ret.GetScalar().ULongLong(LLDB_INVALID_ADDRESS); char buf[512]; size_t cstr_len = 0; size_t full_buffer_len = sizeof (buf) - 1; size_t curr_len = full_buffer_len; while (curr_len == full_buffer_len) { Error error; curr_len = process->ReadCStringFromMemory(result_ptr + cstr_len, buf, sizeof(buf), error); strm.Write (buf, curr_len); cstr_len += curr_len; } return cstr_len > 0; }
Target *createTargetByString (std::string tar_string, bool debug) { Target *rtar = NULL; LibnovaRaDec raDec; int ret = raDec.parseString (tar_string.c_str ()); if (ret == 0) { std::string new_prefix; // default prefix for new RTS2 sources new_prefix = std::string ("RTS2_"); // set name.. ConstTarget *constTarget = new ConstTarget (); constTarget->setPosition (raDec.getRa (), raDec.getDec ()); std::ostringstream os; rts2core::Configuration::instance ()->getString ("newtarget", "prefix", new_prefix, "RTS2"); os << new_prefix << LibnovaRaComp (raDec.getRa ()) << LibnovaDeg90Comp (raDec.getDec ()); constTarget->setTargetName (os.str ().c_str ()); constTarget->setTargetType (TYPE_OPORTUNITY); return constTarget; } // if it's MPC ephemeris.. rtar = new EllTarget (); ret = ((EllTarget *) rtar)->orbitFromMPC (tar_string.c_str ()); if (ret == 0) return rtar; delete rtar; try { rtar = new TLETarget (); ((TLETarget *) rtar)->orbitFromTLE (tar_string); return rtar; } catch (rts2core::Error &er) { } delete rtar; XmlRpcLogHandler::setVerbosity (debug ? 5 : 0); // try to get target from SIMBAD try { rtar = new rts2db::SimbadTargetDb (tar_string.c_str ()); rtar->load (); rtar->setTargetType (TYPE_OPORTUNITY); return rtar; } catch (rts2core::Error &er) { delete rtar; // MPEC fallback rtar = new rts2db::MPECTarget (tar_string.c_str ()); rtar->load (); return rtar; } }
void reinforce( const Target& obj ) const { obj.reinforce( *this ); }
bool CommandObjectDisassemble::DoExecute (Args& command, CommandReturnObject &result) { Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get(); if (target == NULL) { result.AppendError ("invalid target, create a debug target using the 'target create' command"); result.SetStatus (eReturnStatusFailed); return false; } if (!m_options.arch.IsValid()) m_options.arch = target->GetArchitecture(); if (!m_options.arch.IsValid()) { result.AppendError ("use the --arch option or set the target architecure to disassemble"); result.SetStatus (eReturnStatusFailed); return false; } const char *plugin_name = m_options.GetPluginName (); const char *flavor_string = m_options.GetFlavorString(); DisassemblerSP disassembler = Disassembler::FindPlugin(m_options.arch, flavor_string, plugin_name); if (!disassembler) { if (plugin_name) { result.AppendErrorWithFormat ("Unable to find Disassembler plug-in named '%s' that supports the '%s' architecture.\n", plugin_name, m_options.arch.GetArchitectureName()); } else result.AppendErrorWithFormat ("Unable to find Disassembler plug-in for the '%s' architecture.\n", m_options.arch.GetArchitectureName()); result.SetStatus (eReturnStatusFailed); return false; } else if (flavor_string != NULL && !disassembler->FlavorValidForArchSpec(m_options.arch, flavor_string)) result.AppendWarningWithFormat("invalid disassembler flavor \"%s\", using default.\n", flavor_string); result.SetStatus (eReturnStatusSuccessFinishResult); if (command.GetArgumentCount() != 0) { result.AppendErrorWithFormat ("\"disassemble\" arguments are specified as options.\n"); GetOptions()->GenerateOptionUsage (result.GetErrorStream(), this); result.SetStatus (eReturnStatusFailed); return false; } if (m_options.show_mixed && m_options.num_lines_context == 0) m_options.num_lines_context = 1; // Always show the PC in the disassembly uint32_t options = Disassembler::eOptionMarkPCAddress; // Mark the source line for the current PC only if we are doing mixed source and assembly if (m_options.show_mixed) options |= Disassembler::eOptionMarkPCSourceLine; if (m_options.show_bytes) options |= Disassembler::eOptionShowBytes; if (m_options.raw) options |= Disassembler::eOptionRawOuput; if (!m_options.func_name.empty()) { ConstString name(m_options.func_name.c_str()); if (Disassembler::Disassemble (m_interpreter.GetDebugger(), m_options.arch, plugin_name, flavor_string, m_exe_ctx, name, NULL, // Module * m_options.num_instructions, m_options.show_mixed ? m_options.num_lines_context : 0, options, result.GetOutputStream())) { result.SetStatus (eReturnStatusSuccessFinishResult); } else { result.AppendErrorWithFormat ("Unable to find symbol with name '%s'.\n", name.GetCString()); result.SetStatus (eReturnStatusFailed); } } else { std::vector<AddressRange> ranges; AddressRange range; StackFrame *frame = m_exe_ctx.GetFramePtr(); if (m_options.frame_line) { if (frame == NULL) { result.AppendError ("Cannot disassemble around the current line without a selected frame.\n"); result.SetStatus (eReturnStatusFailed); return false; } LineEntry pc_line_entry (frame->GetSymbolContext(eSymbolContextLineEntry).line_entry); if (pc_line_entry.IsValid()) { range = pc_line_entry.range; } else { m_options.at_pc = true; // No line entry, so just disassemble around the current pc m_options.show_mixed = false; } } else if (m_options.current_function) { if (frame == NULL) { result.AppendError ("Cannot disassemble around the current function without a selected frame.\n"); result.SetStatus (eReturnStatusFailed); return false; } Symbol *symbol = frame->GetSymbolContext(eSymbolContextSymbol).symbol; if (symbol) { range.GetBaseAddress() = symbol->GetAddress(); range.SetByteSize(symbol->GetByteSize()); } } // Did the "m_options.frame_line" find a valid range already? If so // skip the rest... if (range.GetByteSize() == 0) { if (m_options.at_pc) { if (frame == NULL) { result.AppendError ("Cannot disassemble around the current PC without a selected frame.\n"); result.SetStatus (eReturnStatusFailed); return false; } range.GetBaseAddress() = frame->GetFrameCodeAddress(); if (m_options.num_instructions == 0) { // Disassembling at the PC always disassembles some number of instructions (not the whole function). m_options.num_instructions = DEFAULT_DISASM_NUM_INS; } ranges.push_back(range); } else { range.GetBaseAddress().SetOffset (m_options.start_addr); if (range.GetBaseAddress().IsValid()) { if (m_options.end_addr != LLDB_INVALID_ADDRESS) { if (m_options.end_addr <= m_options.start_addr) { result.AppendErrorWithFormat ("End address before start address.\n"); result.SetStatus (eReturnStatusFailed); return false; } range.SetByteSize (m_options.end_addr - m_options.start_addr); } ranges.push_back(range); } else { if (m_options.symbol_containing_addr != LLDB_INVALID_ADDRESS && target) { if (!target->GetSectionLoadList().IsEmpty()) { bool failed = false; Address symbol_containing_address; if (target->GetSectionLoadList().ResolveLoadAddress (m_options.symbol_containing_addr, symbol_containing_address)) { ModuleSP module_sp (symbol_containing_address.GetModule()); SymbolContext sc; bool resolve_tail_call_address = true; // PC can be one past the address range of the function. module_sp->ResolveSymbolContextForAddress (symbol_containing_address, eSymbolContextEverything, sc, resolve_tail_call_address); if (sc.function || sc.symbol) { sc.GetAddressRange (eSymbolContextFunction | eSymbolContextSymbol, 0, false, range); } else { failed = true; } } else { failed = true; } if (failed) { result.AppendErrorWithFormat ("Could not find function bounds for address 0x%" PRIx64 "\n", m_options.symbol_containing_addr); result.SetStatus (eReturnStatusFailed); return false; } ranges.push_back(range); } else { for (lldb::ModuleSP module_sp : target->GetImages().Modules()) { lldb::addr_t file_addr = m_options.symbol_containing_addr; Address file_address; if (module_sp->ResolveFileAddress(file_addr, file_address)) { SymbolContext sc; bool resolve_tail_call_address = true; // PC can be one past the address range of the function. module_sp->ResolveSymbolContextForAddress (file_address, eSymbolContextEverything, sc, resolve_tail_call_address); if (sc.function || sc.symbol) { sc.GetAddressRange (eSymbolContextFunction | eSymbolContextSymbol, 0, false, range); ranges.push_back(range); } } } } } } } } else ranges.push_back(range); if (m_options.num_instructions != 0) { if (ranges.size() == 0) { // The default action is to disassemble the current frame function. if (frame) { SymbolContext sc(frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextSymbol)); if (sc.function) range.GetBaseAddress() = sc.function->GetAddressRange().GetBaseAddress(); else if (sc.symbol && sc.symbol->ValueIsAddress()) range.GetBaseAddress() = sc.symbol->GetAddress(); else range.GetBaseAddress() = frame->GetFrameCodeAddress(); } if (!range.GetBaseAddress().IsValid()) { result.AppendError ("invalid frame"); result.SetStatus (eReturnStatusFailed); return false; } } bool print_sc_header = ranges.size() > 1; for (AddressRange cur_range : ranges) { if (Disassembler::Disassemble (m_interpreter.GetDebugger(), m_options.arch, plugin_name, flavor_string, m_exe_ctx, cur_range.GetBaseAddress(), m_options.num_instructions, m_options.show_mixed ? m_options.num_lines_context : 0, options, result.GetOutputStream())) { result.SetStatus (eReturnStatusSuccessFinishResult); } else { if (m_options.start_addr != LLDB_INVALID_ADDRESS) result.AppendErrorWithFormat ("Failed to disassemble memory at 0x%8.8" PRIx64 ".\n", m_options.start_addr); else if (m_options.symbol_containing_addr != LLDB_INVALID_ADDRESS) result.AppendErrorWithFormat ("Failed to disassemble memory in function at 0x%8.8" PRIx64 ".\n", m_options.symbol_containing_addr); result.SetStatus (eReturnStatusFailed); } } if (print_sc_header) result.AppendMessage("\n"); } else { if (ranges.size() == 0) { // The default action is to disassemble the current frame function. if (frame) { SymbolContext sc(frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextSymbol)); if (sc.function) range = sc.function->GetAddressRange(); else if (sc.symbol && sc.symbol->ValueIsAddress()) { range.GetBaseAddress() = sc.symbol->GetAddress(); range.SetByteSize (sc.symbol->GetByteSize()); } else range.GetBaseAddress() = frame->GetFrameCodeAddress(); } else { result.AppendError ("invalid frame"); result.SetStatus (eReturnStatusFailed); return false; } ranges.push_back(range); } bool print_sc_header = ranges.size() > 1; for (AddressRange cur_range : ranges) { if (cur_range.GetByteSize() == 0) cur_range.SetByteSize(DEFAULT_DISASM_BYTE_SIZE); if (Disassembler::Disassemble (m_interpreter.GetDebugger(), m_options.arch, plugin_name, flavor_string, m_exe_ctx, cur_range, m_options.num_instructions, m_options.show_mixed ? m_options.num_lines_context : 0, options, result.GetOutputStream())) { result.SetStatus (eReturnStatusSuccessFinishResult); } else { result.AppendErrorWithFormat ("Failed to disassemble memory at 0x%8.8" PRIx64 ".\n", m_options.start_addr); result.SetStatus (eReturnStatusFailed); } if (print_sc_header) result.AppendMessage("\n"); } } } return result.Succeeded(); }
bool CommandObjectDisassemble::Execute ( CommandInterpreter &interpreter, Args& command, CommandReturnObject &result ) { Target *target = interpreter.GetDebugger().GetCurrentTarget().get(); if (target == NULL) { result.AppendError ("invalid target, set executable file using 'file' command"); result.SetStatus (eReturnStatusFailed); return false; } ArchSpec arch(target->GetArchitecture()); if (!arch.IsValid()) { result.AppendError ("target needs valid architecure in order to be able to disassemble"); result.SetStatus (eReturnStatusFailed); return false; } Disassembler *disassembler = Disassembler::FindPlugin(arch); if (disassembler == NULL) { result.AppendErrorWithFormat ("Unable to find Disassembler plug-in for %s architecture.\n", arch.AsCString()); result.SetStatus (eReturnStatusFailed); return false; } result.SetStatus (eReturnStatusSuccessFinishResult); if (command.GetArgumentCount() != 0) { result.AppendErrorWithFormat ("\"disassemble\" doesn't take any arguments.\n"); result.SetStatus (eReturnStatusFailed); return false; } ExecutionContext exe_ctx(interpreter.GetDebugger().GetExecutionContext()); if (m_options.show_mixed && m_options.num_lines_context == 0) m_options.num_lines_context = 3; if (!m_options.m_func_name.empty()) { ConstString name(m_options.m_func_name.c_str()); if (Disassembler::Disassemble (interpreter.GetDebugger(), arch, exe_ctx, name, NULL, // Module * m_options.show_mixed ? m_options.num_lines_context : 0, m_options.show_bytes, result.GetOutputStream())) { result.SetStatus (eReturnStatusSuccessFinishResult); } else { result.AppendErrorWithFormat ("Unable to find symbol with name '%s'.\n", name.GetCString()); result.SetStatus (eReturnStatusFailed); } } else { AddressRange range; if (m_options.m_start_addr != LLDB_INVALID_ADDRESS) { range.GetBaseAddress().SetOffset (m_options.m_start_addr); if (m_options.m_end_addr != LLDB_INVALID_ADDRESS) { if (m_options.m_end_addr < m_options.m_start_addr) { result.AppendErrorWithFormat ("End address before start address.\n"); result.SetStatus (eReturnStatusFailed); return false; } range.SetByteSize (m_options.m_end_addr - m_options.m_start_addr); } else range.SetByteSize (DEFAULT_DISASM_BYTE_SIZE); } else { if (exe_ctx.frame) { SymbolContext sc(exe_ctx.frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextSymbol)); if (sc.function) range = sc.function->GetAddressRange(); else if (sc.symbol && sc.symbol->GetAddressRangePtr()) range = *sc.symbol->GetAddressRangePtr(); else range.GetBaseAddress() = exe_ctx.frame->GetPC(); } else { result.AppendError ("invalid frame"); result.SetStatus (eReturnStatusFailed); return false; } } if (range.GetByteSize() == 0) range.SetByteSize(DEFAULT_DISASM_BYTE_SIZE); if (Disassembler::Disassemble (interpreter.GetDebugger(), arch, exe_ctx, range, m_options.show_mixed ? m_options.num_lines_context : 0, m_options.show_bytes, result.GetOutputStream())) { result.SetStatus (eReturnStatusSuccessFinishResult); } else { result.AppendErrorWithFormat ("Failed to disassemble memory at 0x%8.8llx.\n", m_options.m_start_addr); result.SetStatus (eReturnStatusFailed); } } return result.Succeeded(); }
Error CommandObjectDisassemble::CommandOptions::SetOptionValue (uint32_t option_idx, const char *option_arg) { Error error; const int short_option = m_getopt_table[option_idx].val; bool success; switch (short_option) { case 'm': show_mixed = true; break; case 'C': num_lines_context = StringConvert::ToUInt32(option_arg, 0, 0, &success); if (!success) error.SetErrorStringWithFormat ("invalid num context lines string: \"%s\"", option_arg); break; case 'c': num_instructions = StringConvert::ToUInt32(option_arg, 0, 0, &success); if (!success) error.SetErrorStringWithFormat ("invalid num of instructions string: \"%s\"", option_arg); break; case 'b': show_bytes = true; break; case 's': { ExecutionContext exe_ctx (m_interpreter.GetExecutionContext()); start_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error); if (start_addr != LLDB_INVALID_ADDRESS) some_location_specified = true; } break; case 'e': { ExecutionContext exe_ctx (m_interpreter.GetExecutionContext()); end_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error); if (end_addr != LLDB_INVALID_ADDRESS) some_location_specified = true; } break; case 'n': func_name.assign (option_arg); some_location_specified = true; break; case 'p': at_pc = true; some_location_specified = true; break; case 'l': frame_line = true; // Disassemble the current source line kind of implies showing mixed // source code context. show_mixed = true; some_location_specified = true; break; case 'P': plugin_name.assign (option_arg); break; case 'F': { Target *target = m_interpreter.GetExecutionContext().GetTargetPtr(); if (target->GetArchitecture().GetTriple().getArch() == llvm::Triple::x86 || target->GetArchitecture().GetTriple().getArch() == llvm::Triple::x86_64) { flavor_string.assign (option_arg); } else error.SetErrorStringWithFormat("Disassembler flavors are currently only supported for x86 and x86_64 targets."); break; } case 'r': raw = true; break; case 'f': current_function = true; some_location_specified = true; break; case 'A': if (!arch.SetTriple (option_arg, m_interpreter.GetPlatform (true).get())) arch.SetTriple (option_arg); break; case 'a': { ExecutionContext exe_ctx (m_interpreter.GetExecutionContext()); symbol_containing_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error); if (symbol_containing_addr != LLDB_INVALID_ADDRESS) { some_location_specified = true; } } break; default: error.SetErrorStringWithFormat("unrecognized short option '%c'", short_option); break; } return error; }
void MoonEGLContext::Project (MoonSurface *src, const double *matrix, double alpha, double x, double y) { MoonEGLSurface *surface = (MoonEGLSurface *) src; Target *target = Top ()->GetTarget (); Rect r = target->GetData (NULL); Rect clip = GetClip (); double m[16]; if (!target->GetInit () && !IS_TRANSLUCENT (alpha) && r == clip) { int x0, y0; GetMatrix (m); if (matrix) Matrix3D::Multiply (m, matrix, m); if (Matrix3D::IsIntegerTranslation (m, &x0, &y0)) { MoonEGLSurface *surface = (MoonEGLSurface *) src; Rect r = Rect (x + x0, y + y0, surface->Width (), surface->Height ()); // matching dimensions and no transformation allow us // to set source as initial state of target surface when // it is not already initialized. if (r == clip) { target->SetInit (src); return; } } } if (!HasDrawable () && !surface->HasTexture ()) { int x0, y0; GetMatrix (m); if (matrix) Matrix3D::Multiply (m, matrix, m); // avoid GL rendering to target without previously // allocated hardware drawable if (Matrix3D::IsIntegerTranslation (m, &x0, &y0)) { cairo_matrix_t m; cairo_matrix_init_translate (&m, x0, y0); Context::Push (Context::AbsoluteTransform (m)); Context::Paint (src, alpha, x, y); Context::Pop (); return; } } GetDeviceMatrix (m); if (matrix) Matrix3D::Multiply (m, matrix, m); ForceCurrent (); GLContext::Paint (src, m, alpha, x, y); }
/// Locates the address of the rendezvous structure. Returns the address on /// success and LLDB_INVALID_ADDRESS on failure. static addr_t ResolveRendezvousAddress(Process *process) { Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER)); addr_t info_location; addr_t info_addr; Error error; if (!process) { if (log) log->Printf ("%s null process provided", __FUNCTION__); return LLDB_INVALID_ADDRESS; } // Try to get it from our process. This might be a remote process and might // grab it via some remote-specific mechanism. info_location = process->GetImageInfoAddress(); if (log) log->Printf ("%s info_location = 0x%" PRIx64, __FUNCTION__, info_location); // If the process fails to return an address, fall back to seeing if the local object file can help us find it. if (info_location == LLDB_INVALID_ADDRESS) { Target *target = &process->GetTarget(); if (target) { ObjectFile *obj_file = target->GetExecutableModule()->GetObjectFile(); Address addr = obj_file->GetImageInfoAddress(target); if (addr.IsValid()) { info_location = addr.GetLoadAddress(target); if (log) log->Printf ("%s resolved via direct object file approach to 0x%" PRIx64, __FUNCTION__, info_location); } else { if (log) log->Printf ("%s FAILED - direct object file approach did not yield a valid address", __FUNCTION__); } } } if (info_location == LLDB_INVALID_ADDRESS) { if (log) log->Printf ("%s FAILED - invalid info address", __FUNCTION__); return LLDB_INVALID_ADDRESS; } if (log) log->Printf ("%s reading pointer (%" PRIu32 " bytes) from 0x%" PRIx64, __FUNCTION__, process->GetAddressByteSize(), info_location); info_addr = process->ReadPointerFromMemory(info_location, error); if (error.Fail()) { if (log) log->Printf ("%s FAILED - could not read from the info location: %s", __FUNCTION__, error.AsCString ()); return LLDB_INVALID_ADDRESS; } if (info_addr == 0) { if (log) log->Printf ("%s FAILED - the rendezvous address contained at 0x%" PRIx64 " returned a null value", __FUNCTION__, info_location); return LLDB_INVALID_ADDRESS; } return info_addr; }
Func demosaic(Func deinterleaved) { // These are the values we already know from the input // x_y = the value of channel x at a site in the input of channel y // gb refers to green sites in the blue rows // gr refers to green sites in the red rows // Give more convenient names to the four channels we know Func r_r, g_gr, g_gb, b_b; g_gr(x, y) = deinterleaved(x, y, 0); r_r(x, y) = deinterleaved(x, y, 1); b_b(x, y) = deinterleaved(x, y, 2); g_gb(x, y) = deinterleaved(x, y, 3); // These are the ones we need to interpolate Func b_r, g_r, b_gr, r_gr, b_gb, r_gb, r_b, g_b; // First calculate green at the red and blue sites // Try interpolating vertically and horizontally. Also compute // differences vertically and horizontally. Use interpolation in // whichever direction had the smallest difference. Expr gv_r = avg(g_gb(x, y-1), g_gb(x, y)); Expr gvd_r = absd(g_gb(x, y-1), g_gb(x, y)); Expr gh_r = avg(g_gr(x+1, y), g_gr(x, y)); Expr ghd_r = absd(g_gr(x+1, y), g_gr(x, y)); g_r(x, y) = select(ghd_r < gvd_r, gh_r, gv_r); Expr gv_b = avg(g_gr(x, y+1), g_gr(x, y)); Expr gvd_b = absd(g_gr(x, y+1), g_gr(x, y)); Expr gh_b = avg(g_gb(x-1, y), g_gb(x, y)); Expr ghd_b = absd(g_gb(x-1, y), g_gb(x, y)); g_b(x, y) = select(ghd_b < gvd_b, gh_b, gv_b); // Next interpolate red at gr by first interpolating, then // correcting using the error green would have had if we had // interpolated it in the same way (i.e. add the second derivative // of the green channel at the same place). Expr correction; correction = g_gr(x, y) - avg(g_r(x, y), g_r(x-1, y)); r_gr(x, y) = correction + avg(r_r(x-1, y), r_r(x, y)); // Do the same for other reds and blues at green sites correction = g_gr(x, y) - avg(g_b(x, y), g_b(x, y-1)); b_gr(x, y) = correction + avg(b_b(x, y), b_b(x, y-1)); correction = g_gb(x, y) - avg(g_r(x, y), g_r(x, y+1)); r_gb(x, y) = correction + avg(r_r(x, y), r_r(x, y+1)); correction = g_gb(x, y) - avg(g_b(x, y), g_b(x+1, y)); b_gb(x, y) = correction + avg(b_b(x, y), b_b(x+1, y)); // Now interpolate diagonally to get red at blue and blue at // red. Hold onto your hats; this gets really fancy. We do the // same thing as for interpolating green where we try both // directions (in this case the positive and negative diagonals), // and use the one with the lowest absolute difference. But we // also use the same trick as interpolating red and blue at green // sites - we correct our interpolations using the second // derivative of green at the same sites. correction = g_b(x, y) - avg(g_r(x, y), g_r(x-1, y+1)); Expr rp_b = correction + avg(r_r(x, y), r_r(x-1, y+1)); Expr rpd_b = absd(r_r(x, y), r_r(x-1, y+1)); correction = g_b(x, y) - avg(g_r(x-1, y), g_r(x, y+1)); Expr rn_b = correction + avg(r_r(x-1, y), r_r(x, y+1)); Expr rnd_b = absd(r_r(x-1, y), r_r(x, y+1)); r_b(x, y) = select(rpd_b < rnd_b, rp_b, rn_b); // Same thing for blue at red correction = g_r(x, y) - avg(g_b(x, y), g_b(x+1, y-1)); Expr bp_r = correction + avg(b_b(x, y), b_b(x+1, y-1)); Expr bpd_r = absd(b_b(x, y), b_b(x+1, y-1)); correction = g_r(x, y) - avg(g_b(x+1, y), g_b(x, y-1)); Expr bn_r = correction + avg(b_b(x+1, y), b_b(x, y-1)); Expr bnd_r = absd(b_b(x+1, y), b_b(x, y-1)); b_r(x, y) = select(bpd_r < bnd_r, bp_r, bn_r); // Interleave the resulting channels Func r = interleave_y(interleave_x(r_gr, r_r), interleave_x(r_b, r_gb)); Func g = interleave_y(interleave_x(g_gr, g_r), interleave_x(g_b, g_gb)); Func b = interleave_y(interleave_x(b_gr, b_r), interleave_x(b_b, b_gb)); Func output; output(x, y, c) = select(c == 0, r(x, y), c == 1, g(x, y), b(x, y)); /* THE SCHEDULE */ int vec = target.natural_vector_size(UInt(16)); if (target.has_feature(Target::HVX_64)) { vec = 32; } else if (target.has_feature(Target::HVX_128)) { vec = 64; } g_r.compute_at(processed, yi) .store_at(processed, yo) .vectorize(x, vec, TailStrategy::RoundUp) .fold_storage(y, 2); g_b.compute_at(processed, yi) .store_at(processed, yo) .vectorize(x, vec, TailStrategy::RoundUp) .fold_storage(y, 2); output.compute_at(processed, x) .vectorize(x) .unroll(y) .reorder(c, x, y) .unroll(c); if (target.features_any_of({Target::HVX_64, Target::HVX_128})) { g_r.align_storage(x, vec); g_b.align_storage(x, vec); } return output; }
void Target::checkState() { if (_state == INITIALIZED) { _state = CHECKING_STATE; // Check output files bool needsRebuild = false; bool needsRebuildDeps = false; File * oldestOutput = NULL; for (FileList::const_iterator it = _outputs.begin(), itEnd = _outputs.end(); it != itEnd; ++it) { File * f = *it; if (!f->statusChecked()) { //console::out() << " Checking status of " << f->name() << "\n"; if (!f->updateFileStatus()) { continue; } } if (f->statusValid()) { if (!f->exists()) { if (!needsRebuild) { if (VERBOSE) { console::out() << " Output " << f << " is missing.\n"; } } needsRebuild = true; break; } else if (oldestOutput == NULL || f->lastModified() < oldestOutput->lastModified()) { oldestOutput = f; } } } if (_outputs.empty()) { needsRebuild = true; } // Check source files. Don't bother checking source file timestamps if we know we need // a rebuild, or if there are no declared outputs. for (FileList::const_iterator it = _sources.begin(), itEnd = _sources.end(); it != itEnd; ++it) { File * f = *it; if (!f->statusChecked()) { //console::out() << " Checking status of " << f->name() << "\n"; if (!f->updateFileStatus()) { continue; } } if (f->statusValid()) { // If this file is the output of another target, then unless that target is up // to date, then it doesn't matter what the timestamp of the output is in. if (!f->exists()) { needsRebuild = true; } if (!f->outputOf().empty() && !isSourceOnly()) { for (TargetList::const_iterator ti = f->outputOf().begin(), tiEnd = f->outputOf().end(); ti != tiEnd; ++ti) { Target * dep = *ti; if (dep->state() == CHECKING_STATE) { diag::error(this->location()) << "Circular dependency between target: " << this; diag::info(dep->location()) << "and target: " << dep; continue; } dep->checkState(); if (dep->state() == READY || dep->state() == WAITING || dep->state() == BUILDING) { needsRebuild = true; needsRebuildDeps = true; } // TODO: Do we want to add to implicit deps? } } else if (!f->exists()) { diag::error(this->location()) << "Target " << this << " depends on non-existent file " << f->name(); break; } else if (oldestOutput != NULL && oldestOutput->lastModified() < f->lastModified()) { if (!needsRebuild) { if (VERBOSE) { console::out() << " Output " << oldestOutput << " is older than source " << f << ".\n"; } } needsRebuild = true; } } } for (TargetList::const_iterator ti = _depends.begin(), tiEnd = _depends.end(); ti != tiEnd; ++ti) { Target * dep = *ti; if (dep->state() == CHECKING_STATE) { diag::error(this->location()) << "Circular dependency between target: " << this; diag::info(dep->location()) << "and target: " << dep; continue; } dep->checkState(); if (dep->state() == READY || dep->state() == WAITING || dep->state() == BUILDING) { needsRebuild = true; needsRebuildDeps = true; } } if (needsRebuild) { if (needsRebuildDeps) { _state = WAITING; if (VERBOSE) { console::out() << "Target " << this << " is waiting on other targets\n"; } } else { _state = READY; if (VERBOSE) { console::out() << "Target " << this << " is ready to build\n"; } } } else { _state = FINISHED; if (VERBOSE) { console::out() << "Target " << this << " is up to date\n"; console::out() << "Target has " << _depends.size() << " dependencies, and " << _dependents.size() << " dependents.\n"; } } } else { //console::out() << "Target " << this << " is in a weird state: " << _state << ".\n"; } }
bool CardSelector::CheckUserInput(JButton key) { if (!active) { for (vector<Target*>::iterator it = cards.begin(); it != cards.end(); ++it) if ((NULL == limitor) || (limitor->select(*it))) { active = *it; active->Entering(); return true; } return true; } Target* oldactive = active; timer = 800; int x,y; JGE* jge = observer->getInput(); if(!jge) return false; if(jge->GetLeftClickCoordinates(x, y)) { active = closest<CardSelectorTrue> (cards, limitor, static_cast<float> (x), static_cast<float> (y)); } switch (key) { case JGE_BTN_SEC: observer->cancelCurrentAction(); goto switch_active; break; case JGE_BTN_OK: observer->ButtonPressed(active); goto switch_active; break; case JGE_BTN_LEFT: active = closest<CardSelectorLeft> (cards, limitor, active); break; case JGE_BTN_RIGHT: active = closest<CardSelectorRight> (cards, limitor, active); break; case JGE_BTN_UP: active = closest<CardSelectorUp> (cards, limitor, active); break; case JGE_BTN_DOWN: active = closest<CardSelectorDown> (cards, limitor, active); break; case JGE_BTN_CANCEL: mDrawMode = (mDrawMode + 1) % DrawMode::kNumDrawModes; if (mDrawMode == DrawMode::kText) options[Options::DISABLECARDS].number = 1; else options[Options::DISABLECARDS].number = 0; return true; default: { if(!jge->GetLeftClickCoordinates(x, y)) { return false; } } } if(key != JGE_BTN_NONE) { if (active != oldactive) { CardView::SelectorZone oldowner, owner; if (CardView *q = dynamic_cast<CardView*>(oldactive)) oldowner = q->owner; else oldowner = CardView::nullZone; if (CardView *q = dynamic_cast<CardView*>(active)) owner = q->owner; else owner = CardView::nullZone; if (oldowner != owner) { if (CardView::nullZone != owner) { if (PlayGuiObject* old = fetchMemory(lasts[owner])) switch (key) { case JGE_BTN_LEFT: if (old->x < oldactive->x) active = old; break; case JGE_BTN_RIGHT: if (old->x > oldactive->x) active = old; break; case JGE_BTN_UP: if (old->y < oldactive->y) active = old; break; case JGE_BTN_DOWN: if (old->y > oldactive->y) active = old; break; default: if (old) active = old; break; } } lasts[oldowner] = SelectorMemory(oldactive); } } else { // active card hasn't changed - that means we're probably at an edge of the battlefield. // check if we're not already a selected avatar - if not, select one depending whether we're going up/down. GuiAvatar* avatar = dynamic_cast<GuiAvatar*> (active); if (!avatar) { if (key == JGE_BTN_DOWN) { active = duel->GetAvatars()->GetSelf(); } else if (key == JGE_BTN_UP) { active = duel->GetAvatars()->GetOpponent(); } } } } switch_active: if (active != oldactive) { { PlayGuiObject* c = dynamic_cast<PlayGuiObject*> (oldactive); if (c) c->zoom = 1.0f; } { PlayGuiObject* c = dynamic_cast<PlayGuiObject*> (active); if (c) c->zoom = 1.4f; } if (oldactive) oldactive->Leaving(JGE_BTN_NONE); if (active) active->Entering(); } else { timer = 800; } return true; }
// // Performing accesses based on specifications to targets. // The following function initiates I/O, recording performance information only when the // grunt is in the TestRecording state. The function needs to be as efficient as possible // while still being readable and maintainable. // // "data" is the location of data to use for transfers. // void Grunt::Do_IOs() { //////////////////////////////////////////////////////////////////////////// // these are working variables for the IO loop - they aren't referenced // outside of it and their values don't span more than one burst of data. // int remaining_transactions_in_burst=0; // how's that for a name? int access_percent = 0; // Determines the access spec. int target_id; // Index into target array of target to access. DWORD size; // Size of transfer request to target. int transfer_delay; // Milliseconds to wait before accessing. ReturnVal transfer_result; // Success/failure result of read or write operation. Transaction* transaction = NULL; // Pointer to the transaction being processed. DWORD user_alignment; DWORDLONG user_align_mask; DWORD reply; // Size of reply, or 0 for no reply DWORDLONG conn_time; // Used to calculate average and max connection times. Target* target; Raw_Result *target_results; // Pointer to results for selected target. Raw_Result *prev_target_results; while ( grunt_state != TestIdle ) { #if defined(IOMTR_OSFAMILY_NETWARE) pthread_yield(); // NetWare is non-preemptive #elif defined(IOMTR_OSFAMILY_UNIX) || defined(IOMTR_OSFAMILY_WINDOWS) // nop #else #warning ===> WARNING: You have to do some coding here to get the port done! #endif // If we can't queue another request, wait for a completion. // If we CAN queue another request, get only one completion and do // so immediately (with a time out of 0). Complete_IO( ( available_head == available_tail || target_count == targets_closing_count ) ? TIMEOUT_TIME : 0 ); // Now check to see if there really are any completed requests. // Complete_IO may not have freed a slot in the available queue. if ( available_head == available_tail ) continue; // repeat the outermost while loop // Getting an index into the target array of the next target to access. target_id = trans_slots[available_trans_queue[available_head]].target_id; target = targets[target_id]; // Checking the next target to access to see if it is closing. // This if statement is separated from the one below for performance. if ( target->spec.test_connection_rate && target->is_closing ) { // Target is closing. Move it to the tail of the available queue. available_trans_queue[available_tail++] = available_trans_queue[available_head++]; if ( available_head > cur_trans_slots ) { available_head = 0; } if ( available_tail > cur_trans_slots ) { available_tail = 0; } // Check to see if we can close the target. Targets are not closed // until all outstanding I/Os have completed. if ( target->outstanding_ios == 0 ) { #if _DEBUG cout << "Testing connection rate: Closing " << targets[target_id]->spec.name << endl; #endif // Close target and record connection time. target->Close( &grunt_state ); conn_time = rdtsc() - target->conn_start_time; // Since target is closed, it is no longer closing. target->is_closing = FALSE; // Record connection latencies. if ( ramp_up_ios_pending <= 0 && grunt_state == TestRecording ) { target_results = &(worker_performance.target_results.result[target_id]); target_results->connection_count++; target_results->connection_latency_sum += conn_time; if ( conn_time > target_results->max_raw_connection_latency ) target_results->max_raw_connection_latency = conn_time; prev_target_results = &(prev_worker_performance.target_results.result[target_id]); if ( conn_time > prev_target_results->max_raw_connection_latency ) prev_target_results->max_raw_connection_latency = conn_time; } } continue; } // Check to see if we need to open the target. if ( target->spec.test_connection_rate && target->trans_left_in_conn <= 0 ) { #if _DEBUG cout << "Testing connection rate: Opening " << target->spec.name << endl; #endif // Set the number of transactions to do before closing. target->trans_left_in_conn = target->spec.trans_per_conn; // Record the start time for the transaction. target->conn_start_time = rdtsc(); // Open the target. target->Open( &grunt_state ); // If not doing any transactions, set the target to close. if ((target->is_closing = !target->spec.trans_per_conn)) continue; } // "transaction" will now point to the next available // transaction slot transaction = &( trans_slots[ available_trans_queue[available_head] ] ); // See if this is the start of a new transaction if ( ! (transaction->remaining_requests || transaction->remaining_replies) ) { // No requests or replies remain, start a new transaction. // Check to see if this transaction will be the last one // before closing the target. target->is_closing = ( target->spec.test_connection_rate && --target->trans_left_in_conn <= 0 ); // See if we need to get a new access spec line. All transactions // for the current burst have been sent. if ( --remaining_transactions_in_burst <= 0 ) { access_spec.GetNextBurst( access_percent = (unsigned int)Rand() % 100, &remaining_transactions_in_burst, &size, &transfer_delay, &user_alignment, &user_align_mask, &reply ); // Possibly waiting some delay before sending next burst of transfers. if ( transfer_delay ) Asynchronous_Delay( transfer_delay ); } // Fill in the information for a new transaction // Set number and size of requests. (Currently always one request; we can support // any number, but this is not yet implemented in Iometer.) transaction->request_size = size; transaction->remaining_requests = 1; // Set number and size of replies. (Currently reply size = 0 means no reply, // reply size != 0 means one reply; we can support any number, but this is not // yet implemented in Iometer.) transaction->reply_size = reply; transaction->remaining_replies = ( reply ? 1 : 0 ); // Determine if the first I/O will be a read or write. // (is_read will change when replies are sent) transaction->is_read = access_spec.Read( access_percent, (unsigned int)target->Rand() % 100 ); // Set flag to record transaction start time when the transaction actually begins. transaction->start_transaction = 0; } // Prepare the next I/O of the transaction... // Set the transaction's size. if ( transaction->remaining_requests ) transaction->size = transaction->request_size; else transaction->size = transaction->reply_size; if ( IsType( target->spec.type, GenericDiskType ) ) { ((TargetDisk *) targets[target_id])->Seek( access_spec.Random( access_percent, (unsigned int)targets[target_id]->Rand() % 100 ), size, user_alignment, user_align_mask ); } transaction->start_IO = (grunt_state == TestRecording) ? rdtsc() : 0; // If the transaction start time hasn't been set, // this is the first I/O of this transaction. Set the start time. if ( !transaction->start_transaction ) transaction->start_transaction = transaction->start_IO; // // Finally doing the actual I/O request - whew! Continue to try to do // the I/O while it should be retried. A retry indicates that there // currently aren't enough reources to fulfill the request. // do { #if defined(IOMTR_OSFAMILY_NETWARE) pthread_yield(); // NetWare is Non-preemptive #elif defined(IOMTR_OSFAMILY_UNIX) || defined(IOMTR_OSFAMILY_WINDOWS) // nop #else #warning ===> WARNING: You have to do some coding here to get the port done! #endif if ( transaction->is_read ) { transfer_result = target->Read( read_data, transaction ); } else { transfer_result = target->Write( write_data, transaction ); } // Continue to process completions. This may free up the resource // that is needed. if ( transfer_result == ReturnRetry ) Complete_IO( TIMEOUT_TIME ); } while ( transfer_result == ReturnRetry && grunt_state != TestIdle ); // The request finished. See what the result was and process it // accordingly. switch ( transfer_result ) { case ReturnPending: // An I/O was successfully started, and its completion will be // posted to the completion queue. // Increment the number of outstanding I/Os to the target. target->outstanding_ios++; // See if the I/O occurred during the ramp up period. if ( !transaction->start_IO ) ++ramp_up_ios_pending; break; case ReturnSuccess: // The request completed successfully, and its completion will not // go to the completion queue. // We need to treat its full completion as "pending" to ensure that // Record_IO can properly handle it. // Increment the number of outstanding I/Os to the target. target->outstanding_ios++; // See if the I/O occurred during the ramp up period. if ( !transaction->start_IO ) ++ramp_up_ios_pending; // An I/O completed successfully and will not go to the completion // queue. Record the request as done. Record_IO( transaction, rdtsc() ); break; default: // see whether it should record the error if ( grunt_state == TestRecording ) { // ERROR: The I/O was not queued successfully. cout << "*** Error performing I/O to " << target->spec.name << endl; if ( transaction->is_read ) worker_performance.target_results.result[target_id].read_errors++; else worker_performance.target_results.result[target_id].write_errors++; } // Move the failed transaction to the end of the available queue to // allow other requests, if any, to have a chance of going. available_trans_queue[available_tail++] = available_trans_queue[available_head]; if ( available_tail > cur_trans_slots ) { available_tail = 0; } } // Move the head of the available queue to reflect the last request. if ( (++available_head) > cur_trans_slots ) { available_head = 0; } } // while grunt_state is not TestIdle }
void BreakpointLocation::GetDescription (Stream *s, lldb::DescriptionLevel level) { SymbolContext sc; // If the description level is "initial" then the breakpoint is printing out our initial state, // and we should let it decide how it wants to print our label. if (level != eDescriptionLevelInitial) { s->Indent(); BreakpointID::GetCanonicalReference(s, m_owner.GetID(), GetID()); } if (level == lldb::eDescriptionLevelBrief) return; if (level != eDescriptionLevelInitial) s->PutCString(": "); if (level == lldb::eDescriptionLevelVerbose) s->IndentMore(); if (m_address.IsSectionOffset()) { m_address.CalculateSymbolContext(&sc); if (level == lldb::eDescriptionLevelFull || level == eDescriptionLevelInitial) { if (IsReExported()) s->PutCString ("re-exported target = "); else s->PutCString("where = "); sc.DumpStopContext (s, m_owner.GetTarget().GetProcessSP().get(), m_address, false, true, false, true, true); } else { if (sc.module_sp) { s->EOL(); s->Indent("module = "); sc.module_sp->GetFileSpec().Dump (s); } if (sc.comp_unit != NULL) { s->EOL(); s->Indent("compile unit = "); static_cast<FileSpec*>(sc.comp_unit)->GetFilename().Dump (s); if (sc.function != NULL) { s->EOL(); s->Indent("function = "); s->PutCString (sc.function->GetName().AsCString("<unknown>")); } if (sc.line_entry.line > 0) { s->EOL(); s->Indent("location = "); sc.line_entry.DumpStopContext (s, true); } } else { // If we don't have a comp unit, see if we have a symbol we can print. if (sc.symbol) { s->EOL(); if (IsReExported()) s->Indent ("re-exported target = "); else s->Indent("symbol = "); s->PutCString(sc.symbol->GetName().AsCString("<unknown>")); } } } } if (level == lldb::eDescriptionLevelVerbose) { s->EOL(); s->Indent(); } if (m_address.IsSectionOffset() && (level == eDescriptionLevelFull || level == eDescriptionLevelInitial)) s->Printf (", "); s->Printf ("address = "); ExecutionContextScope *exe_scope = NULL; Target *target = &m_owner.GetTarget(); if (target) exe_scope = target->GetProcessSP().get(); if (exe_scope == NULL) exe_scope = target; if (level == eDescriptionLevelInitial) m_address.Dump(s, exe_scope, Address::DumpStyleLoadAddress, Address::DumpStyleFileAddress); else m_address.Dump(s, exe_scope, Address::DumpStyleLoadAddress, Address::DumpStyleModuleWithFileAddress); if (IsIndirect() && m_bp_site_sp) { Address resolved_address; resolved_address.SetLoadAddress(m_bp_site_sp->GetLoadAddress(), target); Symbol *resolved_symbol = resolved_address.CalculateSymbolContextSymbol(); if (resolved_symbol) { if (level == eDescriptionLevelFull || level == eDescriptionLevelInitial) s->Printf (", "); else if (level == lldb::eDescriptionLevelVerbose) { s->EOL(); s->Indent(); } s->Printf ("indirect target = %s", resolved_symbol->GetName().GetCString()); } } if (level == lldb::eDescriptionLevelVerbose) { s->EOL(); s->Indent(); s->Printf("resolved = %s\n", IsResolved() ? "true" : "false"); s->Indent(); s->Printf ("hit count = %-4u\n", GetHitCount()); if (m_options_ap.get()) { s->Indent(); m_options_ap->GetDescription (s, level); s->EOL(); } s->IndentLess(); } else if (level != eDescriptionLevelInitial) { s->Printf(", %sresolved, hit count = %u ", (IsResolved() ? "" : "un"), GetHitCount()); if (m_options_ap.get()) { m_options_ap->GetDescription (s, level); } } }
/// @brief Platform-level implementation called by getScom() ReturnCode platGetScom(const Target<TARGET_TYPE_ALL>& i_target, const uint64_t i_address, buffer<uint64_t>& o_data) { ReturnCode l_rc; errlHndl_t l_err = NULL; FAPI_DBG(ENTER_MRK "platGetScom"); // Note: Trace is placed here in plat code because PPE doesn't support // trace in common fapi2_hw_access.H bool l_traceit = platIsScanTraceEnabled(); // Extract the component pointer TARGETING::Target* l_target = reinterpret_cast<TARGETING::Target*>(i_target.get()); // Grab the name of the target TARGETING::ATTR_FAPI_NAME_type l_targName = {0}; fapi2::toString(i_target, l_targName, sizeof(l_targName)); // Perform SCOM read size_t l_size = sizeof(uint64_t); l_err = deviceRead(l_target, &o_data(), l_size, DEVICE_SCOM_ADDRESS(i_address, opMode)); //If an error occured durring the device read and a pib_err_mask is set, // then we will check if the err matches the mask, if it does we // ignore the error if(l_err && (pib_err_mask != 0x00)) { checkPibMask(l_err); } if (l_err) { if(opMode & fapi2::IGNORE_HW_ERROR) { delete l_err; l_err = nullptr; } else { FAPI_ERR("platGetScom: deviceRead returns error!"); FAPI_ERR("fapiGetScom failed - Target %s, Addr %.16llX", l_targName, i_address); l_rc.setPlatDataPtr(reinterpret_cast<void *> (l_err)); } } if (l_traceit) { uint64_t l_data = (uint64_t)o_data; FAPI_SCAN("TRACE : GETSCOM : %s : %.16llX %.16llX", l_targName, i_address, l_data); } FAPI_DBG(EXIT_MRK "platGetScom"); return l_rc; }