static PPCTargetMachine::PPCABI computeTargetABI(const Triple &TT, const TargetOptions &Options) { if (Options.MCOptions.getABIName().startswith("elfv1")) return PPCTargetMachine::PPC_ABI_ELFv1; else if (Options.MCOptions.getABIName().startswith("elfv2")) return PPCTargetMachine::PPC_ABI_ELFv2; assert(Options.MCOptions.getABIName().empty() && "Unknown target-abi option!"); if (!TT.isMacOSX()) { switch (TT.getArch()) { case Triple::ppc64le: return PPCTargetMachine::PPC_ABI_ELFv2; case Triple::ppc64: return PPCTargetMachine::PPC_ABI_ELFv1; default: // Fallthrough. ; } } return PPCTargetMachine::PPC_ABI_UNKNOWN; }
PPCMCAsmInfoDarwin::PPCMCAsmInfoDarwin(bool is64Bit, const Triple& T) { if (is64Bit) { PointerSize = CalleeSaveStackSlotSize = 8; } IsLittleEndian = false; CommentString = ";"; ExceptionsType = ExceptionHandling::DwarfCFI; if (!is64Bit) Data64bitsDirective = 0; // We can't emit a 64-bit unit in PPC32 mode. AssemblerDialect = 1; // New-Style mnemonics. SupportsDebugInformation= true; // Debug information. // The installed assembler for OSX < 10.6 lacks some directives. // FIXME: this should really be a check on the assembler characteristics // rather than OS version if (T.isMacOSX() && T.isMacOSXVersionLT(10, 6)) HasWeakDefCanBeHiddenDirective = false; UseIntegratedAssembler = true; }
bool NameServiceOnTriples::cmdCheck(NameTripleState& act) { lock(); if (act.reply.size()==0) { act.reply.addString("old"); } ConstString port = act.cmd.get(1).asString(); ConstString key = act.cmd.get(2).toString(); ConstString val = act.cmd.get(3).toString(); Triple t; t.setNameValue("port",port.c_str()); int result = act.mem.find(t, YARP_NULLPTR); if (result==-1) { unlock(); return false; } TripleContext context; context.setRid(result); t.setNameValue(key.c_str(),"*"); list<Triple> lst = act.mem.query(t,&context); Bottle& q = act.reply.addList(); q.addString("port"); q.addString(port); q.addString("property"); q.addString(key); q.addString("value"); q.addString(val); q.addString("present"); ConstString present = "false"; for (list<Triple>::iterator it=lst.begin(); it!=lst.end(); it++) { if (val == it->value.c_str()) { present = "true"; } } q.addString(present); unlock(); return true; }
Expected<std::unique_ptr<LazyCallThroughManager>> createLocalLazyCallThroughManager(const Triple &T, ExecutionSession &ES, JITTargetAddress ErrorHandlerAddr) { switch (T.getArch()) { default: return make_error<StringError>( std::string("No callback manager available for ") + T.str(), inconvertibleErrorCode()); case Triple::aarch64: return LocalLazyCallThroughManager::Create<OrcAArch64>(ES, ErrorHandlerAddr); case Triple::x86: return LocalLazyCallThroughManager::Create<OrcI386>(ES, ErrorHandlerAddr); case Triple::mips: return LocalLazyCallThroughManager::Create<OrcMips32Be>(ES, ErrorHandlerAddr); case Triple::mipsel: return LocalLazyCallThroughManager::Create<OrcMips32Le>(ES, ErrorHandlerAddr); case Triple::mips64: case Triple::mips64el: return LocalLazyCallThroughManager::Create<OrcMips64>(ES, ErrorHandlerAddr); case Triple::x86_64: if (T.getOS() == Triple::OSType::Win32) return LocalLazyCallThroughManager::Create<OrcX86_64_Win32>( ES, ErrorHandlerAddr); else return LocalLazyCallThroughManager::Create<OrcX86_64_SysV>( ES, ErrorHandlerAddr); } }
MipsMCAsmInfo::MipsMCAsmInfo(const Triple &TheTriple) { if ((TheTriple.getArch() == Triple::mips) || (TheTriple.getArch() == Triple::mips64)) IsLittleEndian = false; if ((TheTriple.getArch() == Triple::mips64el) || (TheTriple.getArch() == Triple::mips64)) { PointerSize = CalleeSaveStackSlotSize = 8; } // FIXME: This condition isn't quite right but it's the best we can do until // this object can identify the ABI. It will misbehave when using O32 // on a mips64*-* triple. if ((TheTriple.getArch() == Triple::mipsel) || (TheTriple.getArch() == Triple::mips)) { PrivateGlobalPrefix = "$"; PrivateLabelPrefix = "$"; } AlignmentIsInBytes = false; Data16bitsDirective = "\t.2byte\t"; Data32bitsDirective = "\t.4byte\t"; Data64bitsDirective = "\t.8byte\t"; CommentString = "#"; ZeroDirective = "\t.space\t"; GPRel32Directive = "\t.gpword\t"; GPRel64Directive = "\t.gpdword\t"; UseAssignmentForEHBegin = true; SupportsDebugInformation = true; ExceptionsType = ExceptionHandling::DwarfCFI; DwarfRegNumForCFI = true; // Enable IAS by default for O32. if (TheTriple.getArch() == Triple::mips || TheTriple.getArch() == Triple::mipsel) UseIntegratedAssembler = true; }
OrcLazyJIT::CallbackManagerBuilder OrcLazyJIT::createCallbackManagerBuilder(Triple T) { switch (T.getArch()) { default: return nullptr; case Triple::x86_64: { typedef orc::JITCompileCallbackManager<CompileLayerT, orc::OrcX86_64> CCMgrT; return [](CompileLayerT &CompileLayer, RuntimeDyld::MemoryManager &MemMgr, LLVMContext &Context) { return make_unique<CCMgrT>(CompileLayer, MemMgr, Context, 0, 64); }; } } }
X86MCAsmInfoMicrosoft::X86MCAsmInfoMicrosoft(const Triple &Triple) { if (Triple.getArch() == Triple::x86_64) { PrivateGlobalPrefix = ".L"; PointerSize = 8; ExceptionsType = ExceptionHandling::WinEH; } AssemblerDialect = AsmWriterFlavor; TextAlignFillValue = 0x90; AllowAtInName = true; UseIntegratedAssembler = true; }
Triple ObjectFile::makeTriple() const { Triple TheTriple; auto Arch = getArch(); TheTriple.setArch(Triple::ArchType(Arch)); // For ARM targets, try to use the build attributes to build determine // the build target. Target features are also added, but later during // disassembly. if (Arch == Triple::arm || Arch == Triple::armeb) setARMSubArch(TheTriple); // TheTriple defaults to ELF, and COFF doesn't have an environment: // the best we can do here is indicate that it is mach-o. if (isMachO()) TheTriple.setObjectFormat(Triple::MachO); if (isCOFF()) { const auto COFFObj = dyn_cast<COFFObjectFile>(this); if (COFFObj->getArch() == Triple::thumb) TheTriple.setTriple("thumbv7-windows"); } return TheTriple; }
static Triple::ObjectFormatType getDefaultFormat(const Triple &T) { switch (T.getArch()) { default: break; case Triple::hexagon: case Triple::mips: case Triple::mipsel: case Triple::mips64: case Triple::mips64el: case Triple::r600: case Triple::amdgcn: case Triple::sparc: case Triple::sparcv9: case Triple::systemz: case Triple::xcore: case Triple::ppc64le: return Triple::ELF; case Triple::ppc: case Triple::ppc64: if (T.isOSDarwin()) return Triple::MachO; return Triple::ELF; case Triple::wasm32: case Triple::wasm64: // Unknown for now, until an object format is specified. return Triple::UnknownObjectFormat; } if (T.isOSDarwin()) return Triple::MachO; else if (T.isOSWindows()) return Triple::COFF; return Triple::ELF; }
static ARMBaseTargetMachine::ARMABI computeTargetABI(const Triple &TT, StringRef CPU, const TargetOptions &Options) { if (Options.MCOptions.getABIName().startswith("aapcs")) return ARMBaseTargetMachine::ARM_ABI_AAPCS; else if (Options.MCOptions.getABIName().startswith("apcs")) return ARMBaseTargetMachine::ARM_ABI_APCS; assert(Options.MCOptions.getABIName().empty() && "Unknown target-abi option!"); ARMBaseTargetMachine::ARMABI TargetABI = ARMBaseTargetMachine::ARM_ABI_UNKNOWN; // FIXME: This is duplicated code from the front end and should be unified. if (TT.isOSBinFormatMachO()) { if (TT.getEnvironment() == llvm::Triple::EABI || (TT.getOS() == llvm::Triple::UnknownOS && TT.getObjectFormat() == llvm::Triple::MachO) || CPU.startswith("cortex-m")) { TargetABI = ARMBaseTargetMachine::ARM_ABI_AAPCS; } else { TargetABI = ARMBaseTargetMachine::ARM_ABI_APCS; } } else if (TT.isOSWindows()) { // FIXME: this is invalid for WindowsCE TargetABI = ARMBaseTargetMachine::ARM_ABI_AAPCS; } else { // Select the default based on the platform. switch (TT.getEnvironment()) { case llvm::Triple::Android: case llvm::Triple::GNUEABI: case llvm::Triple::GNUEABIHF: case llvm::Triple::EABIHF: case llvm::Triple::EABI: TargetABI = ARMBaseTargetMachine::ARM_ABI_AAPCS; break; case llvm::Triple::GNU: TargetABI = ARMBaseTargetMachine::ARM_ABI_APCS; break; default: if (TT.getOS() == llvm::Triple::NetBSD) TargetABI = ARMBaseTargetMachine::ARM_ABI_APCS; else TargetABI = ARMBaseTargetMachine::ARM_ABI_AAPCS; break; } } return TargetABI; }
NVPTXTargetMachine::NVPTXTargetMachine(const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, Reloc::Model RM, CodeModel::Model CM, CodeGenOpt::Level OL, bool is64bit) : LLVMTargetMachine(T, computeDataLayout(is64bit), TT, CPU, FS, Options, RM, CM, OL), is64bit(is64bit), TLOF(make_unique<NVPTXTargetObjectFile>()), Subtarget(TT, CPU, FS, *this) { if (TT.getOS() == Triple::NVCL) drvInterface = NVPTX::NVCL; else drvInterface = NVPTX::CUDA; initAsmInfo(); }
int main(int argc, char **argv) { // Print a stack trace if we signal out. sys::PrintStackTraceOnErrorSignal(); PrettyStackTraceProgram X(argc, argv); llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. cl::ParseCommandLineOptions(argc, argv, "llvm object size dumper\n"); ToolName = argv[0]; if (OutputFormatShort.getNumOccurrences()) OutputFormat = OutputFormatShort; if (RadixShort.getNumOccurrences()) Radix = RadixShort; for (unsigned i = 0; i < ArchFlags.size(); ++i) { if (ArchFlags[i] == "all") { ArchAll = true; } else { Triple T = MachOObjectFile::getArch(ArchFlags[i]); if (T.getArch() == Triple::UnknownArch) { outs() << ToolName << ": for the -arch option: Unknown architecture " << "named '" << ArchFlags[i] << "'"; return 1; } } } if (InputFilenames.size() == 0) InputFilenames.push_back("a.out"); moreThanOneFile = InputFilenames.size() > 1; std::for_each(InputFilenames.begin(), InputFilenames.end(), PrintFileSectionSizes); return 0; }
X86ELFMCAsmInfo::X86ELFMCAsmInfo(const Triple &T) { AsmTransCBE = x86_asm_table; AssemblerDialect = AsmWriterFlavor; TextAlignFillValue = 0x90; PrivateGlobalPrefix = ".L"; WeakRefDirective = "\t.weak\t"; PCSymbol = "."; // Set up DWARF directives HasLEB128 = true; // Target asm supports leb128 directives (little-endian) // Debug Information SupportsDebugInformation = true; // Exceptions handling ExceptionsType = ExceptionHandling::Dwarf; // OpenBSD has buggy support for .quad in 32-bit mode, just split into two // .words. if (T.getOS() == Triple::OpenBSD && T.getArch() == Triple::x86) Data64bitsDirective = 0; }
static std::unique_ptr<TargetLoweringObjectFile> createTLOF(const Triple &TT) { if (TT.isOSBinFormatMachO()) { if (TT.getArch() == Triple::x86_64) return make_unique<X86_64MachoTargetObjectFile>(); return make_unique<TargetLoweringObjectFileMachO>(); } if (TT.isOSLinux() || TT.isOSNaCl()) return make_unique<X86LinuxNaClTargetObjectFile>(); if (TT.isOSBinFormatELF()) return make_unique<X86ELFTargetObjectFile>(); if (TT.isKnownWindowsMSVCEnvironment() || TT.isWindowsCoreCLREnvironment()) return make_unique<X86WindowsTargetObjectFile>(); if (TT.isOSBinFormatCOFF()) return make_unique<TargetLoweringObjectFileCOFF>(); llvm_unreachable("unknown subtarget type"); }
/// Create an WebAssembly architecture model. /// WebAssemblyTargetMachine::WebAssemblyTargetMachine( const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, Reloc::Model RM, CodeModel::Model CM, CodeGenOpt::Level OL) : LLVMTargetMachine(T, TT.isArch64Bit() ? "e-p:64:64-i64:64-v128:8:128-n32:64-S128" : "e-p:32:32-i64:64-v128:8:128-n32:64-S128", TT, CPU, FS, Options, RM, CM, OL), TLOF(make_unique<WebAssemblyTargetObjectFile>()) { initAsmInfo(); // We need a reducible CFG, so disable some optimizations which tend to // introduce irreducibility. setRequiresStructuredCFG(true); }
std::function<std::unique_ptr<IndirectStubsManager>()> createLocalIndirectStubsManagerBuilder(const Triple &T) { switch (T.getArch()) { default: return [](){ return llvm::make_unique< orc::LocalIndirectStubsManager<orc::OrcGenericABI>>(); }; case Triple::aarch64: return [](){ return llvm::make_unique< orc::LocalIndirectStubsManager<orc::OrcAArch64>>(); }; case Triple::x86: return [](){ return llvm::make_unique< orc::LocalIndirectStubsManager<orc::OrcI386>>(); }; case Triple::x86_64: if (T.getOS() == Triple::OSType::Win32) { return [](){ return llvm::make_unique< orc::LocalIndirectStubsManager<orc::OrcX86_64_Win32>>(); }; } else { return [](){ return llvm::make_unique< orc::LocalIndirectStubsManager<orc::OrcX86_64_SysV>>(); }; } } }
// checkMachOAndArchFlags() checks to see if the SymbolicFile is a Mach-O file // and if it is and there is a list of architecture flags is specified then // check to make sure this Mach-O file is one of those architectures or all // architectures was specificed. If not then an error is generated and this // routine returns false. Else it returns true. static bool checkMachOAndArchFlags(SymbolicFile *O, std::string &Filename) { MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(O); if (!MachO || ArchAll || ArchFlags.size() == 0) return true; MachO::mach_header H; MachO::mach_header_64 H_64; Triple T; if (MachO->is64Bit()) { H_64 = MachO->MachOObjectFile::getHeader64(); T = MachOObjectFile::getArch(H_64.cputype, H_64.cpusubtype); } else { H = MachO->MachOObjectFile::getHeader(); T = MachOObjectFile::getArch(H.cputype, H.cpusubtype); } if (std::none_of( ArchFlags.begin(), ArchFlags.end(), [&](const std::string &Name) { return Name == T.getArchName(); })) { error("No architecture specified", Filename); return false; } return true; }
std::vector<Triple> Flock::getVelIncr(unsigned int ticks, unsigned int delta_ticks) { Triple steering; Triple direction; int tam = 0; double distance, targetSpeed; Triple cp, tp; //if (this->accum == 0) { for (unsigned int i = 0; i < boids.size(); i++) { if (target->pos.length() < flockRadius) { target->pos += boids[i]->pos; tam++; } } if (tam > 0) target->pos /= tam; //} //if (this->accum++ == 3000) this->accum = 0; std::tie(cp, tp) = points(this->character, this->target); /* steering = tp - cp; if (steering.length() > 0.001) { steering.normalized(); steering *= maxAcceleration; }*/ // TODO: distance direction = tp - cp; distance = direction.length(); if (distance < targetRadius) { steering = target->vel - character->vel; if (steering.length() > maxAcceleration) { steering.normalized(); steering *= maxAcceleration; } return std::vector<Triple>(1, steering); } targetSpeed = maxAcceleration - character->vel.dot(direction.normalized()); if (distance < slowRadius) { targetSpeed *= (distance - targetRadius) / (slowRadius - targetRadius); } if (targetSpeed < 0) targetSpeed = 0; if (targetSpeed > maxAcceleration) targetSpeed = maxAcceleration; steering = direction.normalized() * targetSpeed; return std::vector<Triple>(1, steering); }
static bool useCompactUnwind(const Triple &T) { // Only on darwin. if (!T.isOSDarwin()) return false; // aarch64 always has it. if (T.getArch() == Triple::arm64 || T.getArch() == Triple::aarch64) return true; // Use it on newer version of OS X. if (T.isMacOSX() && !T.isMacOSXVersionLT(10, 6)) return true; // And the iOS simulator. if (T.isiOS() && (T.getArch() == Triple::x86_64 || T.getArch() == Triple::x86)) return true; return false; }
static bool hasSinCosPiStret(const Triple &T) { // Only Darwin variants have _stret versions of combined trig functions. if (!T.isMacOSX() && T.getOS() != Triple::IOS) return false; // The ABI is rather complicated on x86, so don't do anything special there. if (T.getArch() == Triple::x86) return false; if (T.isMacOSX() && T.isMacOSXVersionLT(10, 9)) return false; if (T.getOS() == Triple::IOS && T.isOSVersionLT(7, 0)) return false; return true; }
NVPTXTargetMachine::NVPTXTargetMachine(const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, Optional<Reloc::Model> RM, CodeModel::Model CM, CodeGenOpt::Level OL, bool is64bit) // The pic relocation model is used regardless of what the client has // specified, as it is the only relocation model currently supported. : LLVMTargetMachine(T, computeDataLayout(is64bit), TT, CPU, FS, Options, Reloc::PIC_, CM, OL), is64bit(is64bit), TLOF(llvm::make_unique<NVPTXTargetObjectFile>()), Subtarget(TT, CPU, FS, *this) { if (TT.getOS() == Triple::NVCL) drvInterface = NVPTX::NVCL; else drvInterface = NVPTX::CUDA; initAsmInfo(); }
/// Create an WebAssembly architecture model. /// WebAssemblyTargetMachine::WebAssemblyTargetMachine( const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, Reloc::Model RM, CodeModel::Model CM, CodeGenOpt::Level OL) : LLVMTargetMachine(T, TT.isArch64Bit() ? "e-p:64:64-i64:64-n32:64-S128" : "e-p:32:32-i64:64-n32:64-S128", TT, CPU, FS, Options, RM, CM, OL), TLOF(make_unique<WebAssemblyTargetObjectFile>()) { // WebAssembly type-checks expressions, but a noreturn function with a return // type that doesn't match the context will cause a check failure. So we lower // LLVM 'unreachable' to ISD::TRAP and then lower that to WebAssembly's // 'unreachable' expression which is meant for that case. this->Options.TrapUnreachable = true; initAsmInfo(); // We need a reducible CFG, so disable some optimizations which tend to // introduce irreducibility. setRequiresStructuredCFG(true); }
bool Triple::EpsilonEquals(Triple t, double d) { assert(d >= 0); if (GetX() - t.GetX() < d && GetX() - t.GetX() > -d) { if (GetY() - t.GetY() < d && GetY() - t.GetY() > -d) { if (GetZ() - t.GetZ() < d && GetZ() - t.GetZ() > -d) { return true; } } } return false; }
/// Create an ARM architecture model. /// ARMBaseTargetMachine::ARMBaseTargetMachine(const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM, CodeGenOpt::Level OL, bool isLittle) : LLVMTargetMachine(T, computeDataLayout(TT, CPU, Options, isLittle), TT, CPU, FS, Options, getEffectiveRelocModel(TT, RM), getEffectiveCodeModel(CM, CodeModel::Small), OL), TargetABI(computeTargetABI(TT, CPU, Options)), TLOF(createTLOF(getTargetTriple())), isLittle(isLittle) { // Default to triple-appropriate float ABI if (Options.FloatABIType == FloatABI::Default) { if (isTargetHardFloat()) this->Options.FloatABIType = FloatABI::Hard; else this->Options.FloatABIType = FloatABI::Soft; } // Default to triple-appropriate EABI if (Options.EABIVersion == EABI::Default || Options.EABIVersion == EABI::Unknown) { // musl is compatible with glibc with regard to EABI version if ((TargetTriple.getEnvironment() == Triple::GNUEABI || TargetTriple.getEnvironment() == Triple::GNUEABIHF || TargetTriple.getEnvironment() == Triple::MuslEABI || TargetTriple.getEnvironment() == Triple::MuslEABIHF) && !(TargetTriple.isOSWindows() || TargetTriple.isOSDarwin())) this->Options.EABIVersion = EABI::GNU; else this->Options.EABIVersion = EABI::EABI5; } if (TT.isOSBinFormatMachO()) { this->Options.TrapUnreachable = true; this->Options.NoTrapAfterNoreturn = true; } initAsmInfo(); }
/// Create an AArch64 architecture model. /// AArch64TargetMachine::AArch64TargetMachine(const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, Optional<Reloc::Model> RM, Optional<CodeModel::Model> CM, CodeGenOpt::Level OL, bool JIT, bool LittleEndian) : LLVMTargetMachine(T, computeDataLayout(TT, Options.MCOptions, LittleEndian), TT, CPU, FS, Options, getEffectiveRelocModel(TT, RM), getEffectiveCodeModel(TT, CM, JIT), OL), TLOF(createTLOF(getTargetTriple())), isLittle(LittleEndian) { initAsmInfo(); if (TT.isOSBinFormatMachO()) this->Options.TrapUnreachable = true; // Enable GlobalISel at or below EnableGlobalISelAt0. if (getOptLevel() <= EnableGlobalISelAtO) setGlobalISel(true); }
static CodeModel::Model getEffectiveCodeModel(const Triple &TT, Optional<CodeModel::Model> CM, bool JIT) { if (CM) { if (*CM != CodeModel::Small && *CM != CodeModel::Large) { if (!TT.isOSFuchsia()) report_fatal_error( "Only small and large code models are allowed on AArch64"); else if (CM != CodeModel::Kernel) report_fatal_error( "Only small, kernel, and large code models are allowed on AArch64"); } return *CM; } // The default MCJIT memory managers make no guarantees about where they can // find an executable page; JITed code needs to be able to refer to globals // no matter how far away they are. if (JIT) return CodeModel::Large; return CodeModel::Small; }
/// Create an WebAssembly architecture model. /// WebAssemblyTargetMachine::WebAssemblyTargetMachine( const Target &T, const Triple &TT, StringRef CPU, StringRef FS, const TargetOptions &Options, Reloc::Model RM, CodeModel::Model CM, CodeGenOpt::Level OL) : LLVMTargetMachine(T, TT.isArch64Bit() ? "e-m:e-p:64:64-i64:64-n32:64-S128" : "e-m:e-p:32:32-i64:64-n32:64-S128", TT, CPU, FS, Options, RM, CM, OL), TLOF(make_unique<WebAssemblyTargetObjectFile>()) { // WebAssembly type-checks expressions, but a noreturn function with a return // type that doesn't match the context will cause a check failure. So we lower // LLVM 'unreachable' to ISD::TRAP and then lower that to WebAssembly's // 'unreachable' expression which is meant for that case. this->Options.TrapUnreachable = true; initAsmInfo(); // Note that we don't use setRequiresStructuredCFG(true). It disables // optimizations than we're ok with, and want, such as critical edge // splitting and tail merging. }
std::vector<Triple> Evade::getVel(unsigned int ticks, unsigned int delta_ticks) { Triple steering; Triple direction; double distance, targetRadius = 1.0, speed, prediction; Triple cp, tp; if (character->vel.length() == 0) { #ifdef DEBUG_EVADE std::cout << "Evade : " << dynamic_cast<void *>(this) << "1 distancia : " << distance << " velocidad : " << std::endl; steering.print(); #endif return std::vector<Triple>(); } std::tie(cp, tp) = points(this->character, this->target); direction = cp - tp; distance = direction.length(); if (distance < targetRadius) { #ifdef DEBUG_EVADE std::cout << "Evade : " << dynamic_cast<void *>(this) << "2 distancia : " << distance << " velocidad : " << std::endl; steering.print(); #endif return std::vector<Triple>(); } speed = character->vel.length(); if (speed <= (distance / maxPrediction)) prediction = maxPrediction; else prediction = distance / speed; steering = cp - tp + target->vel * prediction; steering.normalized(); #ifdef DEBUG_EVADE std::cout << "Evade : " << dynamic_cast<void *>(this) << "3 distancia : " << distance << " velocidad : " << std::endl; steering.print(); #endif steering *= maxSpeed; return std::vector<Triple>(1, steering); }
X86MCAsmInfoMicrosoft::X86MCAsmInfoMicrosoft(const Triple &Triple) { if (Triple.getArch() == Triple::x86_64) { PrivateGlobalPrefix = ".L"; PrivateLabelPrefix = ".L"; PointerSize = 8; WinEHEncodingType = WinEH::EncodingType::Itanium; } else { // 32-bit X86 doesn't use CFI, so this isn't a real encoding type. It's just // a place holder that the Windows EHStreamer looks for to suppress CFI // output. In particular, usesWindowsCFI() returns false. WinEHEncodingType = WinEH::EncodingType::X86; } ExceptionsType = ExceptionHandling::WinEH; AssemblerDialect = AsmWriterFlavor; TextAlignFillValue = 0x90; AllowAtInName = true; UseIntegratedAssembler = true; }
Nios2MCAsmInfo::Nios2MCAsmInfo(const Triple &TheTriple) { if ((TheTriple.getArch() == Triple::nios2)) IsLittleEndian = true; // the default of IsLittleEndian is true AlignmentIsInBytes = false; Data16bitsDirective = "\t.2byte\t"; Data32bitsDirective = "\t.4byte\t"; Data64bitsDirective = "\t.8byte\t"; PrivateLabelPrefix = ".LC"; CommentString = "#"; ZeroDirective = "\t.space\t"; GPRel32Directive = "\t.gpword\t"; GPRel64Directive = "\t.gpdword\t"; WeakRefDirective = "\t.weak\t"; GlobalDirective = "\t.global\t"; AscizDirective = "\t.string\t"; UseAssignmentForEHBegin = true; SupportsDebugInformation = true; ExceptionsType = ExceptionHandling::DwarfCFI; DwarfRegNumForCFI = true; UsesELFSectionDirectiveForBSS = true; }