Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "MandarinPassConfig", "::", "addPreEmitPass", "(", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "This", "pass", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "machine", "code", "is", "emitted", "." ]

[ "Mandarin" ]

[]

[ "<s>", "bool", "AMDGPUCallLowering", "::", "lowerReturn", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Value", "*", "Val", ",", "ArrayRef", "<", "unsigned", ">", "VRegs", ")", "const", "{", "if", "(", "Val", ")", "return", "false", ";", "MIRBuilder", ".", "buildInstr", "(", "AMDGPU", "::", "S_ENDPGM", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "behaves", "as", "the", "extended", "lowerReturn", "function", ",", "but", "for", "targets", "that", "do", "not", "support", "swifterror", "value", "promotion", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU::S_ENDPGM" ]

[]

[ "<s>", "void", "emitLocal", "(", "ArrayRef", "<", "wasm", "::", "ValType", ">", ")", "override", "{", "}", "</s>" ]

[ ".local" ]

[ "WebAssembly", "wasm::ValType" ]

[]

[ "<s>", "static", "void", "unw_access_gr", "(", "struct", "_Unwind_Context", "*", "info", ",", "int", "regnum", ",", "unsigned", "long", "*", "val", ",", "char", "*", "nat", ",", "int", "write", ")", "{", "unsigned", "long", "*", "addr", ",", "*", "nat_addr", "=", "0", ",", "nat_mask", "=", "0", ",", "dummy_nat", ";", "struct", "unw_ireg", "*", "ireg", ";", "if", "(", "(", "unsigned", ")", "regnum", "-", "1", ">=", "127", ")", "abort", "(", ")", ";", "if", "(", "regnum", "<", "1", ")", "{", "nat_addr", "=", "addr", "=", "&", "dummy_nat", ";", "dummy_nat", "=", "0", ";", "}", "else", "if", "(", "regnum", "<", "32", ")", "{", "ireg", "=", "&", "info", "->", "ireg", "[", "regnum", "-", "2", "]", ";", "addr", "=", "ireg", "->", "loc", ";", "if", "(", "addr", ")", "{", "nat_addr", "=", "addr", "+", "ireg", "->", "nat", ".", "off", ";", "switch", "(", "ireg", "->", "nat", ".", "type", ")", "{", "case", "UNW_NAT_VAL", ":", "if", "(", "write", ")", "{", "if", "(", "*", "nat", ")", "{", "addr", "[", "0", "]", "=", "0", ";", "addr", "[", "1", "]", "=", "0x1fffe", ";", "return", ";", "}", "addr", "[", "1", "]", "=", "0x1003e", ";", "}", "else", "if", "(", "addr", "[", "0", "]", "==", "0", "&&", "addr", "[", "1", "]", "==", "0x1ffe", ")", "{", "*", "val", "=", "0", ";", "*", "nat", "=", "1", ";", "return", ";", "}", "case", "UNW_NAT_NONE", ":", "dummy_nat", "=", "0", ";", "nat_addr", "=", "&", "dummy_nat", ";", "break", ";", "case", "UNW_NAT_MEMSTK", ":", "nat_mask", "=", "1UL", "<<", "(", "(", "long", ")", "addr", "&", "0x1f8", ")", "/", "8", ";", "break", ";", "case", "UNW_NAT_REGSTK", ":", "nat_addr", "=", "ia64_rse_rnat_addr", "(", "addr", ")", ";", "if", "(", "(", "unsigned", "long", ")", "nat_addr", ">=", "info", "->", "regstk_top", ")", "nat_addr", "=", "&", "info", "->", "rnat", ";", "nat_mask", "=", "1UL", "<<", "ia64_rse_slot_num", "(", "addr", ")", ";", "break", ";", "}", "}", "}", "else", "{", "addr", "=", "ia64_rse_skip_regs", "(", "(", "unsigned", "long", "*", ")", "info", "->", "bsp", ",", "regnum", "-", "32", ")", ";", "nat_addr", "=", "ia64_rse_rnat_addr", "(", "addr", ")", ";", "if", "(", "(", "unsigned", "long", ")", "nat_addr", ">=", "info", "->", "regstk_top", ")", "nat_addr", "=", "&", "info", "->", "rnat", ";", "nat_mask", "=", "1UL", "<<", "ia64_rse_slot_num", "(", "addr", ")", ";", "}", "if", "(", "write", ")", "{", "*", "addr", "=", "*", "val", ";", "if", "(", "*", "nat", ")", "*", "nat_addr", "|=", "nat_mask", ";", "else", "*", "nat_addr", "&=", "~", "nat_mask", ";", "}", "else", "{", "*", "val", "=", "*", "addr", ";", "*", "nat", "=", "(", "*", "nat_addr", "&", "nat_mask", ")", "!=", "0", ";", "}", "}", "</s>" ]

[ "Unwind", "accessors", "." ]

[ "ia64", "0", "0", "1", "127", "1", "0", "32", "2", "0", "0", "1", "0x1fffe", "1", "0x1003e", "0", "0", "1", "0x1ffe", "0", "1", "0", "1UL", "0x1f8", "8", "1UL", "32", "1UL", "0" ]

[]

[ "<s>", "static", "bool", "rs6000_cannot_force_const_mem", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "HIGH", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "UNSPEC", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "!=", "0", ")", "return", "true", ";", "return", "TARGET_ELF", "&&", "tls_referenced_p", "(", "x", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_CANNOT_FORCE_CONST_MEM", "." ]

[ "powerpcspe", "0", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "bool", "PIC16TargetMachine", "::", "addInstSelector", "(", "PassManagerBase", "&", "PM", ",", "bool", "Fast", ")", "{", "PM", ".", "add", "(", "createPIC16ISelDag", "(", "*", "this", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "PIC16", "PIC16", "PIC16" ]

[]

[ "<s>", "unsigned", "WebAssemblyInstrInfo", "::", "insertBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "*", "TBB", ",", "MachineBasicBlock", "*", "FBB", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ",", "const", "DebugLoc", "&", "DL", ",", "int", "*", "BytesAdded", ")", "const", "{", "assert", "(", "!", "BytesAdded", "&&", "\"code size not handled\"", ")", ";", "if", "(", "Cond", ".", "empty", "(", ")", ")", "{", "if", "(", "!", "TBB", ")", "return", "0", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR", ")", ")", ".", "addMBB", "(", "TBB", ")", ";", "return", "1", ";", "}", "assert", "(", "Cond", ".", "size", "(", ")", "==", "2", "&&", "\"Expected a flag and a successor block\"", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "auto", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "bool", "IsBrOnExn", "=", "Cond", "[", "1", "]", ".", "isReg", "(", ")", "&&", "MRI", ".", "getRegClass", "(", "Cond", "[", "1", "]", ".", "getReg", "(", ")", ")", "==", "&", "WebAssembly", "::", "EXNREFRegClass", ";", "if", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", "{", "if", "(", "IsBrOnExn", ")", "{", "const", "char", "*", "CPPExnSymbol", "=", "MF", ".", "createExternalSymbolName", "(", "\"__cpp_exception\"", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR_ON_EXN", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "addExternalSymbol", "(", "CPPExnSymbol", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ";", "}", "else", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR_IF", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ";", "}", "else", "{", "assert", "(", "!", "IsBrOnExn", "&&", "\"br_on_exn does not have a reversed condition\"", ")", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR_UNLESS", ")", ")", ".", "addMBB", "(", "TBB", ")", ".", "add", "(", "Cond", "[", "1", "]", ")", ";", "}", "if", "(", "!", "FBB", ")", "return", "1", ";", "BuildMI", "(", "&", "MBB", ",", "DL", ",", "get", "(", "WebAssembly", "::", "BR", ")", ")", ".", "addMBB", "(", "FBB", ")", ";", "return", "2", ";", "}", "</s>" ]

[ "Insert", "branch", "code", "into", "the", "end", "of", "the", "specified", "MachineBasicBlock", "." ]

[ "WebAssembly", "WebAssembly", "\"code size not handled\"", "0", "WebAssembly::BR", "1", "2", "\"Expected a flag and a successor block\"", "1", "1", "WebAssembly::EXNREFRegClass", "0", "\"__cpp_exception\"", "WebAssembly::BR_ON_EXN", "1", "WebAssembly::BR_IF", "1", "\"br_on_exn does not have a reversed condition\"", "WebAssembly::BR_UNLESS", "1", "1", "WebAssembly::BR", "2" ]

[]

[ "<s>", "static", "MCSymbol", "*", "GetSymbolFromOperand", "(", "const", "MachineOperand", "&", "MO", ",", "AsmPrinter", "&", "AP", ")", "{", "MCContext", "&", "Ctx", "=", "AP", ".", "OutContext", ";", "SmallString", "<", "128", ">", "Name", ";", "if", "(", "!", "MO", ".", "isGlobal", "(", ")", ")", "{", "assert", "(", "MO", ".", "isSymbol", "(", ")", "&&", "\"Isn't a symbol reference\"", ")", ";", "Name", "+=", "AP", ".", "MAI", "->", "getGlobalPrefix", "(", ")", ";", "Name", "+=", "MO", ".", "getSymbolName", "(", ")", ";", "}", "else", "{", "const", "GlobalValue", "*", "GV", "=", "MO", ".", "getGlobal", "(", ")", ";", "bool", "isImplicitlyPrivate", "=", "false", ";", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "==", "PPCII", "::", "MO_DARWIN_STUB", "||", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_FLAG", ")", ")", "isImplicitlyPrivate", "=", "true", ";", "AP", ".", "Mang", "->", "getNameWithPrefix", "(", "Name", ",", "GV", ",", "isImplicitlyPrivate", ")", ";", "}", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "==", "PPCII", "::", "MO_DARWIN_STUB", ")", "{", "Name", "+=", "\"$stub\"", ";", "const", "char", "*", "PGP", "=", "AP", ".", "MAI", "->", "getPrivateGlobalPrefix", "(", ")", ";", "const", "char", "*", "Prefix", "=", "\"\"", ";", "if", "(", "!", "Name", ".", "startswith", "(", "PGP", ")", ")", "{", "Prefix", "=", "PGP", ";", "}", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "GetOrCreateSymbol", "(", "Twine", "(", "Prefix", ")", "+", "Twine", "(", "Name", ")", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "getMachOMMI", "(", "AP", ")", ".", "getFnStubEntry", "(", "Sym", ")", ";", "if", "(", "StubSym", ".", "getPointer", "(", ")", ")", "return", "Sym", ";", "if", "(", "MO", ".", "isGlobal", "(", ")", ")", "{", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "AP", ".", "Mang", "->", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "!", "MO", ".", "getGlobal", "(", ")", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "else", "{", "Name", ".", "erase", "(", "Name", ".", "end", "(", ")", "-", "5", ",", "Name", ".", "end", "(", ")", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "Ctx", ".", "GetOrCreateSymbol", "(", "Name", ".", "str", "(", ")", ")", ",", "false", ")", ";", "}", "return", "Sym", ";", "}", "if", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_FLAG", ")", "{", "Name", "+=", "\"$non_lazy_ptr\"", ";", "MCSymbol", "*", "Sym", "=", "Ctx", ".", "GetOrCreateSymbol", "(", "Name", ".", "str", "(", ")", ")", ";", "MachineModuleInfoMachO", "&", "MachO", "=", "getMachOMMI", "(", "AP", ")", ";", "MachineModuleInfoImpl", "::", "StubValueTy", "&", "StubSym", "=", "(", "MO", ".", "getTargetFlags", "(", ")", "&", "PPCII", "::", "MO_NLP_HIDDEN_FLAG", ")", "?", "MachO", ".", "getHiddenGVStubEntry", "(", "Sym", ")", ":", "MachO", ".", "getGVStubEntry", "(", "Sym", ")", ";", "if", "(", "StubSym", ".", "getPointer", "(", ")", "==", "0", ")", "{", "assert", "(", "MO", ".", "isGlobal", "(", ")", "&&", "\"Extern symbol not handled yet\"", ")", ";", "StubSym", "=", "MachineModuleInfoImpl", "::", "StubValueTy", "(", "AP", ".", "Mang", "->", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ",", "!", "MO", ".", "getGlobal", "(", ")", "->", "hasInternalLinkage", "(", ")", ")", ";", "}", "return", "Sym", ";", "}", "return", "Ctx", ".", "GetOrCreateSymbol", "(", "Name", ".", "str", "(", ")", ")", ";", "}", "</s>" ]

[ "Lower", "an", "MO_GlobalAddress", "or", "MO_ExternalSymbol", "operand", "to", "an", "MCSymbol", "." ]

[ "PowerPC", "128", "\"Isn't a symbol reference\"", "PPCII::MO_DARWIN_STUB", "PPCII::MO_NLP_FLAG", "PPCII::MO_DARWIN_STUB", "\"$stub\"", "\"\"", "5", "PPCII::MO_NLP_FLAG", "\"$non_lazy_ptr\"", "PPCII::MO_NLP_HIDDEN_FLAG", "0", "\"Extern symbol not handled yet\"" ]

[]

[ "<s>", "bool", "ARMAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "unsigned", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", ";", "MatchResult", "=", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ";", "switch", "(", "MatchResult", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "if", "(", "validateInstruction", "(", "Inst", ",", "Operands", ")", ")", "{", "forwardITPosition", "(", ")", ";", "return", "true", ";", "}", "while", "(", "processInstruction", "(", "Inst", ",", "Operands", ")", ")", ";", "forwardITPosition", "(", ")", ";", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "ARM", "::", "ITasm", ")", "return", "false", ";", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "Out", ".", "EmitInstruction", "(", "Inst", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "{", "assert", "(", "ErrorInfo", "&&", "\"Unknown missing feature!\"", ")", ";", "std", "::", "string", "Msg", "=", "\"instruction requires:\"", ";", "unsigned", "Mask", "=", "1", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "(", "sizeof", "(", "ErrorInfo", ")", "*", "8", "-", "1", ")", ";", "++", "i", ")", "{", "if", "(", "ErrorInfo", "&", "Mask", ")", "{", "Msg", "+=", "\" \"", ";", "Msg", "+=", "getSubtargetFeatureName", "(", "ErrorInfo", "&", "Mask", ")", ";", "}", "Mask", "<<=", "1", ";", "}", "return", "Error", "(", "IDLoc", ",", "Msg", ")", ";", "}", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", ",", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "0", "]", ")", "->", "getLocRange", "(", ")", ")", ";", "case", "Match_RequiresNotITBlock", ":", "return", "Error", "(", "IDLoc", ",", "\"flag setting instruction only valid outside IT block\"", ")", ";", "case", "Match_RequiresITBlock", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction only valid inside IT block\"", ")", ";", "case", "Match_RequiresV6", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction variant requires ARMv6 or later\"", ")", ";", "case", "Match_RequiresThumb2", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction variant requires Thumb2\"", ")", ";", "case", "Match_ImmRange0_4", ":", "{", "SMLoc", "ErrorLoc", "=", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "return", "Error", "(", "ErrorLoc", ",", "\"immediate operand must be in the range [0,4]\"", ")", ";", "}", "case", "Match_ImmRange0_15", ":", "{", "SMLoc", "ErrorLoc", "=", "(", "(", "ARMOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "return", "Error", "(", "ErrorLoc", ",", "\"immediate operand must be in the range [0,15]\"", ")", ";", "}", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

[ "MatchAndEmitInstruction", "-", "Recognize", "a", "series", "of", "operands", "of", "a", "parsed", "instruction", "as", "an", "actual", "MCInst", "and", "emit", "it", "to", "the", "specified", "MCStreamer", "." ]

[ "ARM", "ARM", "ARM::ITasm", "\"Unknown missing feature!\"", "\"instruction requires:\"", "1", "0", "8", "1", "\" \"", "1", "0U", "\"too few operands for instruction\"", "ARM", "\"invalid operand for instruction\"", "\"invalid instruction\"", "ARM", "0", "\"flag setting instruction only valid outside IT block\"", "\"instruction only valid inside IT block\"", "\"instruction variant requires ARMv6 or later\"", "\"instruction variant requires Thumb2\"", "ARM", "\"immediate operand must be in the range [0,4]\"", "ARM", "\"immediate operand must be in the range [0,15]\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "const", "RegisterBank", "&", "AArch64RegisterBankInfo", "::", "getRegBankFromRegClass", "(", "const", "TargetRegisterClass", "&", "RC", ")", "const", "{", "switch", "(", "RC", ".", "getID", "(", ")", ")", "{", "case", "AArch64", "::", "FPR8RegClassID", ":", "case", "AArch64", "::", "FPR16RegClassID", ":", "case", "AArch64", "::", "FPR32RegClassID", ":", "case", "AArch64", "::", "FPR64RegClassID", ":", "case", "AArch64", "::", "FPR128RegClassID", ":", "case", "AArch64", "::", "FPR128_loRegClassID", ":", "case", "AArch64", "::", "DDRegClassID", ":", "case", "AArch64", "::", "DDDRegClassID", ":", "case", "AArch64", "::", "DDDDRegClassID", ":", "case", "AArch64", "::", "QQRegClassID", ":", "case", "AArch64", "::", "QQQRegClassID", ":", "case", "AArch64", "::", "QQQQRegClassID", ":", "case", "AArch64", "::", "ZPRRegClassID", ":", "case", "AArch64", "::", "ZPR2RegClassID", ":", "case", "AArch64", "::", "ZPR3RegClassID", ":", "case", "AArch64", "::", "ZPR4RegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "FPRRegBankID", ")", ";", "case", "AArch64", "::", "GPR32commonRegClassID", ":", "case", "AArch64", "::", "GPR32RegClassID", ":", "case", "AArch64", "::", "GPR32spRegClassID", ":", "case", "AArch64", "::", "GPR32sponlyRegClassID", ":", "case", "AArch64", "::", "GPR32allRegClassID", ":", "case", "AArch64", "::", "GPR64commonRegClassID", ":", "case", "AArch64", "::", "GPR64RegClassID", ":", "case", "AArch64", "::", "GPR64spRegClassID", ":", "case", "AArch64", "::", "GPR64sponlyRegClassID", ":", "case", "AArch64", "::", "GPR64allRegClassID", ":", "case", "AArch64", "::", "tcGPR64RegClassID", ":", "case", "AArch64", "::", "WSeqPairsClassRegClassID", ":", "case", "AArch64", "::", "XSeqPairsClassRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "GPRRegBankID", ")", ";", "case", "AArch64", "::", "CCRRegClassID", ":", "return", "getRegBank", "(", "AArch64", "::", "CCRRegBankID", ")", ";", "default", ":", "llvm_unreachable", "(", "\"Register class not supported\"", ")", ";", "}", "}", "</s>" ]

[ "Get", "a", "register", "bank", "that", "covers", "RC", "." ]

[ "AArch64", "AArch64", "AArch64::FPR8RegClassID", "AArch64::FPR16RegClassID", "AArch64::FPR32RegClassID", "AArch64::FPR64RegClassID", "AArch64::FPR128RegClassID", "AArch64::FPR128_loRegClassID", "AArch64::DDRegClassID", "AArch64::DDDRegClassID", "AArch64::DDDDRegClassID", "AArch64::QQRegClassID", "AArch64::QQQRegClassID", "AArch64::QQQQRegClassID", "AArch64::ZPRRegClassID", "AArch64::ZPR2RegClassID", "AArch64::ZPR3RegClassID", "AArch64::ZPR4RegClassID", "AArch64::FPRRegBankID", "AArch64::GPR32commonRegClassID", "AArch64::GPR32RegClassID", "AArch64::GPR32spRegClassID", "AArch64::GPR32sponlyRegClassID", "AArch64::GPR32allRegClassID", "AArch64::GPR64commonRegClassID", "AArch64::GPR64RegClassID", "AArch64::GPR64spRegClassID", "AArch64::GPR64sponlyRegClassID", "AArch64::GPR64allRegClassID", "AArch64::tcGPR64RegClassID", "AArch64::WSeqPairsClassRegClassID", "AArch64::XSeqPairsClassRegClassID", "AArch64::GPRRegBankID", "AArch64::CCRRegClassID", "AArch64::CCRRegBankID", "\"Register class not supported\"" ]

[]

[ "<s>", "void", "MSP430InstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "if", "(", "!", "printAliasInstr", "(", "MI", ",", "O", ")", ")", "printInstruction", "(", "MI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

[ "Print", "the", "specified", "MCInst", "to", "the", "specified", "raw_ostream", "." ]

[ "MSP430", "MSP430" ]

[]

[ "<s>", "static", "int", "aarch64_build_constant", "(", "int", "regnum", ",", "HOST_WIDE_INT", "val", ",", "bool", "generate", ")", "{", "int", "insns", "=", "0", ";", "if", "(", "aarch64_bitmask_imm", "(", "val", ",", "DImode", ")", ")", "{", "if", "(", "generate", ")", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "regnum", ")", ",", "GEN_INT", "(", "val", ")", ")", ";", "insns", "=", "1", ";", "}", "else", "{", "int", "i", ";", "int", "ncount", "=", "0", ";", "int", "zcount", "=", "0", ";", "HOST_WIDE_INT", "valp", "=", "val", ">>", "16", ";", "HOST_WIDE_INT", "valm", ";", "HOST_WIDE_INT", "tval", ";", "for", "(", "i", "=", "16", ";", "i", "<", "64", ";", "i", "+=", "16", ")", "{", "valm", "=", "(", "valp", "&", "0xffff", ")", ";", "if", "(", "valm", "!=", "0", ")", "++", "zcount", ";", "if", "(", "valm", "!=", "0xffff", ")", "++", "ncount", ";", "valp", ">>=", "16", ";", "}", "if", "(", "ncount", "<", "zcount", ")", "{", "if", "(", "generate", ")", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "regnum", ")", ",", "GEN_INT", "(", "val", "|", "~", "(", "HOST_WIDE_INT", ")", "0xffff", ")", ")", ";", "tval", "=", "0xffff", ";", "insns", "++", ";", "}", "else", "{", "if", "(", "generate", ")", "emit_move_insn", "(", "gen_rtx_REG", "(", "Pmode", ",", "regnum", ")", ",", "GEN_INT", "(", "val", "&", "0xffff", ")", ")", ";", "tval", "=", "0", ";", "insns", "++", ";", "}", "val", ">>=", "16", ";", "for", "(", "i", "=", "16", ";", "i", "<", "64", ";", "i", "+=", "16", ")", "{", "if", "(", "(", "val", "&", "0xffff", ")", "!=", "tval", ")", "{", "if", "(", "generate", ")", "emit_insn", "(", "gen_insv_immdi", "(", "gen_rtx_REG", "(", "Pmode", ",", "regnum", ")", ",", "GEN_INT", "(", "i", ")", ",", "GEN_INT", "(", "val", "&", "0xffff", ")", ")", ")", ";", "insns", "++", ";", "}", "val", ">>=", "16", ";", "}", "}", "return", "insns", ";", "}", "</s>" ]

[ "Possibly", "output", "code", "to", "build", "up", "a", "constant", "in", "a", "register", ".", "For", "the", "benefit", "of", "the", "costs", "infrastructure", ",", "returns", "the", "number", "of", "instructions", "which", "would", "be", "emitted", ".", "GENERATE", "inhibits", "or", "enables", "code", "generation", "." ]

[ "aarch64", "0", "1", "0", "0", "16", "16", "64", "16", "0xffff", "0", "0xffff", "16", "0xffff", "0xffff", "0xffff", "0", "16", "16", "64", "16", "0xffff", "0xffff", "16" ]

[]

[ "<s>", "unsigned", "int", "LC2200AsmBackend", "::", "getNumFixupKinds", "(", ")", "const", "{", "return", "LC2200", "::", "Fixups", "::", "NumTargetFixupKinds", ";", "}", "</s>" ]

[ "Get", "the", "number", "of", "target", "specific", "fixup", "kinds", "." ]

[ "LC2200", "LC2200", "LC2200::Fixups" ]

[]

[ "<s>", "bool", "WebAssemblyAddMissingPrototypes", "::", "runOnModule", "(", "Module", "&", "M", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"runnning AddMissingPrototypes\\n\"", ")", ";", "std", "::", "vector", "<", "std", "::", "pair", "<", "Function", "*", ",", "Function", "*", ">>", "Replacements", ";", "for", "(", "Function", "&", "F", ":", "M", ")", "{", "if", "(", "!", "F", ".", "isDeclaration", "(", ")", "||", "!", "F", ".", "hasFnAttribute", "(", "\"no-prototype\"", ")", ")", "continue", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Found no-prototype function: \"", "<<", "F", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "!", "F", ".", "isVarArg", "(", ")", ")", "report_fatal_error", "(", "\"Functions with 'no-prototype' attribute must take varargs: \"", "+", "F", ".", "getName", "(", ")", ")", ";", "if", "(", "F", ".", "getFunctionType", "(", ")", "->", "getNumParams", "(", ")", "!=", "0", ")", "report_fatal_error", "(", "\"Functions with 'no-prototype' attribute should not have params: \"", "+", "F", ".", "getName", "(", ")", ")", ";", "FunctionType", "*", "NewType", "=", "nullptr", ";", "Function", "*", "NewF", "=", "nullptr", ";", "for", "(", "Use", "&", "U", ":", "F", ".", "uses", "(", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"prototype-less use: \"", "<<", "F", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "BitCastOperator", "*", "BC", "=", "dyn_cast", "<", "BitCastOperator", ">", "(", "U", ".", "getUser", "(", ")", ")", ")", "{", "FunctionType", "*", "DestType", "=", "cast", "<", "FunctionType", ">", "(", "BC", "->", "getDestTy", "(", ")", "->", "getPointerElementType", "(", ")", ")", ";", "NewType", "=", "DestType", ";", "NewF", "=", "Function", "::", "Create", "(", "NewType", ",", "F", ".", "getLinkage", "(", ")", ",", "F", ".", "getName", "(", ")", ")", ";", "NewF", "->", "setAttributes", "(", "F", ".", "getAttributes", "(", ")", ")", ";", "NewF", "->", "removeFnAttr", "(", "\"no-prototype\"", ")", ";", "break", ";", "}", "}", "if", "(", "!", "NewType", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"could not derive a function prototype from usage: \"", "+", "F", ".", "getName", "(", ")", "+", "\"\\n\"", ")", ";", "continue", ";", "}", "for", "(", "Use", "&", "U", ":", "F", ".", "uses", "(", ")", ")", "{", "if", "(", "BitCastOperator", "*", "BC", "=", "dyn_cast", "<", "BitCastOperator", ">", "(", "U", ".", "getUser", "(", ")", ")", ")", "{", "FunctionType", "*", "DestType", "=", "cast", "<", "FunctionType", ">", "(", "BC", "->", "getDestTy", "(", ")", "->", "getPointerElementType", "(", ")", ")", ";", "if", "(", "NewType", "!=", "DestType", ")", "{", "report_fatal_error", "(", "\"Prototypeless function used with conflicting signatures: \"", "+", "F", ".", "getName", "(", ")", ")", ";", "}", "BC", "->", "replaceAllUsesWith", "(", "NewF", ")", ";", "Replacements", ".", "emplace_back", "(", "&", "F", ",", "NewF", ")", ";", "}", "else", "{", "dbgs", "(", ")", "<<", "*", "U", ".", "getUser", "(", ")", "->", "getType", "(", ")", "<<", "\"\\n\"", ";", "U", ".", "getUser", "(", ")", "->", "dump", "(", ")", ";", "report_fatal_error", "(", "\"unexpected use of prototypeless function: \"", "+", "F", ".", "getName", "(", ")", "+", "\"\\n\"", ")", ";", "}", "}", "}", "for", "(", "auto", "&", "Pair", ":", "Replacements", ")", "{", "Function", "*", "Old", "=", "Pair", ".", "first", ";", "Function", "*", "New", "=", "Pair", ".", "second", ";", "Old", "->", "eraseFromParent", "(", ")", ";", "M", ".", "getFunctionList", "(", ")", ".", "push_back", "(", "New", ")", ";", "}", "return", "!", "Replacements", ".", "empty", "(", ")", ";", "}", "</s>" ]

[ "runOnModule", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "process", "the", "module", "being", "operated", "on", "." ]

[ "WebAssembly", "WebAssembly", "\"runnning AddMissingPrototypes\\n\"", "\"no-prototype\"", "\"Found no-prototype function: \"", "\"\\n\"", "\"Functions with 'no-prototype' attribute must take varargs: \"", "0", "\"Functions with 'no-prototype' attribute should not have params: \"", "\"prototype-less use: \"", "\"\\n\"", "\"no-prototype\"", "\"could not derive a function prototype from usage: \"", "\"\\n\"", "\"Prototypeless function used with conflicting signatures: \"", "\"\\n\"", "\"unexpected use of prototypeless function: \"", "\"\\n\"" ]

[]

[ "<s>", "static", "tree", "associated_type", "(", "tree", "decl", ")", "{", "return", "(", "DECL_CONTEXT", "(", "decl", ")", "&&", "TYPE_P", "(", "DECL_CONTEXT", "(", "decl", ")", ")", "?", "DECL_CONTEXT", "(", "decl", ")", ":", "NULL_TREE", ")", ";", "}", "</s>" ]

[ "Return", "the", "type", "that", "we", "should", "use", "to", "determine", "if", "DECL", "is", "imported", "or", "exported", "." ]

[ "i386" ]

[]

[ "<s>", "static", "void", "arm_print_asm_arch_directives", "(", "FILE", "*", "stream", ",", "cl_target_option", "*", "targ_options", ")", "{", "arm_build_target", "build_target", ";", "if", "(", "last_asm_targ_options", "==", "targ_options", ")", "return", ";", "last_asm_targ_options", "=", "targ_options", ";", "build_target", ".", "isa", "=", "sbitmap_alloc", "(", "isa_num_bits", ")", ";", "arm_configure_build_target", "(", "&", "build_target", ",", "targ_options", ",", "false", ")", ";", "if", "(", "build_target", ".", "core_name", "&&", "!", "bitmap_bit_p", "(", "build_target", ".", "isa", ",", "isa_bit_quirk_no_asmcpu", ")", ")", "{", "const", "char", "*", "truncated_name", "=", "arm_rewrite_selected_cpu", "(", "build_target", ".", "core_name", ")", ";", "asm_fprintf", "(", "stream", ",", "\"\\t.cpu %s\\n\"", ",", "truncated_name", ")", ";", "}", "const", "arch_option", "*", "arch", "=", "arm_parse_arch_option_name", "(", "all_architectures", ",", "\"-march\"", ",", "build_target", ".", "arch_name", ")", ";", "auto_sbitmap", "opt_bits", "(", "isa_num_bits", ")", ";", "gcc_assert", "(", "arch", ")", ";", "if", "(", "strcmp", "(", "build_target", ".", "arch_name", ",", "\"armv7ve\"", ")", "==", "0", ")", "{", "asm_fprintf", "(", "stream", ",", "\"\\t.arch armv7-a\\n\"", ")", ";", "asm_fprintf", "(", "stream", ",", "\"\\t.arch_extension virt\\n\"", ")", ";", "asm_fprintf", "(", "stream", ",", "\"\\t.arch_extension idiv\\n\"", ")", ";", "asm_fprintf", "(", "stream", ",", "\"\\t.arch_extension sec\\n\"", ")", ";", "asm_fprintf", "(", "stream", ",", "\"\\t.arch_extension mp\\n\"", ")", ";", "}", "else", "asm_fprintf", "(", "stream", ",", "\"\\t.arch %s\\n\"", ",", "build_target", ".", "arch_name", ")", ";", "const", "char", "*", "fpu_name", "=", "(", "TARGET_SOFT_FLOAT", "?", "\"softvfp\"", ":", "arm_identify_fpu_from_isa", "(", "build_target", ".", "isa", ")", ")", ";", "asm_fprintf", "(", "stream", ",", "\"\\t.fpu %s\\n\"", ",", "fpu_name", ")", ";", "if", "(", "!", "arch", "->", "common", ".", "extensions", ")", "return", ";", "for", "(", "const", "struct", "cpu_arch_extension", "*", "opt", "=", "arch", "->", "common", ".", "extensions", ";", "opt", "->", "name", "!=", "NULL", ";", "opt", "++", ")", "{", "if", "(", "!", "opt", "->", "remove", ")", "{", "arm_initialize_isa", "(", "opt_bits", ",", "opt", "->", "isa_bits", ")", ";", "if", "(", "(", "bitmap_bit_p", "(", "opt_bits", ",", "isa_bit_mve", ")", "&&", "!", "TARGET_HAVE_MVE", ")", "||", "(", "bitmap_bit_p", "(", "opt_bits", ",", "isa_bit_mve_float", ")", "&&", "!", "TARGET_HAVE_MVE_FLOAT", ")", ")", "continue", ";", "if", "(", "bitmap_subset_p", "(", "opt_bits", ",", "build_target", ".", "isa", ")", "&&", "!", "bitmap_subset_p", "(", "opt_bits", ",", "isa_all_fpubits_internal", ")", ")", "asm_fprintf", "(", "stream", ",", "\"\\t.arch_extension %s\\n\"", ",", "opt", "->", "name", ")", ";", "}", "}", "}", "</s>" ]

[ "Print", ".arch", "and", ".arch_extension", "directives", "corresponding", "to", "the", "current", "architecture", "configuration", "." ]

[ "arm", "\"\\t.cpu %s\\n\"", "\"-march\"", "\"armv7ve\"", "0", "\"\\t.arch armv7-a\\n\"", "\"\\t.arch_extension virt\\n\"", "\"\\t.arch_extension idiv\\n\"", "\"\\t.arch_extension sec\\n\"", "\"\\t.arch_extension mp\\n\"", "\"\\t.arch %s\\n\"", "\"softvfp\"", "\"\\t.fpu %s\\n\"", "\"\\t.arch_extension %s\\n\"" ]

[]

[ "<s>", "void", "PPCPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "initializePPCVSXFMAMutatePass", "(", "*", "PassRegistry", "::", "getPassRegistry", "(", ")", ")", ";", "insertPass", "(", "VSXFMAMutateEarly", "?", "&", "RegisterCoalescerID", ":", "&", "MachineSchedulerID", ",", "&", "PPCVSXFMAMutateID", ")", ";", "if", "(", "getPPCTargetMachine", "(", ")", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "addPass", "(", "createPPCTLSDynamicCallPass", "(", ")", ")", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "immediately", "before", "register", "allocation", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC" ]

[]

[ "<s>", "bool", "PPCFrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "!", "Subtarget", ".", "isSVR4ABI", "(", ")", ")", "return", "false", ";", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "const", "PPCInstrInfo", "&", "TII", "=", "*", "Subtarget", ".", "getInstrInfo", "(", ")", ";", "PPCFunctionInfo", "*", "FI", "=", "MF", "->", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "bool", "MustSaveTOC", "=", "FI", "->", "mustSaveTOC", "(", ")", ";", "bool", "CR2Spilled", "=", "false", ";", "bool", "CR3Spilled", "=", "false", ";", "bool", "CR4Spilled", "=", "false", ";", "unsigned", "CSIIndex", "=", "0", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MI", ",", "BeforeI", "=", "I", ";", "bool", "AtStart", "=", "I", "==", "MBB", ".", "begin", "(", ")", ";", "if", "(", "!", "AtStart", ")", "--", "BeforeI", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CSI", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "if", "(", "Reg", "==", "PPC", "::", "VRSAVE", ")", "continue", ";", "if", "(", "(", "Reg", "==", "PPC", "::", "X2", "||", "Reg", "==", "PPC", "::", "R2", ")", "&&", "MustSaveTOC", ")", "continue", ";", "if", "(", "Reg", "==", "PPC", "::", "CR2", ")", "{", "CR2Spilled", "=", "true", ";", "CSIIndex", "=", "i", ";", "continue", ";", "}", "else", "if", "(", "Reg", "==", "PPC", "::", "CR3", ")", "{", "CR3Spilled", "=", "true", ";", "continue", ";", "}", "else", "if", "(", "Reg", "==", "PPC", "::", "CR4", ")", "{", "CR4Spilled", "=", "true", ";", "continue", ";", "}", "else", "{", "if", "(", "(", "CR2Spilled", "||", "CR3Spilled", "||", "CR4Spilled", ")", "&&", "!", "(", "PPC", "::", "CR2", "<=", "Reg", "&&", "Reg", "<=", "PPC", "::", "CR4", ")", ")", "{", "bool", "is31", "=", "needsFP", "(", "*", "MF", ")", ";", "restoreCRs", "(", "Subtarget", ".", "isPPC64", "(", ")", ",", "is31", ",", "CR2Spilled", ",", "CR3Spilled", ",", "CR4Spilled", ",", "MBB", ",", "I", ",", "CSI", ",", "CSIIndex", ")", ";", "CR2Spilled", "=", "CR3Spilled", "=", "CR4Spilled", "=", "false", ";", "}", "if", "(", "CSI", "[", "i", "]", ".", "isSpilledToReg", "(", ")", ")", "{", "DebugLoc", "DL", ";", "NumPEReloadVSR", "++", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "TII", ".", "get", "(", "PPC", "::", "MFVSRD", ")", ",", "Reg", ")", ".", "addReg", "(", "CSI", "[", "i", "]", ".", "getDstReg", "(", ")", ",", "getKillRegState", "(", "true", ")", ")", ";", "}", "else", "{", "const", "TargetRegisterClass", "*", "RC", "=", "TRI", "->", "getMinimalPhysRegClass", "(", "Reg", ")", ";", "TII", ".", "loadRegFromStackSlot", "(", "MBB", ",", "I", ",", "Reg", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "RC", ",", "TRI", ")", ";", "assert", "(", "I", "!=", "MBB", ".", "begin", "(", ")", "&&", "\"loadRegFromStackSlot didn't insert any code!\"", ")", ";", "}", "}", "if", "(", "AtStart", ")", "I", "=", "MBB", ".", "begin", "(", ")", ";", "else", "{", "I", "=", "BeforeI", ";", "++", "I", ";", "}", "}", "if", "(", "CR2Spilled", "||", "CR3Spilled", "||", "CR4Spilled", ")", "{", "bool", "is31", "=", "needsFP", "(", "*", "MF", ")", ";", "restoreCRs", "(", "Subtarget", ".", "isPPC64", "(", ")", ",", "is31", ",", "CR2Spilled", ",", "CR3Spilled", ",", "CR4Spilled", ",", "MBB", ",", "I", ",", "CSI", ",", "CSIIndex", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "restoreCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "restore", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "load", "instructions", "via", "loadRegToStackSlot", "(", ")", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "0", "0", "PPC::VRSAVE", "PPC::X2", "PPC::R2", "PPC::CR2", "PPC::CR3", "PPC::CR4", "PPC::CR2", "PPC::CR4", "PPC", "PPC::MFVSRD", "\"loadRegFromStackSlot didn't insert any code!\"", "PPC" ]

[]

[ "<s>", "bool", "AMDGPUTargetLowering", "::", "ShouldShrinkFPConstant", "(", "EVT", "VT", ")", "const", "{", "if", "(", "VT", ".", "getScalarType", "(", ")", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", "==", "MVT", "::", "f32", "||", "VT", ".", "getScalarType", "(", ")", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", "==", "MVT", "::", "f64", ")", "{", "return", "false", ";", "}", "else", "{", "return", "true", ";", "}", "}", "</s>" ]

[ "If", "true", ",", "then", "instruction", "selection", "should", "seek", "to", "shrink", "the", "FP", "constant", "of", "the", "specified", "type", "to", "a", "smaller", "type", "in", "order", "to", "save", "space", "and", "/", "or", "reduce", "runtime", "." ]

[ "R600", "MVT::f32", "MVT::f64" ]

[]

[ "<s>", "rtx", "mips_return_addr", "(", "int", "count", ",", "rtx", "frame", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "count", "!=", "0", ")", "return", "const0_rtx", ";", "return", "get_hard_reg_initial_val", "(", "Pmode", ",", "RETURN_ADDR_REGNUM", ")", ";", "}", "</s>" ]

[ "Implement", "RETURN_ADDR_RTX", ".", "Note", ",", "we", "do", "not", "support", "moving", "back", "to", "a", "previous", "frame", "." ]

[ "mips", "0" ]

[]

[ "<s>", "CCAssignFn", "*", "ARM64TargetLowering", "::", "CCAssignFnForCall", "(", "CallingConv", "::", "ID", "CC", ",", "bool", "IsVarArg", ")", "const", "{", "switch", "(", "CC", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention.\"", ")", ";", "case", "CallingConv", "::", "WebKit_JS", ":", "return", "CC_ARM64_WebKit_JS", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "if", "(", "!", "Subtarget", "->", "isTargetDarwin", "(", ")", ")", "return", "CC_ARM64_AAPCS", ";", "return", "IsVarArg", "?", "CC_ARM64_DarwinPCS_VarArg", ":", "CC_ARM64_DarwinPCS", ";", "}", "}", "</s>" ]

[ "Selects", "the", "correct", "CCAssignFn", "for", "a", "given", "CallingConvention", "value", "." ]

[ "ARM64", "ARM64", "\"Unsupported calling convention.\"", "ARM64", "ARM64", "ARM64", "ARM64" ]

[]

[ "<s>", "FastISel", "*", "X86", "::", "createFastISel", "(", "FunctionLoweringInfo", "&", "funcInfo", ",", "const", "TargetLibraryInfo", "*", "libInfo", ")", "{", "return", "new", "X86FastISel", "(", "funcInfo", ",", "libInfo", ")", ";", "}", "</s>" ]

[ "This", "method", "returns", "a", "target", "specific", "FastISel", "object", ",", "or", "null", "if", "the", "target", "does", "not", "support", "``", "fast", "''", "ISel", "." ]

[ "X86", "X86::createFastISel", "X86" ]

[]

[ "<s>", "static", "bool", "get_unit_operand_masks", "(", "rtx_insn", "*", "insn", ",", "unsigned", "int", "*", "pmask1", ",", "unsigned", "int", "*", "pmask2", ")", "{", "enum", "attr_op_pattern", "op_pat", ";", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "COND_EXEC", ")", "return", "false", ";", "extract_insn", "(", "insn", ")", ";", "op_pat", "=", "get_attr_op_pattern", "(", "insn", ")", ";", "if", "(", "op_pat", "==", "OP_PATTERN_DT", ")", "{", "gcc_assert", "(", "recog_data", ".", "n_operands", "==", "2", ")", ";", "*", "pmask1", "=", "1", "<<", "0", ";", "*", "pmask2", "=", "1", "<<", "1", ";", "return", "true", ";", "}", "else", "if", "(", "op_pat", "==", "OP_PATTERN_TD", ")", "{", "gcc_assert", "(", "recog_data", ".", "n_operands", "==", "2", ")", ";", "*", "pmask1", "=", "1", "<<", "1", ";", "*", "pmask2", "=", "1", "<<", "0", ";", "return", "true", ";", "}", "else", "if", "(", "op_pat", "==", "OP_PATTERN_SXS", ")", "{", "gcc_assert", "(", "recog_data", ".", "n_operands", "==", "3", ")", ";", "*", "pmask1", "=", "(", "1", "<<", "0", ")", "|", "(", "1", "<<", "2", ")", ";", "*", "pmask2", "=", "1", "<<", "1", ";", "return", "true", ";", "}", "else", "if", "(", "op_pat", "==", "OP_PATTERN_SX", ")", "{", "gcc_assert", "(", "recog_data", ".", "n_operands", "==", "2", ")", ";", "*", "pmask1", "=", "1", "<<", "0", ";", "*", "pmask2", "=", "1", "<<", "1", ";", "return", "true", ";", "}", "else", "if", "(", "op_pat", "==", "OP_PATTERN_SSX", ")", "{", "gcc_assert", "(", "recog_data", ".", "n_operands", "==", "3", ")", ";", "*", "pmask1", "=", "(", "1", "<<", "0", ")", "|", "(", "1", "<<", "1", ")", ";", "*", "pmask2", "=", "1", "<<", "2", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Examine", "INSN", ",", "and", "store", "in", "PMASK1", "and", "PMASK2", "bitmasks", "that", "represent", "the", "operands", "that", "are", "involved", "in", "the", "(", "up", "to", ")", "two", "reservations", ",", "as", "found", "by", "get_unit_reqs", ".", "Return", "true", "if", "we", "did", "this", "successfully", ",", "false", "if", "we", "could", "n't", "identify", "what", "to", "do", "with", "INSN", "." ]

[ "c6x", "0", "0", "2", "1", "0", "1", "1", "2", "1", "1", "1", "0", "3", "1", "0", "1", "2", "1", "1", "2", "1", "0", "1", "1", "3", "1", "0", "1", "1", "1", "2" ]

[]

[ "<s>", "void", "WebAssemblyTargetELFStreamer", "::", "emitIndIdx", "(", "const", "MCExpr", "*", "Value", ")", "{", "Streamer", ".", "EmitIntValue", "(", "WebAssembly", "::", "DotIndIdx", ",", "sizeof", "(", "uint64_t", ")", ")", ";", "Streamer", ".", "EmitValue", "(", "Value", ",", "sizeof", "(", "uint64_t", ")", ")", ";", "}", "</s>" ]

[ ".indidx" ]

[ "WebAssembly", "WebAssembly", "WebAssembly::DotIndIdx" ]

[]

[ "<s>", "RegisterSet", "&", "insert", "(", "const", "RegisterSet", "&", "Rs", ")", "{", "return", "static_cast", "<", "RegisterSet", "&", ">", "(", "BitVector", "::", "operator", "|=", "(", "Rs", ")", ")", ";", "}", "</s>" ]

[ "insert", "-", "Append", "entry", "to", "the", "vector", "if", "it", "does", "n't", "already", "exist", "." ]

[ "Hexagon" ]

[]

[ "<s>", "static", "void", "epiphany_function_arg_advance", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "*", "cum", "=", "(", "ROUND_ADVANCE_CUM", "(", "*", "cum", ",", "arg", ".", "mode", ",", "arg", ".", "type", ")", "+", "ROUND_ADVANCE_ARG", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ")", ";", "}", "</s>" ]

[ "Update", "the", "data", "in", "CUM", "to", "advance", "over", "an", "argument", "of", "mode", "MODE", "and", "data", "type", "TYPE", ".", "(", "TYPE", "is", "null", "for", "libcalls", "where", "that", "information", "may", "not", "be", "available", ".", ")" ]

[ "epiphany" ]

[]

[ "<s>", "void", "addLOHDirective", "(", "MCLOHType", "Kind", ",", "MILOHArgs", "Args", ")", "{", "LOHContainerSet", ".", "push_back", "(", "MILOHDirective", "(", "Kind", ",", "Args", ")", ")", ";", "LOHRelated", ".", "insert", "(", "Args", ".", "begin", "(", ")", ",", "Args", ".", "end", "(", ")", ")", ";", "}", "</s>" ]

[ "Add", "a", "LOH", "directive", "of", "this", "Kind", "and", "this", "Args", "." ]

[ "AArch64" ]

[]

[ "<s>", "static", "bool", "tilepro_tls_referenced_p", "(", "rtx", "x", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", ")", "x", "=", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "contains", "a", "thread-local", "symbol", "." ]

[ "tilepro", "0", "0", "0" ]

[]

[ "<s>", "PPCSubtarget", "&", "PPCSubtarget", "::", "initializeSubtargetDependencies", "(", "StringRef", "CPU", ",", "StringRef", "FS", ")", "{", "initializeEnvironment", "(", ")", ";", "resetSubtargetFeatures", "(", "CPU", ",", "FS", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

[ "initializeSubtargetDependencies", "-", "Initializes", "using", "a", "CPU", ",", "a", "TuneCPU", ",", "and", "feature", "string", "so", "that", "we", "can", "use", "initializer", "lists", "for", "subtarget", "initialization", "." ]

[ "PowerPC", "PPC", "PPC" ]

[]

[ "<s>", "void", "RISCVTargetStreamer", "::", "finish", "(", ")", "{", "finishAttributeSection", "(", ")", ";", "}", "</s>" ]

[ "finish", "-", "after", "all", "the", "new", "live", "ranges", "have", "been", "created", ",", "compute", "the", "remaining", "live", "range", ",", "and", "rewrite", "instructions", "to", "use", "the", "new", "registers", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "unsigned", "getGlobalBaseReg", "(", ")", "const", "{", "return", "GlobalBaseReg", ";", "}", "</s>" ]

[ "getGlobalBaseReg", "-", "Return", "a", "virtual", "register", "initialized", "with", "the", "the", "global", "base", "register", "value", "." ]

[ "X86" ]

[]

[ "<s>", "static", "int", "ix86_fp_comparison_fcomi_cost", "(", "enum", "rtx_code", "code", ")", "{", "enum", "rtx_code", "bypass_code", ",", "first_code", ",", "second_code", ";", "if", "(", "!", "TARGET_CMOVE", ")", "return", "1024", ";", "ix86_fp_comparison_codes", "(", "code", ",", "&", "bypass_code", ",", "&", "first_code", ",", "&", "second_code", ")", ";", "return", "(", "bypass_code", "!=", "UNKNOWN", "||", "second_code", "!=", "UNKNOWN", ")", "+", "2", ";", "}", "</s>" ]

[ "Return", "cost", "of", "comparison", "done", "using", "fcomi", "operation", ".", "See", "ix86_fp_comparison_arithmetics_cost", "for", "the", "metrics", "." ]

[ "i386", "1024", "2" ]

[]

[ "<s>", "bool", "VideocoreDAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "SDValue", "Op0", ",", "Op1", ";", "switch", "(", "ConstraintCode", ")", "{", "default", ":", "return", "true", ";", "case", "'m'", ":", "if", "(", "!", "SelectADDRrr", "(", "Op", ",", "Op0", ",", "Op1", ")", ")", "SelectADDRri", "(", "Op", ",", "Op0", ",", "Op1", ")", ";", "break", ";", "}", "OutOps", ".", "push_back", "(", "Op0", ")", ";", "OutOps", ".", "push_back", "(", "Op1", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "SelectInlineAsmMemoryOperand", "-", "Select", "the", "specified", "address", "as", "a", "target", "addressing", "mode", ",", "according", "to", "the", "specified", "constraint", "." ]

[ "Videocore", "Videocore" ]

[]

[ "<s>", "int", "thumb_legitimate_offset_p", "(", "enum", "machine_mode", "mode", ",", "HOST_WIDE_INT", "val", ")", "{", "switch", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", "{", "case", "1", ":", "return", "val", ">=", "0", "&&", "val", "<", "32", ";", "case", "2", ":", "return", "val", ">=", "0", "&&", "val", "<", "64", "&&", "(", "val", "&", "1", ")", "==", "0", ";", "default", ":", "return", "(", "val", ">=", "0", "&&", "(", "val", "+", "GET_MODE_SIZE", "(", "mode", ")", ")", "<=", "128", "&&", "(", "val", "&", "3", ")", "==", "0", ")", ";", "}", "}", "</s>" ]

[ "Return", "nonzero", "if", "VAL", "can", "be", "used", "as", "an", "offset", "in", "a", "Thumb-state", "address", "instruction", "of", "mode", "MODE", "." ]

[ "arm", "1", "0", "32", "2", "0", "64", "1", "0", "0", "128", "3", "0" ]

[]

[ "<s>", "bool", "ARMRegisterInfo", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "NoFramePointerElim", "||", "MFI", "->", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

[ "hasFP", "-", "Return", "true", "if", "the", "specified", "function", "should", "have", "a", "dedicated", "frame", "pointer", "register", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "static", "void", "riscv_for_each_saved_reg", "(", "HOST_WIDE_INT", "sp_offset", ",", "riscv_save_restore_fn", "fn", ")", "{", "HOST_WIDE_INT", "offset", ";", "offset", "=", "cfun", "->", "machine", "->", "frame", ".", "gp_sp_offset", "-", "sp_offset", ";", "for", "(", "int", "regno", "=", "GP_REG_FIRST", ";", "regno", "<=", "GP_REG_LAST", ";", "regno", "++", ")", "if", "(", "BITSET_P", "(", "cfun", "->", "machine", "->", "frame", ".", "mask", ",", "regno", "-", "GP_REG_FIRST", ")", ")", "{", "riscv_save_restore_reg", "(", "word_mode", ",", "regno", ",", "offset", ",", "fn", ")", ";", "offset", "-=", "UNITS_PER_WORD", ";", "}", "offset", "=", "cfun", "->", "machine", "->", "frame", ".", "fp_sp_offset", "-", "sp_offset", ";", "for", "(", "int", "regno", "=", "FP_REG_FIRST", ";", "regno", "<=", "FP_REG_LAST", ";", "regno", "++", ")", "if", "(", "BITSET_P", "(", "cfun", "->", "machine", "->", "frame", ".", "fmask", ",", "regno", "-", "FP_REG_FIRST", ")", ")", "{", "machine_mode", "mode", "=", "TARGET_DOUBLE_FLOAT", "?", "DFmode", ":", "SFmode", ";", "riscv_save_restore_reg", "(", "mode", ",", "regno", ",", "offset", ",", "fn", ")", ";", "offset", "-=", "GET_MODE_SIZE", "(", "mode", ")", ";", "}", "}", "</s>" ]

[ "Call", "FN", "for", "each", "register", "that", "is", "saved", "by", "the", "current", "function", ".", "SP_OFFSET", "is", "the", "offset", "of", "the", "current", "stack", "pointer", "from", "the", "start", "of", "the", "frame", "." ]

[ "riscv" ]

[]

[ "<s>", "int", "X86TTIImpl", "::", "getIntrinsicInstrCost", "(", "Intrinsic", "::", "ID", "IID", ",", "Type", "*", "RetTy", ",", "ArrayRef", "<", "Value", "*", ">", "Args", ",", "FastMathFlags", "FMF", ")", "{", "return", "BaseT", "::", "getIntrinsicInstrCost", "(", "IID", ",", "RetTy", ",", "Args", ",", "FMF", ")", ";", "}", "</s>" ]

[ "Get", "intrinsic", "cost", "based", "on", "arguments", "." ]

[ "X86", "X86", "Intrinsic::ID" ]

[]

[ "<s>", "static", "rtx", "c6x_function_arg", "(", "cumulative_args_t", "cum_v", ",", "const", "function_arg_info", "&", "arg", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "if", "(", "cum", "->", "count", ">=", "cum", "->", "nregs", ")", "return", "NULL_RTX", ";", "if", "(", "tree", "type", "=", "arg", ".", "type", ")", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "TARGET_BIG_ENDIAN", "&&", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "{", "if", "(", "size", ">", "4", ")", "{", "rtx", "reg1", "=", "gen_rtx_REG", "(", "SImode", ",", "argument_registers", "[", "cum", "->", "count", "]", "+", "1", ")", ";", "rtx", "reg2", "=", "gen_rtx_REG", "(", "SImode", ",", "argument_registers", "[", "cum", "->", "count", "]", ")", ";", "rtvec", "vec", "=", "gen_rtvec", "(", "2", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg1", ",", "const0_rtx", ")", ",", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg2", ",", "GEN_INT", "(", "4", ")", ")", ")", ";", "return", "gen_rtx_PARALLEL", "(", "arg", ".", "mode", ",", "vec", ")", ";", "}", "}", "}", "return", "gen_rtx_REG", "(", "arg", ".", "mode", ",", "argument_registers", "[", "cum", "->", "count", "]", ")", ";", "}", "</s>" ]

[ "Implements", "the", "macro", "FUNCTION_ARG", "defined", "in", "c6x.h", "." ]

[ "c6x", "4", "1", "2", "4" ]

[]

[ "<s>", "bool", "contains", "(", "int32_t", "V", ")", "const", "{", "return", "Min", "<=", "V", "&&", "V", "<=", "Max", "&&", "(", "V", "%", "Align", ")", "==", "0", ";", "}", "</s>" ]

[ "contains", "-", "Returns", "true", "if", "this", "trace", "contains", "the", "given", "basic", "block", "." ]

[ "Hexagon", "0" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"WebAssembly Optimize Returned\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "WebAssembly", "\"WebAssembly Optimize Returned\"" ]

[]

[ "<s>", "SMRange", "getLocRange", "(", ")", "const", "{", "return", "SMRange", "(", "StartLoc", ",", "EndLoc", ")", ";", "}", "</s>" ]

[ "getLocRange", "-", "Get", "the", "range", "between", "the", "first", "and", "last", "token", "of", "this", "operand", "." ]

[ "SystemZ" ]

[]

[ "<s>", "static", "void", "arm_print_value", "(", "FILE", "*", "f", ",", "rtx", "x", ")", "{", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST_INT", ":", "fprintf", "(", "f", ",", "HOST_WIDE_INT_PRINT_HEX", ",", "INTVAL", "(", "x", ")", ")", ";", "return", ";", "case", "CONST_DOUBLE", ":", "{", "char", "fpstr", "[", "20", "]", ";", "real_to_decimal", "(", "fpstr", ",", "CONST_DOUBLE_REAL_VALUE", "(", "x", ")", ",", "sizeof", "(", "fpstr", ")", ",", "0", ",", "1", ")", ";", "fputs", "(", "fpstr", ",", "f", ")", ";", "}", "return", ";", "case", "CONST_VECTOR", ":", "{", "int", "i", ";", "fprintf", "(", "f", ",", "\"<\"", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "CONST_VECTOR_NUNITS", "(", "x", ")", ";", "i", "++", ")", "{", "fprintf", "(", "f", ",", "HOST_WIDE_INT_PRINT_HEX", ",", "INTVAL", "(", "CONST_VECTOR_ELT", "(", "x", ",", "i", ")", ")", ")", ";", "if", "(", "i", "<", "(", "CONST_VECTOR_NUNITS", "(", "x", ")", "-", "1", ")", ")", "fputc", "(", "','", ",", "f", ")", ";", "}", "fprintf", "(", "f", ",", "\">\"", ")", ";", "}", "return", ";", "case", "CONST_STRING", ":", "fprintf", "(", "f", ",", "\"\\\"%s\\\"\"", ",", "XSTR", "(", "x", ",", "0", ")", ")", ";", "return", ";", "case", "SYMBOL_REF", ":", "fprintf", "(", "f", ",", "\"`%s'\"", ",", "XSTR", "(", "x", ",", "0", ")", ")", ";", "return", ";", "case", "LABEL_REF", ":", "fprintf", "(", "f", ",", "\"L%d\"", ",", "INSN_UID", "(", "XEXP", "(", "x", ",", "0", ")", ")", ")", ";", "return", ";", "case", "CONST", ":", "arm_print_value", "(", "f", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "return", ";", "case", "PLUS", ":", "arm_print_value", "(", "f", ",", "XEXP", "(", "x", ",", "0", ")", ")", ";", "fprintf", "(", "f", ",", "\"+\"", ")", ";", "arm_print_value", "(", "f", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "return", ";", "case", "PC", ":", "fprintf", "(", "f", ",", "\"pc\"", ")", ";", "return", ";", "default", ":", "fprintf", "(", "f", ",", "\"????\"", ")", ";", "return", ";", "}", "}", "</s>" ]

[ "Print", "a", "symbolic", "form", "of", "X", "to", "the", "debug", "file", ",", "F", "." ]

[ "arm", "20", "0", "1", "\"<\"", "0", "1", "\">\"", "\"\\\"%s\\\"\"", "0", "\"`%s'\"", "0", "\"L%d\"", "0", "0", "0", "\"+\"", "1", "\"pc\"", "\"????\"" ]

[]

[ "<s>", "void", "AMDGPUAsmPrinter", "::", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "{", "AU", ".", "addRequired", "<", "AMDGPUResourceUsageAnalysis", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "AMDGPUResourceUsageAnalysis", ">", "(", ")", ";", "AsmPrinter", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

[ "getAnalysisUsage", "-", "Subclasses", "that", "override", "getAnalysisUsage", "must", "call", "this", "." ]

[ "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "addr_space_t", "nvptx_addr_space_from_address", "(", "rtx", "addr", ")", "{", "while", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "||", "GET_CODE", "(", "addr", ")", "==", "CONST", ")", "addr", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "addr", ")", "!=", "SYMBOL_REF", ")", "return", "ADDR_SPACE_GENERIC", ";", "tree", "decl", "=", "SYMBOL_REF_DECL", "(", "addr", ")", ";", "if", "(", "decl", "==", "NULL_TREE", "||", "TREE_CODE", "(", "decl", ")", "==", "FUNCTION_DECL", ")", "return", "ADDR_SPACE_GENERIC", ";", "bool", "is_const", "=", "(", "CONSTANT_CLASS_P", "(", "decl", ")", "||", "TREE_CODE", "(", "decl", ")", "==", "CONST_DECL", "||", "TREE_READONLY", "(", "decl", ")", ")", ";", "if", "(", "is_const", ")", "return", "ADDR_SPACE_CONST", ";", "return", "ADDR_SPACE_GLOBAL", ";", "}", "</s>" ]

[ "Look", "for", "a", "SYMBOL_REF", "in", "ADDR", "and", "return", "the", "address", "space", "to", "be", "used", "for", "the", "insn", "referencing", "this", "address", "." ]

[ "nvptx", "0" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Z80old Machine Late Optimization\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "Z80old", "\"Z80old Machine Late Optimization\"" ]

[]

[ "<s>", "bool", "fixupNeedsRelaxation", "(", "const", "MCFixup", "&", "Fixup", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

[ "Simple", "predicate", "for", "targets", "where", "!", "Resolved", "implies", "requiring", "relaxation", "." ]

[ "BPF" ]

[]

[ "<s>", "bool", "M680x0FrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "auto", "&", "MRI", "=", "*", "static_cast", "<", "const", "M680x0RegisterInfo", "*", ">", "(", "TRI", ")", ";", "auto", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "int", "FI", "=", "0", ";", "unsigned", "Mask", "=", "0", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "{", "FI", "=", "std", "::", "max", "(", "FI", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ")", ";", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "unsigned", "Shift", "=", "MRI", ".", "getSpillRegisterOrder", "(", "Reg", ")", ";", "Mask", "|=", "1", "<<", "Shift", ";", "}", "auto", "I", "=", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "M680x0", "::", "MOVM32pm", ")", ")", ",", "FI", ")", ".", "addImm", "(", "Mask", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "const", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "MachineRegisterInfo", "&", "RI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "for", "(", "size_t", "i", "=", "0", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "bool", "isLiveIn", "=", "RI", ".", "isLiveIn", "(", "Reg", ")", ";", "if", "(", "!", "isLiveIn", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "I", ".", "addReg", "(", "Reg", ",", "isLiveIn", "?", "RegState", "::", "Implicit", ":", "RegState", "::", "ImplicitKill", ")", ";", "addMemOperand", "(", "I", ",", "CSI", "[", "i", "]", ".", "getFrameIdx", "(", ")", ",", "0", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "spillCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "spill", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "store", "instructions", "via", "storeRegToStackSlot", "(", ")", "." ]

[ "M680x0", "M680x0", "M680x0", "0", "0", "0", "1", "M680x0::MOVM32pm", "0", "0" ]

[]

[ "<s>", "void", "epiphany_init_expanders", "(", "void", ")", "{", "init_machine_status", "=", "epiphany_init_machine_status", ";", "}", "</s>" ]

[ "Implements", "INIT_EXPANDERS", ".", "We", "just", "set", "up", "to", "call", "the", "above", "*", "function", "." ]

[ "epiphany" ]

[]

[ "<s>", "bool", "TLCS900PassConfig", "::", "addInstSelector", "(", ")", "{", "PM", "->", "add", "(", "createTLCS900ISelDag", "(", "getTLCS900TargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "addInstSelector", "-", "This", "method", "should", "install", "an", "instruction", "selector", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "." ]

[ "TLCS900", "TLCS900", "TLCS900", "TLCS900" ]

[]

[ "<s>", "static", "int", "m32c_leaf_function_p", "(", "void", ")", "{", "rtx_insn", "*", "saved_first", ",", "*", "saved_last", ";", "struct", "sequence_stack", "*", "seq", ";", "int", "rv", ";", "saved_first", "=", "crtl", "->", "emit", ".", "x_first_insn", ";", "saved_last", "=", "crtl", "->", "emit", ".", "x_last_insn", ";", "for", "(", "seq", "=", "crtl", "->", "emit", ".", "sequence_stack", ";", "seq", "&&", "seq", "->", "next", ";", "seq", "=", "seq", "->", "next", ")", ";", "if", "(", "seq", ")", "{", "crtl", "->", "emit", ".", "x_first_insn", "=", "seq", "->", "first", ";", "crtl", "->", "emit", ".", "x_last_insn", "=", "seq", "->", "last", ";", "}", "rv", "=", "leaf_function_p", "(", ")", ";", "crtl", "->", "emit", ".", "x_first_insn", "=", "saved_first", ";", "crtl", "->", "emit", ".", "x_last_insn", "=", "saved_last", ";", "return", "rv", ";", "}", "</s>" ]

[ "Returns", "TRUE", "if", "the", "current", "function", "is", "a", "leaf", ",", "and", "thus", "we", "can", "determine", "which", "registers", "an", "interrupt", "function", "really", "needs", "to", "save", ".", "The", "logic", "below", "is", "mostly", "about", "finding", "the", "insn", "sequence", "that", "'s", "the", "function", ",", "versus", "any", "sequence", "that", "might", "be", "open", "for", "the", "current", "insn", "." ]

[ "m32c" ]

[]

[ "<s>", "static", "bool", "ix86_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", ")", "{", "tree", "func", ";", "rtx", "a", ",", "b", ";", "if", "(", "!", "TARGET_64BIT", "&&", "flag_pic", "&&", "(", "!", "decl", "||", "TREE_PUBLIC", "(", "decl", ")", ")", ")", "return", "false", ";", "if", "(", "decl", ")", "func", "=", "decl", ";", "else", "{", "func", "=", "TREE_TYPE", "(", "TREE_OPERAND", "(", "exp", ",", "0", ")", ")", ";", "if", "(", "POINTER_TYPE_P", "(", "func", ")", ")", "func", "=", "TREE_TYPE", "(", "func", ")", ";", "}", "a", "=", "ix86_function_value", "(", "TREE_TYPE", "(", "exp", ")", ",", "func", ",", "false", ")", ";", "b", "=", "ix86_function_value", "(", "TREE_TYPE", "(", "DECL_RESULT", "(", "cfun", "->", "decl", ")", ")", ",", "cfun", "->", "decl", ",", "false", ")", ";", "if", "(", "STACK_REG_P", "(", "a", ")", "||", "STACK_REG_P", "(", "b", ")", ")", "{", "if", "(", "!", "rtx_equal_p", "(", "a", ",", "b", ")", ")", "return", "false", ";", "}", "else", "if", "(", "VOID_TYPE_P", "(", "TREE_TYPE", "(", "DECL_RESULT", "(", "cfun", "->", "decl", ")", ")", ")", ")", ";", "else", "if", "(", "!", "rtx_equal_p", "(", "a", ",", "b", ")", ")", "return", "false", ";", "if", "(", "!", "decl", "&&", "!", "TARGET_64BIT", ")", "{", "tree", "type", ";", "type", "=", "TREE_OPERAND", "(", "exp", ",", "0", ")", ";", "type", "=", "TREE_TYPE", "(", "type", ")", ";", "type", "=", "TREE_TYPE", "(", "type", ")", ";", "if", "(", "ix86_function_regparm", "(", "type", ",", "NULL", ")", ">=", "3", ")", "{", "return", "false", ";", "}", "}", "if", "(", "decl", "&&", "DECL_DLLIMPORT_P", "(", "decl", ")", "&&", "ix86_function_regparm", "(", "TREE_TYPE", "(", "decl", ")", ",", "NULL", ")", ">=", "3", ")", "return", "false", ";", "if", "(", "cfun", "->", "machine", "->", "force_align_arg_pointer", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Decide", "whether", "we", "can", "make", "a", "sibling", "call", "to", "a", "function", ".", "DECL", "is", "the", "declaration", "of", "the", "function", "being", "targeted", "by", "the", "call", "and", "EXP", "is", "the", "CALL_EXPR", "representing", "the", "call", "." ]

[ "i386", "0", "0", "3", "3" ]

[]

[ "<s>", "static", "machine_mode", "c6x_preferred_simd_mode", "(", "machine_mode", "mode", ")", "{", "switch", "(", "mode", ")", "{", "case", "HImode", ":", "return", "V2HImode", ";", "case", "QImode", ":", "return", "V4QImode", ";", "default", ":", "return", "word_mode", ";", "}", "}", "</s>" ]

[ "Implements", "TARGET_VECTORIZE_PREFERRED_SIMD_MODE", "." ]

[ "c6x" ]

[]

[ "<s>", "void", "mips16_expand_set_fcsr", "(", "rtx", "newval", ")", "{", "if", "(", "!", "mips16_set_fcsr_stub", ")", "mips16_set_fcsr_stub", "=", "new", "mips16_set_fcsr_one_only_stub", "(", ")", ";", "rtx", "fn", "=", "mips16_stub_call_address", "(", "mips16_set_fcsr_stub", ")", ";", "emit_move_insn", "(", "gen_rtx_REG", "(", "SImode", ",", "SET_FCSR_REGNUM", ")", ",", "newval", ")", ";", "emit_insn", "(", "PMODE_INSN", "(", "gen_mips_set_fcsr_mips16", ",", "(", "fn", ")", ")", ")", ";", "}", "</s>" ]

[ "Implement", "__builtin_mips_set_fcsr", "(", "TARGET", ")", "for", "MIPS16", ",", "using", "a", "stub", "." ]

[ "mips" ]

[]

[ "<s>", "WebAssemblyTargetMachine", "::", "WebAssemblyTargetMachine", "(", "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", ")", ":", "LLVMTargetMachine", "(", "T", ",", "TT", ".", "isArch64Bit", "(", ")", "?", "(", "TT", ".", "isOSEmscripten", "(", ")", "?", "\"e-m:e-p:64:64-i64:64-f128:64-n32:64-S128-ni:1:10:20\"", ":", "\"e-m:e-p:64:64-i64:64-n32:64-S128-ni:1:10:20\"", ")", ":", "(", "TT", ".", "isOSEmscripten", "(", ")", "?", "\"e-m:e-p:32:32-i64:64-f128:64-n32:64-S128-ni:1:10:20\"", ":", "\"e-m:e-p:32:32-i64:64-n32:64-S128-ni:1:10:20\"", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "RM", ",", "TT", ")", ",", "getEffectiveCodeModel", "(", "CM", ",", "CodeModel", "::", "Large", ")", ",", "OL", ")", ",", "TLOF", "(", "new", "WebAssemblyTargetObjectFile", "(", ")", ")", "{", "this", "->", "Options", ".", "TrapUnreachable", "=", "true", ";", "this", "->", "Options", ".", "FunctionSections", "=", "true", ";", "this", "->", "Options", ".", "DataSections", "=", "true", ";", "this", "->", "Options", ".", "UniqueSectionNames", "=", "true", ";", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

[ "Create", "an", "WebAssembly", "architecture", "model", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "\"e-m:e-p:64:64-i64:64-f128:64-n32:64-S128-ni:1:10:20\"", "\"e-m:e-p:64:64-i64:64-n32:64-S128-ni:1:10:20\"", "\"e-m:e-p:32:32-i64:64-f128:64-n32:64-S128-ni:1:10:20\"", "\"e-m:e-p:32:32-i64:64-n32:64-S128-ni:1:10:20\"", "WebAssembly" ]

[]

[ "<s>", "void", "final_prescan_insn", "(", "rtx", "insn", ",", "rtx", "opvec", "[", "]", "ATTRIBUTE_UNUSED", ",", "int", "noperands", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "dslots_number_nops", ">", "0", ")", "{", "rtx", "pattern", "=", "PATTERN", "(", "insn", ")", ";", "int", "length", "=", "get_attr_length", "(", "insn", ")", ";", "if", "(", "length", "==", "0", "||", "(", "iq2000_load_reg", "!=", "0", "&&", "reg_mentioned_p", "(", "iq2000_load_reg", ",", "pattern", ")", ")", "||", "(", "iq2000_load_reg2", "!=", "0", "&&", "reg_mentioned_p", "(", "iq2000_load_reg2", ",", "pattern", ")", ")", "||", "(", "iq2000_load_reg3", "!=", "0", "&&", "reg_mentioned_p", "(", "iq2000_load_reg3", ",", "pattern", ")", ")", "||", "(", "iq2000_load_reg4", "!=", "0", "&&", "reg_mentioned_p", "(", "iq2000_load_reg4", ",", "pattern", ")", ")", ")", "fputs", "(", "\"\\tnop\\n\"", ",", "asm_out_file", ")", ";", "else", "dslots_load_filled", "++", ";", "while", "(", "--", "dslots_number_nops", ">", "0", ")", "fputs", "(", "\"\\tnop\\n\"", ",", "asm_out_file", ")", ";", "iq2000_load_reg", "=", "0", ";", "iq2000_load_reg2", "=", "0", ";", "iq2000_load_reg3", "=", "0", ";", "iq2000_load_reg4", "=", "0", ";", "}", "if", "(", "(", "GET_CODE", "(", "insn", ")", "==", "JUMP_INSN", "||", "GET_CODE", "(", "insn", ")", "==", "CALL_INSN", "||", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "RETURN", ")", ")", "&&", "NEXT_INSN", "(", "PREV_INSN", "(", "insn", ")", ")", "==", "insn", ")", "{", "rtx", "nop_insn", "=", "emit_insn_after", "(", "gen_nop", "(", ")", ",", "insn", ")", ";", "INSN_ADDRESSES_NEW", "(", "nop_insn", ",", "-", "1", ")", ";", "}", "if", "(", "TARGET_STATS", "&&", "(", "GET_CODE", "(", "insn", ")", "==", "JUMP_INSN", "||", "GET_CODE", "(", "insn", ")", "==", "CALL_INSN", ")", ")", "dslots_jump_total", "++", ";", "}", "</s>" ]

[ "If", "defined", ",", "a", "C", "statement", "to", "be", "executed", "just", "prior", "to", "the", "output", "of", "assembler", "code", "for", "INSN", ",", "to", "modify", "the", "extracted", "operands", "so", "they", "will", "be", "output", "differently", ".", "Here", "the", "argument", "OPVEC", "is", "the", "vector", "containing", "the", "operands", "extracted", "from", "INSN", ",", "and", "NOPERANDS", "is", "the", "number", "of", "elements", "of", "the", "vector", "which", "contain", "meaningful", "data", "for", "this", "insn", ".", "The", "contents", "of", "this", "vector", "are", "what", "will", "be", "used", "to", "convert", "the", "insn", "template", "into", "assembler", "code", ",", "so", "you", "can", "change", "the", "assembler", "output", "by", "changing", "the", "contents", "of", "the", "vector", ".", "We", "use", "it", "to", "check", "if", "the", "current", "insn", "needs", "a", "nop", "in", "front", "of", "it", "because", "of", "load", "delays", ",", "and", "also", "to", "update", "the", "delay", "slot", "statistics", "." ]

[ "iq2000", "0", "0", "0", "0", "0", "0", "\"\\tnop\\n\"", "0", "\"\\tnop\\n\"", "0", "0", "0", "0", "1" ]

[]

[ "<s>", "static", "void", "restore_saved_cr", "(", "rtx", "reg", ",", "int", "using_mfcr_multiple", ",", "bool", "exit_func", ")", "{", "int", "count", "=", "0", ";", "int", "i", ";", "if", "(", "using_mfcr_multiple", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "i", "++", ")", "if", "(", "save_reg_p", "(", "CR0_REGNO", "+", "i", ")", ")", "count", "++", ";", "gcc_assert", "(", "count", ")", ";", "}", "if", "(", "using_mfcr_multiple", "&&", "count", ">", "1", ")", "{", "rtx_insn", "*", "insn", ";", "rtvec", "p", ";", "int", "ndx", ";", "p", "=", "rtvec_alloc", "(", "count", ")", ";", "ndx", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "i", "++", ")", "if", "(", "save_reg_p", "(", "CR0_REGNO", "+", "i", ")", ")", "{", "rtvec", "r", "=", "rtvec_alloc", "(", "2", ")", ";", "RTVEC_ELT", "(", "r", ",", "0", ")", "=", "reg", ";", "RTVEC_ELT", "(", "r", ",", "1", ")", "=", "GEN_INT", "(", "1", "<<", "(", "7", "-", "i", ")", ")", ";", "RTVEC_ELT", "(", "p", ",", "ndx", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "gen_rtx_REG", "(", "CCmode", ",", "CR0_REGNO", "+", "i", ")", ",", "gen_rtx_UNSPEC", "(", "CCmode", ",", "r", ",", "UNSPEC_MOVESI_TO_CR", ")", ")", ";", "ndx", "++", ";", "}", "insn", "=", "emit_insn", "(", "gen_rtx_PARALLEL", "(", "VOIDmode", ",", "p", ")", ")", ";", "gcc_assert", "(", "ndx", "==", "count", ")", ";", "if", "(", "!", "exit_func", "&&", "DEFAULT_ABI", "==", "ABI_ELFv2", "&&", "flag_shrink_wrap", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "i", "++", ")", "if", "(", "save_reg_p", "(", "CR0_REGNO", "+", "i", ")", ")", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "gen_rtx_REG", "(", "SImode", ",", "CR0_REGNO", "+", "i", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "}", "else", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "i", "++", ")", "if", "(", "save_reg_p", "(", "CR0_REGNO", "+", "i", ")", ")", "{", "rtx", "insn", "=", "emit_insn", "(", "gen_movsi_to_cr_one", "(", "gen_rtx_REG", "(", "CCmode", ",", "CR0_REGNO", "+", "i", ")", ",", "reg", ")", ")", ";", "if", "(", "!", "exit_func", "&&", "DEFAULT_ABI", "==", "ABI_ELFv2", "&&", "flag_shrink_wrap", ")", "{", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "gen_rtx_REG", "(", "SImode", ",", "CR0_REGNO", "+", "i", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "}", "if", "(", "!", "exit_func", "&&", "DEFAULT_ABI", "!=", "ABI_ELFv2", "&&", "(", "DEFAULT_ABI", "==", "ABI_V4", "||", "flag_shrink_wrap", ")", ")", "{", "rtx_insn", "*", "insn", "=", "get_last_insn", "(", ")", ";", "rtx", "cr", "=", "gen_rtx_REG", "(", "SImode", ",", "CR2_REGNO", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_RESTORE", ",", "cr", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "}", "</s>" ]

[ "Reload", "CR", "from", "REG", "." ]

[ "rs6000", "0", "0", "8", "1", "0", "0", "8", "2", "0", "1", "1", "7", "0", "8", "1", "0", "8", "1", "1" ]

[]

[ "<s>", "void", "NVPTXAsmPrinter", "::", "emitImplicitDef", "(", "const", "MachineInstr", "*", "MI", ")", "const", "{", "unsigned", "RegNo", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "RegNo", ")", ")", "{", "OutStreamer", "->", "AddComment", "(", "Twine", "(", "\"implicit-def: \"", ")", "+", "getVirtualRegisterName", "(", "RegNo", ")", ")", ";", "}", "else", "{", "const", "NVPTXSubtarget", "&", "STI", "=", "MI", "->", "getMF", "(", ")", "->", "getSubtarget", "<", "NVPTXSubtarget", ">", "(", ")", ";", "OutStreamer", "->", "AddComment", "(", "Twine", "(", "\"implicit-def: \"", ")", "+", "STI", ".", "getRegisterInfo", "(", ")", "->", "getName", "(", "RegNo", ")", ")", ";", "}", "OutStreamer", "->", "AddBlankLine", "(", ")", ";", "}", "</s>" ]

[ "Targets", "can", "override", "this", "to", "customize", "the", "output", "of", "IMPLICIT_DEF", "instructions", "in", "verbose", "mode", "." ]

[ "NVPTX", "NVPTX", "0", "\"implicit-def: \"", "NVPTX", "NVPTX", "\"implicit-def: \"" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "isCheapToSpeculateCtlz", "(", ")", "const", "{", "return", "Subtarget", ".", "hasStdExtZbb", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "cheap", "to", "speculate", "a", "call", "to", "intrinsic", "ctlz", "." ]

[ "RI5CY", "RISCV" ]

[]

[ "<s>", "SDValue", "HexagonTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "Op", ".", "getNode", "(", ")", "->", "dumpr", "(", "&", "DAG", ")", ";", "if", "(", "Opc", ">", "HexagonISD", "::", "OP_BEGIN", "&&", "Opc", "<", "HexagonISD", "::", "OP_END", ")", "errs", "(", ")", "<<", "\"Check for a non-legal type in this operation\\n\"", ";", "llvm_unreachable", "(", "\"Should not custom lower this!\"", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_SUBVECTOR", ":", "return", "LowerINSERT_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INSERT_VECTOR_ELT", ":", "return", "LowerINSERT_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "return", "LowerEXTRACT_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_VECTOR_ELT", ":", "return", "LowerEXTRACT_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BUILD_VECTOR", ":", "return", "LowerBUILD_VECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VECTOR_SHUFFLE", ":", "return", "LowerVECTOR_SHUFFLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SRA", ":", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRL", ":", "return", "LowerVECTOR_SHIFT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EH_RETURN", ":", "return", "LowerEH_RETURN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "LowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGLOBALADDRESS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GLOBAL_OFFSET_TABLE", ":", "return", "LowerGLOBAL_OFFSET_TABLE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VSELECT", ":", "return", "LowerVSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CTPOP", ":", "return", "LowerCTPOP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_VOID", ":", "return", "LowerINTRINSIC_VOID", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INLINEASM", ":", "return", "LowerINLINEASM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "PREFETCH", ":", "return", "LowerPREFETCH", "(", "Op", ",", "DAG", ")", ";", "}", "}", "</s>" ]

[ "LowerOperation", "-", "Provide", "custom", "lowering", "hooks", "for", "some", "operations", "." ]

[ "Hexagon", "Hexagon", "HexagonISD::OP_BEGIN", "HexagonISD::OP_END", "\"Check for a non-legal type in this operation\\n\"", "\"Should not custom lower this!\"", "ISD::CONCAT_VECTORS", "ISD::INSERT_SUBVECTOR", "ISD::INSERT_VECTOR_ELT", "ISD::EXTRACT_SUBVECTOR", "ISD::EXTRACT_VECTOR_ELT", "ISD::BUILD_VECTOR", "ISD::VECTOR_SHUFFLE", "ISD::SRA", "ISD::SHL", "ISD::SRL", "ISD::ConstantPool", "ISD::JumpTable", "ISD::EH_RETURN", "ISD::RETURNADDR", "ISD::FRAMEADDR", "ISD::GlobalTLSAddress", "ISD::ATOMIC_FENCE", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::GLOBAL_OFFSET_TABLE", "ISD::VASTART", "ISD::LOAD", "ISD::DYNAMIC_STACKALLOC", "ISD::SETCC", "ISD::VSELECT", "ISD::CTPOP", "ISD::INTRINSIC_WO_CHAIN", "ISD::INTRINSIC_VOID", "ISD::INLINEASM", "ISD::PREFETCH" ]

[]

[ "<s>", "void", "MSP430RegisterInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MSP430MachineFunctionInfo", "*", "MSP430FI", "=", "MF", ".", "getInfo", "<", "MSP430MachineFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "unsigned", "RetOpcode", "=", "MBBI", "->", "getOpcode", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "switch", "(", "RetOpcode", ")", "{", "case", "MSP430", "::", "RET", ":", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Can only insert epilog into returning blocks\"", ")", ";", "}", "uint64_t", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "CSSize", "=", "MSP430FI", "->", "getCalleeSavedFrameSize", "(", ")", ";", "uint64_t", "NumBytes", "=", "0", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "uint64_t", "FrameSize", "=", "StackSize", "-", "2", ";", "NumBytes", "=", "FrameSize", "-", "CSSize", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "POP16r", ")", ",", "MSP430", "::", "FPW", ")", ";", "}", "else", "NumBytes", "=", "StackSize", "-", "CSSize", ";", "MachineBasicBlock", "::", "iterator", "LastCSPop", "=", "MBBI", ";", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "PI", "=", "prior", "(", "MBBI", ")", ";", "unsigned", "Opc", "=", "PI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "!=", "MSP430", "::", "POP16r", "&&", "!", "PI", "->", "getDesc", "(", ")", ".", "isTerminator", "(", ")", ")", "break", ";", "--", "MBBI", ";", "}", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "{", "llvm_unreachable", "(", "\"Not implemented yet!\"", ")", ";", "}", "else", "{", "if", "(", "NumBytes", ")", "{", "MachineInstr", "*", "MI", "=", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MSP430", "::", "ADD16ri", ")", ",", "MSP430", "::", "SPW", ")", ".", "addReg", "(", "MSP430", "::", "SPW", ")", ".", "addImm", "(", "NumBytes", ")", ";", "MI", "->", "getOperand", "(", "3", ")", ".", "setIsDead", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "MSP430", "MSP430", "MSP430", "MSP430", "MSP430", "MSP430::RET", "\"Can only insert epilog into returning blocks\"", "MSP430", "0", "2", "MSP430::POP16r", "MSP430::FPW", "MSP430::POP16r", "\"Not implemented yet!\"", "MSP430::ADD16ri", "MSP430::SPW", "MSP430::SPW", "3" ]

[]

[ "<s>", "void", "CSKYTargetStreamer", "::", "emitCurrentConstantPool", "(", ")", "{", "ConstantPool", "->", "emitAll", "(", "Streamer", ")", ";", "ConstantPool", "->", "clearCache", "(", ")", ";", "}", "</s>" ]

[ "Callback", "used", "to", "implement", "the", ".ltorg", "directive", "." ]

[ "CSKY", "CSKY" ]

[]

[ "<s>", "enum", "direction", "pa_function_arg_padding", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "if", "(", "mode", "==", "BLKmode", "||", "(", "TARGET_64BIT", "&&", "type", "&&", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "||", "TREE_CODE", "(", "type", ")", "==", "COMPLEX_TYPE", "||", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", ")", ")", "{", "if", "(", "type", "&&", "TREE_CODE", "(", "TYPE_SIZE", "(", "type", ")", ")", "==", "INTEGER_CST", "&&", "(", "int_size_in_bytes", "(", "type", ")", "*", "BITS_PER_UNIT", ")", "%", "PARM_BOUNDARY", "==", "0", ")", "return", "none", ";", "if", "(", "TARGET_64BIT", ")", "return", "upward", ";", "else", "return", "downward", ";", "}", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "<", "PARM_BOUNDARY", ")", "return", "downward", ";", "else", "return", "none", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG_PADDING", "." ]

[ "pa", "0" ]

[]

[ "<s>", "void", "applyFixup", "(", "const", "MCAssembler", "&", "Asm", ",", "const", "MCFixup", "&", "Fixup", ",", "const", "MCValue", "&", "Target", ",", "MutableArrayRef", "<", "char", ">", "Data", ",", "uint64_t", "Value", ",", "bool", "IsPCRel", ")", "const", "override", "{", "Value", "=", "adjustFixupValue", "(", "Fixup", ".", "getKind", "(", ")", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "{", "unsigned", "Idx", "=", "IsLittleEndian", "?", "i", ":", "(", "NumBytes", "-", "1", "-", "i", ")", ";", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "Idx", "*", "8", ")", ")", "&", "0xff", ")", ";", "}", "}", "</s>" ]

[ "Apply", "the", "Value", "for", "given", "Fixup", "into", "the", "provided", "data", "fragment", ",", "at", "the", "offset", "specified", "by", "the", "fixup", "and", "following", "the", "fixup", "kind", "as", "appropriate", "." ]

[ "PowerPC", "0", "1", "8", "0xff" ]

[]

[ "<s>", "static", "machine_mode", "mips_dwarf_frame_reg_mode", "(", "int", "regno", ")", "{", "machine_mode", "mode", "=", "default_dwarf_frame_reg_mode", "(", "regno", ")", ";", "if", "(", "FP_REG_P", "(", "regno", ")", "&&", "mips_abi", "==", "ABI_32", "&&", "!", "TARGET_FLOAT32", ")", "mode", "=", "SImode", ";", "return", "mode", ";", "}", "</s>" ]

[ "Implement", "TARGET_DWARF_FRAME_REG_MODE", "." ]

[ "mips" ]

[]

[ "<s>", "static", "void", "mips_sim_record_set", "(", "rtx", "x", ",", "rtx", "pat", "ATTRIBUTE_UNUSED", ",", "void", "*", "data", ")", "{", "struct", "mips_sim", "*", "state", ";", "unsigned", "int", "i", ";", "state", "=", "data", ";", "if", "(", "REG_P", "(", "x", ")", ")", "for", "(", "i", "=", "0", ";", "i", "<", "HARD_REGNO_NREGS", "(", "REGNO", "(", "x", ")", ",", "GET_MODE", "(", "x", ")", ")", ";", "i", "++", ")", "{", "state", "->", "last_set", "[", "REGNO", "(", "x", ")", "+", "i", "]", ".", "insn", "=", "mips_sim_insn", ";", "state", "->", "last_set", "[", "REGNO", "(", "x", ")", "+", "i", "]", ".", "time", "=", "state", "->", "time", ";", "}", "}", "</s>" ]

[ "mips_sim_insn", "has", "just", "set", "X.", "Update", "the", "LAST_SET", "array", "in", "simulation", "state", "DATA", "." ]

[ "mips", "0" ]

[]

[ "<s>", "static", "bool", "rs6000_return_in_msb", "(", "const_tree", "valtype", ")", "{", "return", "(", "DEFAULT_ABI", "==", "ABI_ELFv2", "&&", "BYTES_BIG_ENDIAN", "&&", "AGGREGATE_TYPE_P", "(", "valtype", ")", "&&", "FUNCTION_ARG_PADDING", "(", "TYPE_MODE", "(", "valtype", ")", ",", "valtype", ")", "==", "upward", ")", ";", "}", "</s>" ]

[ "Specify", "whether", "values", "returned", "in", "registers", "should", "be", "at", "the", "most", "significant", "end", "of", "a", "register", ".", "We", "want", "aggregates", "returned", "by", "value", "to", "match", "the", "way", "aggregates", "are", "passed", "to", "functions", "." ]

[ "rs6000" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"SystemZ Long Branch\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "SystemZ", "\"SystemZ Long Branch\"" ]

[]

[ "<s>", "bool", "prefixed_paddi_p", "(", "rtx_insn", "*", "insn", ")", "{", "rtx", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "!", "set", ")", "return", "false", ";", "rtx", "dest", "=", "SET_DEST", "(", "set", ")", ";", "rtx", "src", "=", "SET_SRC", "(", "set", ")", ";", "if", "(", "!", "REG_P", "(", "dest", ")", "&&", "!", "SUBREG_P", "(", "dest", ")", ")", "return", "false", ";", "if", "(", "CONST_INT_P", "(", "src", ")", ")", "return", "(", "satisfies_constraint_eI", "(", "src", ")", "&&", "!", "satisfies_constraint_I", "(", "src", ")", "&&", "!", "satisfies_constraint_L", "(", "src", ")", ")", ";", "if", "(", "GET_CODE", "(", "src", ")", "==", "PLUS", ")", "{", "rtx", "op1", "=", "XEXP", "(", "src", ",", "1", ")", ";", "return", "(", "CONST_INT_P", "(", "op1", ")", "&&", "satisfies_constraint_eI", "(", "op1", ")", "&&", "!", "satisfies_constraint_I", "(", "op1", ")", "&&", "!", "satisfies_constraint_L", "(", "op1", ")", ")", ";", "}", "if", "(", "!", "TARGET_PCREL", "||", "GET_MODE", "(", "dest", ")", "!=", "Pmode", ")", "return", "false", ";", "if", "(", "!", "SYMBOL_REF_P", "(", "src", ")", "&&", "!", "LABEL_REF_P", "(", "src", ")", "&&", "GET_CODE", "(", "src", ")", "!=", "CONST", ")", "return", "false", ";", "enum", "insn_form", "iform", "=", "address_to_insn_form", "(", "src", ",", "Pmode", ",", "NON_PREFIXED_DEFAULT", ")", ";", "return", "(", "iform", "==", "INSN_FORM_PCREL_EXTERNAL", "||", "iform", "==", "INSN_FORM_PCREL_LOCAL", ")", ";", "}", "</s>" ]

[ "Whether", "a", "load", "immediate", "or", "add", "instruction", "is", "a", "prefixed", "instruction", ".", "This", "is", "called", "from", "the", "prefixed", "attribute", "processing", "." ]

[ "rs6000", "1" ]

[]

[ "<s>", "static", "tree", "rs6000_builtin_md_vectorized_function", "(", "tree", "fndecl", ",", "tree", "type_out", ",", "tree", "type_in", ")", "{", "machine_mode", "in_mode", ",", "out_mode", ";", "int", "in_n", ",", "out_n", ";", "if", "(", "TARGET_DEBUG_BUILTIN", ")", "fprintf", "(", "stderr", ",", "\"rs6000_builtin_md_vectorized_function (%s, %s, %s)\\n\"", ",", "IDENTIFIER_POINTER", "(", "DECL_NAME", "(", "fndecl", ")", ")", ",", "GET_MODE_NAME", "(", "TYPE_MODE", "(", "type_out", ")", ")", ",", "GET_MODE_NAME", "(", "TYPE_MODE", "(", "type_in", ")", ")", ")", ";", "if", "(", "TREE_CODE", "(", "type_out", ")", "!=", "VECTOR_TYPE", "||", "TREE_CODE", "(", "type_in", ")", "!=", "VECTOR_TYPE", "||", "!", "TARGET_VECTORIZE_BUILTINS", ")", "return", "NULL_TREE", ";", "out_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type_out", ")", ")", ";", "out_n", "=", "TYPE_VECTOR_SUBPARTS", "(", "type_out", ")", ";", "in_mode", "=", "TYPE_MODE", "(", "TREE_TYPE", "(", "type_in", ")", ")", ";", "in_n", "=", "TYPE_VECTOR_SUBPARTS", "(", "type_in", ")", ";", "enum", "rs6000_builtins", "fn", "=", "(", "enum", "rs6000_builtins", ")", "DECL_FUNCTION_CODE", "(", "fndecl", ")", ";", "switch", "(", "fn", ")", "{", "case", "RS6000_BUILTIN_RSQRTF", ":", "if", "(", "VECTOR_UNIT_ALTIVEC_OR_VSX_P", "(", "V4SFmode", ")", "&&", "out_mode", "==", "SFmode", "&&", "out_n", "==", "4", "&&", "in_mode", "==", "SFmode", "&&", "in_n", "==", "4", ")", "return", "rs6000_builtin_decls", "[", "ALTIVEC_BUILTIN_VRSQRTFP", "]", ";", "break", ";", "case", "RS6000_BUILTIN_RSQRT", ":", "if", "(", "VECTOR_UNIT_VSX_P", "(", "V2DFmode", ")", "&&", "out_mode", "==", "DFmode", "&&", "out_n", "==", "2", "&&", "in_mode", "==", "DFmode", "&&", "in_n", "==", "2", ")", "return", "rs6000_builtin_decls", "[", "VSX_BUILTIN_RSQRT_2DF", "]", ";", "break", ";", "case", "RS6000_BUILTIN_RECIPF", ":", "if", "(", "VECTOR_UNIT_ALTIVEC_OR_VSX_P", "(", "V4SFmode", ")", "&&", "out_mode", "==", "SFmode", "&&", "out_n", "==", "4", "&&", "in_mode", "==", "SFmode", "&&", "in_n", "==", "4", ")", "return", "rs6000_builtin_decls", "[", "ALTIVEC_BUILTIN_VRECIPFP", "]", ";", "break", ";", "case", "RS6000_BUILTIN_RECIP", ":", "if", "(", "VECTOR_UNIT_VSX_P", "(", "V2DFmode", ")", "&&", "out_mode", "==", "DFmode", "&&", "out_n", "==", "2", "&&", "in_mode", "==", "DFmode", "&&", "in_n", "==", "2", ")", "return", "rs6000_builtin_decls", "[", "VSX_BUILTIN_RECIP_V2DF", "]", ";", "break", ";", "default", ":", "break", ";", "}", "return", "NULL_TREE", ";", "}", "</s>" ]

[ "Implement", "targetm.vectorize.builtin_md_vectorized_function", "." ]

[ "powerpcspe", "\"rs6000_builtin_md_vectorized_function (%s, %s, %s)\\n\"", "4", "4", "2", "2", "4", "4", "2", "2" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "PerformDAGCombine", "(", "SDNode", "*", "N", ",", "DAGCombinerInfo", "&", "DCI", ")", "const", "{", "SelectionDAG", "&", "DAG", "=", "DCI", ".", "DAG", ";", "unsigned", "Opc", "=", "N", "->", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "SDIVREM", ":", "case", "ISD", "::", "UDIVREM", ":", "return", "performDivRemCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "performSELECTCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "MipsISD", "::", "CMovFP_F", ":", "case", "MipsISD", "::", "CMovFP_T", ":", "return", "performCMovFPCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "AND", ":", "return", "performANDCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "OR", ":", "return", "performORCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "case", "ISD", "::", "ADD", ":", "return", "performADDCombine", "(", "N", ",", "DAG", ",", "DCI", ",", "Subtarget", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

[ "This", "method", "will", "be", "invoked", "for", "all", "target", "nodes", "and", "for", "any", "target-independent", "nodes", "that", "the", "target", "has", "registered", "with", "invoke", "it", "for", "." ]

[ "Mips", "Mips", "ISD::SDIVREM", "ISD::UDIVREM", "ISD::SELECT", "MipsISD::CMovFP_F", "MipsISD::CMovFP_T", "ISD::AND", "ISD::OR", "ISD::ADD" ]

[]

[ "<s>", "bool", "ARCFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Spill callee saved registers: \"", "<<", "MBB", ".", "getParent", "(", ")", "->", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "unsigned", "Last", "=", "determineLastCalleeSave", "(", "CSI", ")", ";", "if", "(", "UseSaveRestoreFunclet", "&&", "Last", ">", "ARC", "::", "R14", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "spillCalleeSavedRegisters", "-", "Issues", "instruction", "(", "s", ")", "to", "spill", "all", "callee", "saved", "registers", "and", "returns", "true", "if", "it", "is", "n't", "possible", "/", "profitable", "to", "do", "so", "by", "issuing", "a", "series", "of", "store", "instructions", "via", "storeRegToStackSlot", "(", ")", "." ]

[ "ARC", "ARC", "\"Spill callee saved registers: \"", "\"\\n\"", "ARC::R14" ]

[]

[ "<s>", "virtual", "const", "TargetFrameInfo", "*", "getFrameInfo", "(", ")", "const", "{", "return", "&", "FrameInfo", ";", "}", "</s>" ]

[ "getFrameInfo", "-", "Return", "the", "frame", "info", "object", "for", "the", "current", "function", "." ]

[ "PIC16" ]

[]

[ "<s>", "static", "void", "rs6000_conditional_register_usage", "(", "void", ")", "{", "int", "i", ";", "if", "(", "TARGET_DEBUG_TARGET", ")", "fprintf", "(", "stderr", ",", "\"rs6000_conditional_register_usage called\\n\"", ")", ";", "fixed_regs", "[", "64", "]", "=", "1", ";", "if", "(", "TARGET_64BIT", ")", "fixed_regs", "[", "13", "]", "=", "call_used_regs", "[", "13", "]", "=", "call_really_used_regs", "[", "13", "]", "=", "1", ";", "if", "(", "TARGET_SOFT_FLOAT", "||", "!", "TARGET_FPRS", ")", "for", "(", "i", "=", "32", ";", "i", "<", "64", ";", "i", "++", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "call_really_used_regs", "[", "i", "]", "=", "1", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "call_really_used_regs", "[", "2", "]", "=", "0", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "flag_pic", "==", "2", ")", "fixed_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_V4", "&&", "flag_pic", "==", "1", ")", "fixed_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_really_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", "&&", "flag_pic", ")", "fixed_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_really_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "TARGET_TOC", "&&", "TARGET_MINIMAL_TOC", ")", "fixed_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "call_used_regs", "[", "RS6000_PIC_OFFSET_TABLE_REGNUM", "]", "=", "1", ";", "if", "(", "TARGET_SPE", ")", "{", "global_regs", "[", "SPEFSCR_REGNO", "]", "=", "1", ";", "fixed_regs", "[", "14", "]", "=", "call_used_regs", "[", "14", "]", "=", "call_really_used_regs", "[", "14", "]", "=", "1", ";", "}", "if", "(", "!", "TARGET_ALTIVEC", "&&", "!", "TARGET_VSX", ")", "{", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", ";", "i", "<=", "LAST_ALTIVEC_REGNO", ";", "++", "i", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "call_really_used_regs", "[", "i", "]", "=", "1", ";", "call_really_used_regs", "[", "VRSAVE_REGNO", "]", "=", "1", ";", "}", "if", "(", "TARGET_ALTIVEC", "||", "TARGET_VSX", ")", "global_regs", "[", "VSCR_REGNO", "]", "=", "1", ";", "if", "(", "TARGET_ALTIVEC_ABI", ")", "{", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", ";", "i", "<", "FIRST_ALTIVEC_REGNO", "+", "20", ";", "++", "i", ")", "call_used_regs", "[", "i", "]", "=", "call_really_used_regs", "[", "i", "]", "=", "1", ";", "if", "(", "TARGET_XCOFF", ")", "for", "(", "i", "=", "FIRST_ALTIVEC_REGNO", "+", "20", ";", "i", "<", "FIRST_ALTIVEC_REGNO", "+", "32", ";", "++", "i", ")", "fixed_regs", "[", "i", "]", "=", "call_used_regs", "[", "i", "]", "=", "call_really_used_regs", "[", "i", "]", "=", "1", ";", "}", "}", "</s>" ]

[ "Change", "register", "usage", "conditional", "on", "target", "flags", "." ]

[ "powerpcspe", "\"rs6000_conditional_register_usage called\\n\"", "64", "1", "13", "13", "13", "1", "32", "64", "1", "2", "0", "2", "1", "1", "1", "1", "1", "1", "14", "14", "14", "1", "1", "1", "1", "20", "1", "20", "32", "1" ]

[]

[ "<s>", "rtx", "riscv_function_value", "(", "const_tree", "type", ",", "const_tree", "func", ",", "enum", "machine_mode", "mode", ")", "{", "struct", "riscv_arg_info", "info", ";", "CUMULATIVE_ARGS", "args", ";", "if", "(", "type", ")", "{", "int", "unsigned_p", "=", "TYPE_UNSIGNED", "(", "type", ")", ";", "mode", "=", "TYPE_MODE", "(", "type", ")", ";", "mode", "=", "promote_function_mode", "(", "type", ",", "mode", ",", "&", "unsigned_p", ",", "func", ",", "1", ")", ";", "}", "memset", "(", "&", "args", ",", "0", ",", "sizeof", "args", ")", ";", "return", "riscv_get_arg_info", "(", "&", "info", ",", "&", "args", ",", "mode", ",", "type", ",", "true", ",", "true", ")", ";", "}", "</s>" ]

[ "Implement", "FUNCTION_VALUE", "and", "LIBCALL_VALUE", ".", "For", "normal", "calls", ",", "VALTYPE", "is", "the", "return", "type", "and", "MODE", "is", "VOIDmode", ".", "For", "libcalls", ",", "VALTYPE", "is", "null", "and", "MODE", "is", "the", "mode", "of", "the", "return", "value", "." ]

[ "riscv", "1", "0" ]

[]

[ "<s>", "static", "unsigned", "ix86_loop_unroll_adjust", "(", "unsigned", "nunroll", ",", "struct", "loop", "*", "loop", ")", "{", "basic_block", "*", "bbs", ";", "rtx_insn", "*", "insn", ";", "unsigned", "i", ";", "unsigned", "mem_count", "=", "0", ";", "if", "(", "!", "TARGET_ADJUST_UNROLL", ")", "return", "nunroll", ";", "subrtx_iterator", "::", "array_type", "array", ";", "bbs", "=", "get_loop_body", "(", "loop", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "loop", "->", "num_nodes", ";", "i", "++", ")", "FOR_BB_INSNS", "(", "bbs", "[", "i", "]", ",", "insn", ")", "if", "(", "NONDEBUG_INSN_P", "(", "insn", ")", ")", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "insn", ",", "NONCONST", ")", "if", "(", "const_rtx", "x", "=", "*", "iter", ")", "if", "(", "MEM_P", "(", "x", ")", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "x", ")", ";", "unsigned", "int", "n_words", "=", "GET_MODE_SIZE", "(", "mode", ")", "/", "UNITS_PER_WORD", ";", "if", "(", "n_words", ">", "4", ")", "mem_count", "+=", "2", ";", "else", "mem_count", "+=", "1", ";", "}", "free", "(", "bbs", ")", ";", "if", "(", "mem_count", "&&", "mem_count", "<=", "32", ")", "return", "32", "/", "mem_count", ";", "return", "nunroll", ";", "}", "</s>" ]

[ "This", "function", "adjusts", "the", "unroll", "factor", "based", "on", "the", "hardware", "capabilities", ".", "For", "ex", ",", "bdver3", "has", "a", "loop", "buffer", "which", "makes", "unrolling", "of", "smaller", "loops", "less", "important", ".", "This", "function", "decides", "the", "unroll", "factor", "using", "number", "of", "memory", "references", "(", "value", "32", "is", "used", ")", "as", "a", "heuristic", "." ]

[ "i386", "0", "0", "4", "2", "1", "32", "32" ]

[]

[ "<s>", "bool", "pdp11_expand_shift", "(", "rtx", "*", "operands", ",", "rtx", "(", "*", "shift_sc", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ",", "rtx", "(", "*", "shift_base", ")", "(", "rtx", ",", "rtx", ",", "rtx", ")", ")", "{", "rtx", "r", ",", "test", ";", "rtx_code_label", "*", "lb", ";", "if", "(", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", "&&", "pdp11_small_shift", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", ")", "emit_insn", "(", "(", "*", "shift_sc", ")", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "operands", "[", "2", "]", ")", ")", ";", "else", "if", "(", "TARGET_40_PLUS", ")", "return", "false", ";", "else", "{", "lb", "=", "gen_label_rtx", "(", ")", ";", "r", "=", "gen_reg_rtx", "(", "HImode", ")", ";", "emit_move_insn", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ";", "emit_move_insn", "(", "r", ",", "operands", "[", "2", "]", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", ")", "{", "test", "=", "gen_rtx_LE", "(", "HImode", ",", "r", ",", "const0_rtx", ")", ";", "emit_jump_insn", "(", "gen_cbranchhi4", "(", "test", ",", "r", ",", "const0_rtx", ",", "lb", ")", ")", ";", "}", "emit_insn", "(", "(", "*", "shift_base", ")", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ",", "r", ")", ")", ";", "if", "(", "!", "CONST_INT_P", "(", "operands", "[", "2", "]", ")", ")", "{", "emit_label", "(", "lb", ")", ";", "emit_use", "(", "stack_pointer_rtx", ")", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Expand", "a", "shift", "insn", ".", "Returns", "true", "if", "the", "expansion", "was", "done", ",", "false", "if", "it", "needs", "to", "be", "handled", "by", "the", "caller", "." ]

[ "pdp11", "2", "2", "0", "1", "2", "0", "1", "2", "2", "0", "1", "2" ]

[]

[ "<s>", "const", "MCFixupKindInfo", "&", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "]", "=", "{", "{", "\"reloc_pcrel_4byte\"", ",", "0", ",", "4", "*", "8", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"reloc_pcrel_1byte\"", ",", "0", ",", "1", "*", "8", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"reloc_riprel_4byte\"", ",", "0", ",", "4", "*", "8", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"reloc_riprel_4byte_movq_load\"", ",", "0", ",", "4", "*", "8", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCCodeEmitter", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

[ "Get", "information", "on", "a", "fixup", "kind", "." ]

[ "X86", "\"reloc_pcrel_4byte\"", "0", "4", "8", "\"reloc_pcrel_1byte\"", "0", "1", "8", "\"reloc_riprel_4byte\"", "0", "4", "8", "\"reloc_riprel_4byte_movq_load\"", "0", "4", "8", "\"Invalid kind!\"" ]

[]

[ "<s>", "void", "MBlazeRegisterInfo", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MBlazeFunctionInfo", "*", "MBlazeFI", "=", "MF", ".", "getInfo", "<", "MBlazeFunctionInfo", ">", "(", ")", ";", "DebugLoc", "dl", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "int", "FPOffset", "=", "MBlazeFI", "->", "getFPStackOffset", "(", ")", ";", "int", "RAOffset", "=", "MBlazeFI", "->", "getRAStackOffset", "(", ")", ";", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "MBlaze", "::", "ADD", ")", ",", "MBlaze", "::", "R1", ")", ".", "addReg", "(", "MBlaze", "::", "R19", ")", ".", "addReg", "(", "MBlaze", "::", "R0", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "MBlaze", "::", "LWI", ")", ",", "MBlaze", "::", "R19", ")", ".", "addImm", "(", "FPOffset", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ";", "}", "if", "(", "MFI", "->", "adjustsStack", "(", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "MBlaze", "::", "LWI", ")", ",", "MBlaze", "::", "R15", ")", ".", "addImm", "(", "RAOffset", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ";", "}", "int", "StackSize", "=", "(", "int", ")", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "<", "28", "&&", "MFI", "->", "adjustsStack", "(", ")", ")", "StackSize", "=", "28", ";", "if", "(", "StackSize", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "MBlaze", "::", "ADDI", ")", ",", "MBlaze", "::", "R1", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addImm", "(", "StackSize", ")", ";", "}", "}", "</s>" ]

[ "Insert", "epilog", "code", "into", "the", "function", "." ]

[ "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze::ADD", "MBlaze::R1", "MBlaze::R19", "MBlaze::R0", "MBlaze::LWI", "MBlaze::R19", "MBlaze::R1", "MBlaze::LWI", "MBlaze::R15", "MBlaze::R1", "28", "28", "MBlaze::ADDI", "MBlaze::R1", "MBlaze::R1" ]

[]

[ "<s>", "void", "X86RegisterInfo", "::", "eliminateFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "II", ",", "int", "SPAdj", ",", "unsigned", "FIOperandNum", ",", "RegScavenger", "*", "RS", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "II", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "bool", "IsEHFuncletEpilogue", "=", "MBBI", "==", "MBB", ".", "end", "(", ")", "?", "false", ":", "isFuncletReturnInstr", "(", "*", "MBBI", ")", ";", "const", "X86FrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "int", "FrameIndex", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "getIndex", "(", ")", ";", "int", "FIOffset", ";", "unsigned", "BasePtr", ";", "if", "(", "MI", ".", "isReturn", "(", ")", ")", "{", "assert", "(", "(", "!", "needsStackRealignment", "(", "MF", ")", "||", "MF", ".", "getFrameInfo", "(", ")", ".", "isFixedObjectIndex", "(", "FrameIndex", ")", ")", "&&", "\"Return instruction can only reference SP relative frame objects\"", ")", ";", "FIOffset", "=", "TFI", "->", "getFrameIndexReferenceSP", "(", "MF", ",", "FrameIndex", ",", "BasePtr", ",", "0", ")", ";", "}", "else", "if", "(", "TFI", "->", "Is64Bit", "&&", "(", "MBB", ".", "isEHFuncletEntry", "(", ")", "||", "IsEHFuncletEpilogue", ")", ")", "{", "FIOffset", "=", "TFI", "->", "getWin64EHFrameIndexRef", "(", "MF", ",", "FrameIndex", ",", "BasePtr", ")", ";", "}", "else", "{", "FIOffset", "=", "TFI", "->", "getFrameIndexReference", "(", "MF", ",", "FrameIndex", ",", "BasePtr", ")", ";", "}", "unsigned", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "TargetOpcode", "::", "LOCAL_ESCAPE", ")", "{", "MachineOperand", "&", "FI", "=", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ";", "FI", ".", "ChangeToImmediate", "(", "FIOffset", ")", ";", "return", ";", "}", "Register", "MachineBasePtr", "=", "BasePtr", ";", "if", "(", "Opc", "==", "X86", "::", "LEA64_32r", "&&", "X86", "::", "GR32RegClass", ".", "contains", "(", "BasePtr", ")", ")", "MachineBasePtr", "=", "getX86SubSuperRegister", "(", "BasePtr", ",", "64", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", ")", ".", "ChangeToRegister", "(", "MachineBasePtr", ",", "false", ")", ";", "if", "(", "BasePtr", "==", "StackPtr", ")", "FIOffset", "+=", "SPAdj", ";", "if", "(", "Opc", "==", "TargetOpcode", "::", "STACKMAP", "||", "Opc", "==", "TargetOpcode", "::", "PATCHPOINT", ")", "{", "assert", "(", "BasePtr", "==", "FramePtr", "&&", "\"Expected the FP as base register\"", ")", ";", "int64_t", "Offset", "=", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "getImm", "(", ")", "+", "FIOffset", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "1", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "return", ";", "}", "if", "(", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "isImm", "(", ")", ")", "{", "int", "Imm", "=", "(", "int", ")", "(", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "getImm", "(", ")", ")", ";", "int", "Offset", "=", "FIOffset", "+", "Imm", ";", "assert", "(", "(", "!", "Is64Bit", "||", "isInt", "<", "32", ">", "(", "(", "long", "long", ")", "FIOffset", "+", "Imm", ")", ")", "&&", "\"Requesting 64-bit offset in 32-bit immediate!\"", ")", ";", "if", "(", "Offset", "!=", "0", "||", "!", "tryOptimizeLEAtoMOV", "(", "II", ")", ")", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "ChangeToImmediate", "(", "Offset", ")", ";", "}", "else", "{", "uint64_t", "Offset", "=", "FIOffset", "+", "(", "uint64_t", ")", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "getOffset", "(", ")", ";", "MI", ".", "getOperand", "(", "FIOperandNum", "+", "3", ")", ".", "setOffset", "(", "Offset", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "must", "be", "overriden", "to", "eliminate", "abstract", "frame", "indices", "from", "instructions", "which", "may", "use", "them", "." ]

[ "X86", "X86", "X86", "\"Return instruction can only reference SP relative frame objects\"", "0", "X86::LEA64_32r", "X86::GR32RegClass", "X86", "64", "\"Expected the FP as base register\"", "1", "1", "3", "3", "32", "\"Requesting 64-bit offset in 32-bit immediate!\"", "0", "3", "3", "3" ]

[]

[ "<s>", "TargetLoweringObjectFile", "*", "getObjFileLowering", "(", ")", "const", "override", "{", "return", "TLOF", ".", "get", "(", ")", ";", "}", "</s>" ]

[ "Return", "information", "about", "object", "file", "lowering", "." ]

[ "Hexagon" ]

[]

[ "<s>", "void", "mt_emit_cbranch", "(", "enum", "rtx_code", "code", ",", "rtx", "loc", ",", "rtx", "op0", ",", "rtx", "op1", ")", "{", "rtx", "condition_rtx", ",", "loc_ref", ";", "if", "(", "!", "reg_or_0_operand", "(", "op0", ",", "SImode", ")", ")", "op0", "=", "copy_to_mode_reg", "(", "SImode", ",", "op0", ")", ";", "if", "(", "!", "reg_or_0_operand", "(", "op1", ",", "SImode", ")", ")", "op1", "=", "copy_to_mode_reg", "(", "SImode", ",", "op1", ")", ";", "condition_rtx", "=", "mt_generate_compare", "(", "code", ",", "op0", ",", "op1", ")", ";", "loc_ref", "=", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "loc", ")", ";", "emit_jump_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "condition_rtx", ",", "loc_ref", ",", "pc_rtx", ")", ")", ")", ";", "}", "</s>" ]

[ "Emit", "a", "branch", "of", "kind", "CODE", "to", "location", "LOC", "." ]

[ "mt" ]

[]

[ "<s>", "static", "bool", "ix86_hard_regno_mode_ok", "(", "unsigned", "int", "regno", ",", "machine_mode", "mode", ")", "{", "if", "(", "CC_REGNO_P", "(", "regno", ")", ")", "return", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", ";", "if", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_CC", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_RANDOM", "||", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_PARTIAL_INT", ")", "return", "false", ";", "if", "(", "STACK_REGNO_P", "(", "regno", ")", ")", "return", "VALID_FP_MODE_P", "(", "mode", ")", ";", "if", "(", "MASK_REGNO_P", "(", "regno", ")", ")", "return", "(", "VALID_MASK_REG_MODE", "(", "mode", ")", "||", "(", "TARGET_AVX512BW", "&&", "VALID_MASK_AVX512BW_MODE", "(", "mode", ")", ")", ")", ";", "if", "(", "SSE_REGNO_P", "(", "regno", ")", ")", "{", "if", "(", "TARGET_AVX512F", "&&", "(", "mode", "==", "XImode", "||", "VALID_AVX512F_REG_MODE", "(", "mode", ")", "||", "VALID_AVX512F_SCALAR_MODE", "(", "mode", ")", ")", ")", "return", "true", ";", "if", "(", "(", "TARGET_AVX5124FMAPS", "||", "TARGET_AVX5124VNNIW", ")", "&&", "(", "mode", "==", "V64SFmode", "||", "mode", "==", "V64SImode", ")", "&&", "MOD4_SSE_REGNO_P", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "TARGET_AVX512VL", "&&", "(", "mode", "==", "OImode", "||", "mode", "==", "TImode", "||", "VALID_AVX256_REG_MODE", "(", "mode", ")", "||", "VALID_AVX512VL_128_REG_MODE", "(", "mode", ")", ")", ")", "return", "true", ";", "if", "(", "EXT_REX_SSE_REGNO_P", "(", "regno", ")", ")", "return", "false", ";", "return", "(", "(", "TARGET_AVX", "&&", "VALID_AVX256_REG_OR_OI_MODE", "(", "mode", ")", ")", "||", "VALID_SSE_REG_MODE", "(", "mode", ")", "||", "VALID_SSE2_REG_MODE", "(", "mode", ")", "||", "VALID_MMX_REG_MODE", "(", "mode", ")", "||", "VALID_MMX_REG_MODE_3DNOW", "(", "mode", ")", ")", ";", "}", "if", "(", "MMX_REGNO_P", "(", "regno", ")", ")", "{", "return", "(", "VALID_MMX_REG_MODE", "(", "mode", ")", "||", "VALID_MMX_REG_MODE_3DNOW", "(", "mode", ")", ")", ";", "}", "if", "(", "mode", "==", "QImode", ")", "{", "if", "(", "ANY_QI_REGNO_P", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "!", "TARGET_PARTIAL_REG_STALL", ")", "return", "true", ";", "if", "(", "lra_in_progress", ")", "return", "true", ";", "return", "!", "can_create_pseudo_p", "(", ")", ";", "}", "else", "if", "(", "VALID_INT_MODE_P", "(", "mode", ")", ")", "return", "true", ";", "else", "if", "(", "VALID_FP_MODE_P", "(", "mode", ")", ")", "return", "true", ";", "else", "if", "(", "VALID_DFP_MODE_P", "(", "mode", ")", ")", "return", "true", ";", "else", "if", "(", "VALID_MMX_REG_MODE_3DNOW", "(", "mode", ")", "||", "VALID_MMX_REG_MODE", "(", "mode", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "hard", "register", "REGNO", "can", "hold", "a", "value", "of", "machine-mode", "MODE", "." ]

[ "i386" ]

[]

[ "<s>", "static", "void", "ix86_emit_save_regs", "(", "void", ")", "{", "unsigned", "int", "regno", ";", "rtx", "insn", ";", "for", "(", "regno", "=", "FIRST_PSEUDO_REGISTER", "-", "1", ";", "regno", "--", ">", "0", ";", ")", "if", "(", "!", "SSE_REGNO_P", "(", "regno", ")", "&&", "ix86_save_reg", "(", "regno", ",", "true", ")", ")", "{", "insn", "=", "emit_insn", "(", "gen_push", "(", "gen_rtx_REG", "(", "word_mode", ",", "regno", ")", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "save", "registers", "in", "the", "prologue", "." ]

[ "i386", "1", "0", "1" ]

[]

[ "<s>", "rtx", "m68k_legitimize_tls_address", "(", "rtx", "orig", ")", "{", "switch", "(", "SYMBOL_REF_TLS_MODEL", "(", "orig", ")", ")", "{", "case", "TLS_MODEL_GLOBAL_DYNAMIC", ":", "orig", "=", "m68k_call_tls_get_addr", "(", "orig", ",", "orig", ",", "RELOC_TLSGD", ")", ";", "break", ";", "case", "TLS_MODEL_LOCAL_DYNAMIC", ":", "{", "rtx", "eqv", ";", "rtx", "a0", ";", "rtx", "x", ";", "eqv", "=", "gen_rtx_UNSPEC", "(", "Pmode", ",", "gen_rtvec", "(", "1", ",", "const0_rtx", ")", ",", "UNSPEC_RELOC32", ")", ";", "a0", "=", "m68k_call_tls_get_addr", "(", "orig", ",", "eqv", ",", "RELOC_TLSLDM", ")", ";", "x", "=", "m68k_wrap_symbol", "(", "orig", ",", "RELOC_TLSLDO", ",", "a0", ",", "NULL_RTX", ")", ";", "if", "(", "can_create_pseudo_p", "(", ")", ")", "x", "=", "m68k_move_to_reg", "(", "x", ",", "orig", ",", "NULL_RTX", ")", ";", "orig", "=", "x", ";", "break", ";", "}", "case", "TLS_MODEL_INITIAL_EXEC", ":", "{", "rtx", "a0", ";", "rtx", "x", ";", "a0", "=", "m68k_call_m68k_read_tp", "(", ")", ";", "x", "=", "m68k_wrap_symbol_into_got_ref", "(", "orig", ",", "RELOC_TLSIE", ",", "NULL_RTX", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "x", ",", "a0", ")", ";", "if", "(", "can_create_pseudo_p", "(", ")", ")", "x", "=", "m68k_move_to_reg", "(", "x", ",", "orig", ",", "NULL_RTX", ")", ";", "orig", "=", "x", ";", "break", ";", "}", "case", "TLS_MODEL_LOCAL_EXEC", ":", "{", "rtx", "a0", ";", "rtx", "x", ";", "a0", "=", "m68k_call_m68k_read_tp", "(", ")", ";", "x", "=", "m68k_wrap_symbol", "(", "orig", ",", "RELOC_TLSLE", ",", "a0", ",", "NULL_RTX", ")", ";", "if", "(", "can_create_pseudo_p", "(", ")", ")", "x", "=", "m68k_move_to_reg", "(", "x", ",", "orig", ",", "NULL_RTX", ")", ";", "orig", "=", "x", ";", "break", ";", "}", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "orig", ";", "}", "</s>" ]

[ "Return", "a", "legitimized", "address", "for", "accessing", "TLS", "SYMBOL_REF", "X", ".", "For", "explanations", "on", "instructions", "sequences", "see", "TLS/NPTL", "ABI", "for", "m68k", "and", "ColdFire", "." ]

[ "m68k", "1" ]

[]

[ "<s>", "bool", "HexagonTargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "I", ",", "MachineFunction", "&", "MF", ",", "unsigned", "Intrinsic", ")", "const", "{", "switch", "(", "Intrinsic", ")", "{", "case", "Intrinsic", "::", "hexagon_V6_vgathermw", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermw_128B", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermh", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermh_128B", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermhw", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermhw_128B", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermwq", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermwq_128B", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermhq", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermhq_128B", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermhwq", ":", "case", "Intrinsic", "::", "hexagon_V6_vgathermhwq_128B", ":", "{", "const", "Module", "&", "M", "=", "*", "I", ".", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Type", "*", "VecTy", "=", "I", ".", "getArgOperand", "(", "1", ")", "->", "getType", "(", ")", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "VecTy", ")", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "0", ";", "Info", ".", "align", "=", "M", ".", "getDataLayout", "(", ")", ".", "getTypeAllocSizeInBits", "(", "VecTy", ")", "/", "8", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOStore", "|", "MachineMemOperand", "::", "MOVolatile", ";", "return", "true", ";", "}", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Given", "an", "intrinsic", ",", "checks", "if", "on", "the", "target", "the", "intrinsic", "will", "need", "to", "map", "to", "a", "MemIntrinsicNode", "(", "touches", "memory", ")", "." ]

[ "Hexagon", "Hexagon", "Intrinsic::hexagon_V6_vgathermw", "Intrinsic::hexagon_V6_vgathermw_128B", "Intrinsic::hexagon_V6_vgathermh", "Intrinsic::hexagon_V6_vgathermh_128B", "Intrinsic::hexagon_V6_vgathermhw", "Intrinsic::hexagon_V6_vgathermhw_128B", "Intrinsic::hexagon_V6_vgathermwq", "Intrinsic::hexagon_V6_vgathermwq_128B", "Intrinsic::hexagon_V6_vgathermhq", "Intrinsic::hexagon_V6_vgathermhq_128B", "Intrinsic::hexagon_V6_vgathermhwq", "Intrinsic::hexagon_V6_vgathermhwq_128B", "ISD::INTRINSIC_W_CHAIN", "1", "MVT::getVT", "0", "0", "8" ]

[]

[ "<s>", "MachineBasicBlock", "*", "SITargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "BB", ")", "const", "{", "MachineBasicBlock", "::", "iterator", "I", "=", "*", "MI", ";", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "Subtarget", "->", "getInstrInfo", "(", ")", ")", ";", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "AMDGPUTargetLowering", "::", "EmitInstrWithCustomInserter", "(", "MI", ",", "BB", ")", ";", "case", "AMDGPU", "::", "BRANCH", ":", "return", "BB", ";", "case", "AMDGPU", "::", "V_SUB_F64", ":", "{", "unsigned", "DestReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "BuildMI", "(", "*", "BB", ",", "I", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "V_ADD_F64", ")", ",", "DestReg", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ")", ".", "addImm", "(", "1", ")", ".", "addReg", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "case", "AMDGPU", "::", "SI_RegisterStorePseudo", ":", "{", "MachineRegisterInfo", "&", "MRI", "=", "BB", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "unsigned", "Reg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "AMDGPU", "::", "SReg_64RegClass", ")", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "*", "BB", ",", "I", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "SI_RegisterStore", ")", ",", "Reg", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "MI", "->", "getNumOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "MIB", ".", "addOperand", "(", "MI", "->", "getOperand", "(", "i", ")", ")", ";", "MI", "->", "eraseFromParent", "(", ")", ";", "break", ";", "}", "}", "return", "BB", ";", "}", "</s>" ]

[ "This", "method", "should", "be", "implemented", "by", "targets", "that", "mark", "instructions", "with", "the", "'usesCustomInserter", "'", "flag", "." ]

[ "R600", "SI", "SI", "SI", "0", "0", "1", "1", "2", "0", "0", "SI", "SI", "0" ]

[]

[ "<s>", "unsigned", "X86InstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "if", "(", "isFrameLoadOpcode", "(", "MI", ".", "getOpcode", "(", ")", ")", ")", "if", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", "&&", "isFrameOperand", "(", "MI", ",", "1", ",", "FrameIndex", ")", ")", "return", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "isLoadFromStackSlot", "-", "If", "the", "specified", "machine", "instruction", "is", "a", "direct", "load", "from", "a", "stack", "slot", ",", "return", "the", "virtual", "or", "physical", "register", "number", "of", "the", "destination", "along", "with", "the", "FrameIndex", "of", "the", "loaded", "stack", "slot", "." ]

[ "X86", "X86", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "bool", "ARMFastISel", "::", "isTypeLegal", "(", "const", "Type", "*", "Ty", ",", "EVT", "&", "VT", ")", "{", "VT", "=", "TLI", ".", "getValueType", "(", "Ty", ",", "true", ")", ";", "if", "(", "VT", "==", "MVT", "::", "Other", "||", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "return", "TLI", ".", "isTypeLegal", "(", "VT", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "type", "is", "legal", "." ]

[ "ARM", "ARM", "MVT::Other" ]

[]

[ "<s>", "static", "unsigned", "int", "pa_function_arg_boundary", "(", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "bool", "singleword", "=", "(", "type", "?", "(", "integer_zerop", "(", "TYPE_SIZE", "(", "type", ")", ")", "||", "!", "TREE_CONSTANT", "(", "TYPE_SIZE", "(", "type", ")", ")", "||", "int_size_in_bytes", "(", "type", ")", "<=", "UNITS_PER_WORD", ")", ":", "GET_MODE_SIZE", "(", "mode", ")", "<=", "UNITS_PER_WORD", ")", ";", "return", "singleword", "?", "PARM_BOUNDARY", ":", "MAX_PARM_BOUNDARY", ";", "}", "</s>" ]

[ "Arguments", "larger", "than", "one", "word", "are", "double", "word", "aligned", "." ]

[ "pa" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"OR1K Delay Slot Filler\"", ";", "}", "</s>" ]

[ "getPassName", "-", "Return", "a", "nice", "clean", "name", "for", "a", "pass", "." ]

[ "OR1K", "\"OR1K Delay Slot Filler\"" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "shouldFoldMaskToVariableShiftPair", "(", "SDValue", "Y", ")", "const", "{", "EVT", "VT", "=", "Y", ".", "getValueType", "(", ")", ";", "if", "(", "VT", ".", "isVector", "(", ")", ")", "return", "false", ";", "if", "(", "VT", "==", "MVT", "::", "i64", "&&", "!", "Subtarget", ".", "is64Bit", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "There", "are", "two", "ways", "to", "clear", "extreme", "bits", "(", "either", "low", "or", "high", ")", ":", "Mask", ":", "x", "&", "(", "-1", "<", "<", "y", ")", "(", "the", "instcombine", "canonical", "form", ")", "Shifts", ":", "x", ">", ">", "y", "<", "<", "y", "Return", "true", "if", "the", "variant", "with", "2", "variable", "shifts", "is", "preferred", "." ]

[ "X86", "X86", "MVT::i64" ]

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "X86TargetMachine", "&", "TM", ",", "unsigned", "StackAlignOverride", ")", ":", "X86GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "X86ProcFamily", "(", "Others", ")", ",", "PICStyle", "(", "PICStyles", "::", "None", ")", ",", "TM", "(", "TM", ")", ",", "TargetTriple", "(", "TT", ")", ",", "StackAlignOverride", "(", "StackAlignOverride", ")", ",", "In64BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", ",", "In32BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "!=", "Triple", "::", "CODE16", ")", ",", "In16BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "CODE16", ")", ",", "TSInfo", "(", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", ",", "FrameLowering", "(", "*", "this", ",", "getStackAlignment", "(", ")", ")", "{", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "Static", ")", "{", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "is64Bit", "(", ")", ")", "{", "setPICStyle", "(", "PICStyles", "::", "RIPRel", ")", ";", "}", "else", "if", "(", "isTargetCOFF", "(", ")", ")", "{", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "}", "else", "if", "(", "isTargetDarwin", "(", ")", ")", "{", "if", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "PIC_", ")", "setPICStyle", "(", "PICStyles", "::", "StubPIC", ")", ";", "else", "{", "assert", "(", "TM", ".", "getRelocationModel", "(", ")", "==", "Reloc", "::", "DynamicNoPIC", ")", ";", "setPICStyle", "(", "PICStyles", "::", "StubDynamicNoPIC", ")", ";", "}", "}", "else", "if", "(", "isTargetELF", "(", ")", ")", "{", "setPICStyle", "(", "PICStyles", "::", "GOT", ")", ";", "}", "}", "</s>" ]

[ "This", "constructor", "initializes", "the", "data", "members", "to", "match", "that", "of", "the", "specified", "triple", "." ]

[ "X86", "X86", "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "std", "::", "unique_ptr", "<", "CSEConfigBase", ">", "X86PassConfig", "::", "getCSEConfig", "(", ")", "const", "{", "return", "getStandardCSEConfigForOpt", "(", "TM", "->", "getOptLevel", "(", ")", ")", ";", "}", "</s>" ]

[ "Returns", "the", "CSEConfig", "object", "to", "use", "for", "the", "current", "optimization", "level", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "void", "HexagonFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "auto", "&", "HRI", "=", "*", "MF", ".", "getSubtarget", "<", "HexagonSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "SavedRegs", ".", "resize", "(", "HRI", ".", "getNumRegs", "(", ")", ")", ";", "if", "(", "MF", ".", "getInfo", "<", "HexagonMachineFunctionInfo", ">", "(", ")", "->", "hasEHReturn", "(", ")", ")", "for", "(", "const", "MCPhysReg", "*", "R", "=", "HRI", ".", "getCalleeSavedRegs", "(", "&", "MF", ")", ";", "*", "R", ";", "++", "R", ")", "SavedRegs", ".", "set", "(", "*", "R", ")", ";", "SmallVector", "<", "unsigned", ",", "8", ">", "NewRegs", ";", "expandSpillMacros", "(", "MF", ",", "NewRegs", ")", ";", "if", "(", "OptimizeSpillSlots", "&&", "!", "isOptNone", "(", "MF", ")", ")", "optimizeSpillSlots", "(", "MF", ",", "NewRegs", ")", ";", "if", "(", "!", "NewRegs", ".", "empty", "(", ")", "||", "mayOverflowFrameOffset", "(", "MF", ")", ")", "{", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "SetVector", "<", "const", "TargetRegisterClass", "*", ">", "SpillRCs", ";", "SpillRCs", ".", "insert", "(", "&", "Hexagon", "::", "IntRegsRegClass", ")", ";", "for", "(", "unsigned", "VR", ":", "NewRegs", ")", "SpillRCs", ".", "insert", "(", "MRI", ".", "getRegClass", "(", "VR", ")", ")", ";", "for", "(", "auto", "*", "RC", ":", "SpillRCs", ")", "{", "if", "(", "!", "needToReserveScavengingSpillSlots", "(", "MF", ",", "HRI", ",", "RC", ")", ")", "continue", ";", "unsigned", "Num", "=", "RC", "==", "&", "Hexagon", "::", "IntRegsRegClass", "?", "NumberScavengerSlots", ":", "1", ";", "unsigned", "S", "=", "HRI", ".", "getSpillSize", "(", "*", "RC", ")", ",", "A", "=", "HRI", ".", "getSpillAlignment", "(", "*", "RC", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Num", ";", "i", "++", ")", "{", "int", "NewFI", "=", "MFI", ".", "CreateSpillStackObject", "(", "S", ",", "A", ")", ";", "RS", "->", "addScavengingFrameIndex", "(", "NewFI", ")", ";", "}", "}", "}", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "}", "</s>" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "8", "Hexagon::IntRegsRegClass", "Hexagon::IntRegsRegClass", "1", "0" ]

[]

[ "<s>", "void", "ARMBaseRegisterInfo", "::", "resolveFrameIndex", "(", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", ".", "getParent", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "ARMBaseInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "ARMBaseInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "ARMFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "int", "Off", "=", "Offset", ";", "unsigned", "i", "=", "0", ";", "assert", "(", "!", "AFI", "->", "isThumb1OnlyFunction", "(", ")", "&&", "\"This resolveFrameIndex does not support Thumb1!\"", ")", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "bool", "Done", "=", "false", ";", "if", "(", "!", "AFI", "->", "isThumbFunction", "(", ")", ")", "Done", "=", "rewriteARMFrameIndex", "(", "MI", ",", "i", ",", "BaseReg", ",", "Off", ",", "TII", ")", ";", "else", "{", "assert", "(", "AFI", "->", "isThumb2Function", "(", ")", ")", ";", "Done", "=", "rewriteT2FrameIndex", "(", "MI", ",", "i", ",", "BaseReg", ",", "Off", ",", "TII", ")", ";", "}", "assert", "(", "Done", "&&", "\"Unable to resolve frame index!\"", ")", ";", "(", "void", ")", "Done", ";", "}", "</s>" ]

[ "Resolve", "a", "frame", "index", "operand", "of", "an", "instruction", "to", "reference", "the", "indicated", "base", "register", "plus", "offset", "instead", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARM", "ARM", "0", "\"This resolveFrameIndex does not support Thumb1!\"", "\"Instr doesn't have FrameIndex operand!\"", "ARM", "\"Unable to resolve frame index!\"" ]

[]

[ "<s>", "M68kTargetLowering", "::", "ConstraintType", "M68kTargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", ">", "0", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "case", "'a'", ":", "case", "'d'", ":", "return", "C_RegisterClass", ";", "case", "'I'", ":", "case", "'J'", ":", "case", "'K'", ":", "case", "'L'", ":", "case", "'M'", ":", "case", "'N'", ":", "case", "'O'", ":", "case", "'P'", ":", "return", "C_Immediate", ";", "case", "'C'", ":", "if", "(", "Constraint", ".", "size", "(", ")", "==", "2", ")", "switch", "(", "Constraint", "[", "1", "]", ")", "{", "case", "'0'", ":", "case", "'i'", ":", "case", "'j'", ":", "return", "C_Immediate", ";", "default", ":", "break", ";", "}", "break", ";", "default", ":", "break", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

[ "Given", "a", "constraint", "letter", ",", "return", "the", "type", "of", "constraint", "for", "this", "target", "." ]

[ "M68k", "M68k", "M68k", "0", "0", "2", "1" ]

[]

[ "<s>", "bool", "X86ATTAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "bool", "Result", "=", "AsmPrinter", "::", "doInitialization", "(", "M", ")", ";", "if", "(", "TAI", "->", "doesSupportDebugInformation", "(", ")", ")", "{", "MMI", "=", "getAnalysisIfAvailable", "<", "MachineModuleInfo", ">", "(", ")", ";", "DW", "=", "getAnalysisIfAvailable", "<", "DwarfWriter", ">", "(", ")", ";", "DW", "->", "BeginModule", "(", "&", "M", ",", "MMI", ",", "O", ",", "this", ",", "TAI", ")", ";", "}", "if", "(", "Subtarget", "->", "isTargetDarwin", "(", ")", ")", "Mang", "->", "setUseQuotes", "(", "true", ")", ";", "return", "Result", ";", "}", "</s>" ]

[ "Set", "up", "the", "AsmPrinter", "when", "we", "are", "working", "on", "a", "new", "module", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "const", "SystemZRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "getSubtargetImpl", "(", ")", "->", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

[ "getRegisterInfo", "-", "TargetInstrInfo", "is", "a", "superset", "of", "MRegister", "info", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "void", "PPCFrameLowering", "::", "determineCalleeSaves", "(", "MachineFunction", "&", "MF", ",", "BitVector", "&", "SavedRegs", ",", "RegScavenger", "*", "RS", ")", "const", "{", "TargetFrameLowering", "::", "determineCalleeSaves", "(", "MF", ",", "SavedRegs", ",", "RS", ")", ";", "const", "PPCRegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "PPCFunctionInfo", "*", "FI", "=", "MF", ".", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "unsigned", "LR", "=", "RegInfo", "->", "getRARegister", "(", ")", ";", "FI", "->", "setMustSaveLR", "(", "MustSaveLR", "(", "MF", ",", "LR", ")", ")", ";", "SavedRegs", ".", "reset", "(", "LR", ")", ";", "int", "FPSI", "=", "FI", "->", "getFramePointerSaveIndex", "(", ")", ";", "bool", "isPPC64", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "bool", "isDarwinABI", "=", "Subtarget", ".", "isDarwinABI", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "if", "(", "!", "FPSI", "&&", "needsFP", "(", "MF", ")", ")", "{", "int", "FPOffset", "=", "getFramePointerSaveOffset", "(", ")", ";", "FPSI", "=", "MFI", ".", "CreateFixedObject", "(", "isPPC64", "?", "8", ":", "4", ",", "FPOffset", ",", "true", ")", ";", "FI", "->", "setFramePointerSaveIndex", "(", "FPSI", ")", ";", "}", "int", "BPSI", "=", "FI", "->", "getBasePointerSaveIndex", "(", ")", ";", "if", "(", "!", "BPSI", "&&", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", "{", "int", "BPOffset", "=", "getBasePointerSaveOffset", "(", ")", ";", "BPSI", "=", "MFI", ".", "CreateFixedObject", "(", "isPPC64", "?", "8", ":", "4", ",", "BPOffset", ",", "true", ")", ";", "FI", "->", "setBasePointerSaveIndex", "(", "BPSI", ")", ";", "}", "if", "(", "FI", "->", "usesPICBase", "(", ")", ")", "{", "int", "PBPSI", "=", "MFI", ".", "CreateFixedObject", "(", "4", ",", "-", "8", ",", "true", ")", ";", "FI", "->", "setPICBasePointerSaveIndex", "(", "PBPSI", ")", ";", "}", "if", "(", "needsFP", "(", "MF", ")", ")", "SavedRegs", ".", "reset", "(", "isPPC64", "?", "PPC", "::", "X31", ":", "PPC", "::", "R31", ")", ";", "if", "(", "RegInfo", "->", "hasBasePointer", "(", "MF", ")", ")", "SavedRegs", ".", "reset", "(", "RegInfo", "->", "getBaseRegister", "(", "MF", ")", ")", ";", "if", "(", "FI", "->", "usesPICBase", "(", ")", ")", "SavedRegs", ".", "reset", "(", "PPC", "::", "R30", ")", ";", "int", "TCSPDelta", "=", "0", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", "&&", "(", "TCSPDelta", "=", "FI", "->", "getTailCallSPDelta", "(", ")", ")", "<", "0", ")", "{", "MFI", ".", "CreateFixedObject", "(", "-", "1", "*", "TCSPDelta", ",", "TCSPDelta", ",", "true", ")", ";", "}", "if", "(", "!", "isPPC64", "&&", "!", "isDarwinABI", "&&", "(", "SavedRegs", ".", "test", "(", "PPC", "::", "CR2", ")", "||", "SavedRegs", ".", "test", "(", "PPC", "::", "CR3", ")", "||", "SavedRegs", ".", "test", "(", "PPC", "::", "CR4", ")", ")", ")", "{", "int", "FrameIdx", "=", "MFI", ".", "CreateFixedObject", "(", "(", "uint64_t", ")", "4", ",", "(", "int64_t", ")", "-", "4", ",", "true", ")", ";", "FI", "->", "setCRSpillFrameIndex", "(", "FrameIdx", ")", ";", "}", "}", "</s>" ]

[ "This", "method", "determines", "which", "of", "the", "registers", "reported", "by", "TargetRegisterInfo", ":", ":getCalleeSavedRegs", "(", ")", "should", "actually", "get", "saved", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "PPC", "8", "4", "PPC", "8", "4", "4", "8", "PPC", "PPC::X31", "PPC::R31", "PPC::R30", "0", "0", "1", "PPC", "PPC::CR2", "PPC::CR3", "PPC::CR4", "4", "4" ]

[]

[ "<s>", "const", "MCExpr", "*", "getSubExpr", "(", ")", "const", "{", "return", "Expr", ";", "}", "</s>" ]

[ "getSubExpr", "-", "Get", "the", "child", "of", "this", "expression", "." ]

[ "ARM64" ]

[]