Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "bool", "AArch64FrameLowering", "::", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "DL", ";", "SmallVector", "<", "RegPairInfo", ",", "8", ">", "RegPairs", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "computeCalleeSaveRegisterPairs", "(", "MF", ",", "CSI", ",", "TRI", ",", "RegPairs", ")", ";", "for", "(", "auto", "RPII", "=", "RegPairs", ".", "begin", "(", ")", ",", "RPIE", "=", "RegPairs", ".", "end", "(", ")", ";", "RPII", "!=", "RPIE", ";", "++", "RPII", ")", "{", "RegPairInfo", "RPI", "=", "*", "RPII", ";", "unsigned", "Reg1", "=", "RPI", ".", "Reg1", ";", "unsigned", "Reg2", "=", "RPI", ".", "Reg2", ";", "unsigned", "LdrOpc", ";", "bool", "BumpSP", "=", "RPII", "==", "std", "::", "prev", "(", "RegPairs", ".", "end", "(", ")", ")", ";", "if", "(", "RPI", ".", "IsGPR", ")", "{", "if", "(", "BumpSP", ")", "LdrOpc", "=", "RPI", ".", "isPaired", "(", ")", "?", "AArch64", "::", "LDPXpost", ":", "AArch64", "::", "LDRXpost", ";", "else", "LdrOpc", "=", "RPI", ".", "isPaired", "(", ")", "?", "AArch64", "::", "LDPXi", ":", "AArch64", "::", "LDRXui", ";", "}", "else", "{", "if", "(", "BumpSP", ")", "LdrOpc", "=", "RPI", ".", "isPaired", "(", ")", "?", "AArch64", "::", "LDPDpost", ":", "AArch64", "::", "LDRDpost", ";", "else", "LdrOpc", "=", "RPI", ".", "isPaired", "(", ")", "?", "AArch64", "::", "LDPDi", ":", "AArch64", "::", "LDRDui", ";", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"CSR restore: (\"", "<<", "TRI", "->", "getName", "(", "Reg1", ")", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "dbgs", "(", ")", "<<", "\", \"", "<<", "TRI", "->", "getName", "(", "Reg2", ")", ";", "dbgs", "(", ")", "<<", "\") -> fi#(\"", "<<", "RPI", ".", "FrameIdx", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "dbgs", "(", ")", "<<", "\", \"", "<<", "RPI", ".", "FrameIdx", "+", "1", ";", "dbgs", "(", ")", "<<", "\")\\n\"", ")", ";", "const", "int", "Offset", "=", "RPI", ".", "Offset", ";", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "LdrOpc", ")", ")", ";", "if", "(", "BumpSP", ")", "MIB", ".", "addReg", "(", "AArch64", "::", "SP", ",", "RegState", "::", "Define", ")", ";", "if", "(", "RPI", ".", "isPaired", "(", ")", ")", "MIB", ".", "addReg", "(", "Reg2", ",", "getDefRegState", "(", "true", ")", ")", ".", "addReg", "(", "Reg1", ",", "getDefRegState", "(", "true", ")", ")", ".", "addReg", "(", "AArch64", "::", "SP", ")", ".", "addImm", "(", "Offset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "else", "MIB", ".", "addReg", "(", "Reg1", ",", "getDefRegState", "(", "true", ")", ")", ".", "addReg", "(", "AArch64", "::", "SP", ")", ".", "addImm", "(", "BumpSP", "?", "Offset", "*", "8", ":", "Offset", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "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", "(", ")", "." ]

[ "AArch64", "AArch64", "8", "AArch64::LDPXpost", "AArch64::LDRXpost", "AArch64::LDPXi", "AArch64::LDRXui", "AArch64::LDPDpost", "AArch64::LDRDpost", "AArch64::LDPDi", "AArch64::LDRDui", "\"CSR restore: (\"", "\", \"", "\") -> fi#(\"", "\", \"", "1", "\")\\n\"", "AArch64::SP", "AArch64::SP", "AArch64::SP", "8" ]

[]

[ "<s>", "virtual", "const", "MCObjectFormat", "&", "getObjectFormat", "(", ")", "const", "{", "return", "Format", ";", "}", "</s>" ]

[ "Get", "the", "object", "format", "for", "this", "triple", "." ]

[ "MBlaze" ]

[]

[ "<s>", "static", "int", "ix86_reassociation_width", "(", "unsigned", "int", ",", "machine_mode", "mode", ")", "{", "if", "(", "VECTOR_MODE_P", "(", "mode", ")", ")", "{", "if", "(", "TARGET_VECTOR_PARALLEL_EXECUTION", ")", "return", "2", ";", "else", "return", "1", ";", "}", "if", "(", "INTEGRAL_MODE_P", "(", "mode", ")", "&&", "TARGET_REASSOC_INT_TO_PARALLEL", ")", "return", "2", ";", "else", "if", "(", "FLOAT_MODE_P", "(", "mode", ")", "&&", "TARGET_REASSOC_FP_TO_PARALLEL", ")", "return", "(", "(", "TARGET_64BIT", "&&", "ix86_tune", "==", "PROCESSOR_HASWELL", ")", "?", "4", ":", "2", ")", ";", "else", "return", "1", ";", "}", "</s>" ]

[ "Implementation", "of", "reassociation_width", "target", "hook", "used", "by", "reassoc", "phase", "to", "identify", "parallelism", "level", "in", "reassociated", "tree", ".", "Statements", "tree_code", "is", "passed", "in", "OPC", ".", "Arguments", "type", "is", "passed", "in", "MODE", ".", "Currently", "parallel", "reassociation", "is", "enabled", "for", "Atom", "processors", "only", "and", "we", "set", "reassociation", "width", "to", "be", "2", "because", "Atom", "may", "issue", "up", "to", "2", "instructions", "per", "cycle", ".", "Return", "value", "should", "be", "fixed", "if", "parallel", "reassociation", "is", "enabled", "for", "other", "processors", "." ]

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

[]

[ "<s>", "bool", "ARM64PassConfig", "::", "addPostRegAlloc", "(", ")", "{", "if", "(", "TM", "->", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", "&&", "EnableDeadRegisterElimination", ")", "addPass", "(", "createARM64DeadRegisterDefinitions", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "register", "allocation", "pass", "pipeline", "but", "before", "prolog-epilog", "insertion", "." ]

[ "ARM64", "ARM64", "ARM64" ]

[]

[ "<s>", "BitVector", "R600RegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "ZERO", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "HALF", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "ONE", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "ONE_INT", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "NEG_HALF", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "NEG_ONE", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "PV_X", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "ALU_LITERAL_X", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "ALU_CONST", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "PREDICATE_BIT", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "PRED_SEL_OFF", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "PRED_SEL_ZERO", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "PRED_SEL_ONE", ")", ";", "for", "(", "TargetRegisterClass", "::", "iterator", "I", "=", "AMDGPU", "::", "R600_AddrRegClass", ".", "begin", "(", ")", ",", "E", "=", "AMDGPU", "::", "R600_AddrRegClass", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Reserved", ".", "set", "(", "*", "I", ")", ";", "}", "for", "(", "TargetRegisterClass", "::", "iterator", "I", "=", "AMDGPU", "::", "TRegMemRegClass", ".", "begin", "(", ")", ",", "E", "=", "AMDGPU", "::", "TRegMemRegClass", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Reserved", ".", "set", "(", "*", "I", ")", ";", "}", "const", "R600InstrInfo", "*", "RII", "=", "static_cast", "<", "const", "R600InstrInfo", "*", ">", "(", "TM", ".", "getInstrInfo", "(", ")", ")", ";", "std", "::", "vector", "<", "unsigned", ">", "IndirectRegs", "=", "RII", "->", "getIndirectReservedRegs", "(", "MF", ")", ";", "for", "(", "std", "::", "vector", "<", "unsigned", ">", "::", "iterator", "I", "=", "IndirectRegs", ".", "begin", "(", ")", ",", "E", "=", "IndirectRegs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "Reserved", ".", "set", "(", "*", "I", ")", ";", "}", "return", "Reserved", ";", "}", "</s>" ]

[ "getReservedRegs", "-", "Returns", "a", "bitset", "indexed", "by", "physical", "register", "number", "indicating", "if", "a", "register", "is", "a", "special", "register", "that", "has", "particular", "uses", "and", "should", "be", "considered", "unavailable", "at", "all", "times", ",", "e.g", "." ]

[ "R600" ]

[]

[ "<s>", "SDValue", "SITargetLowering", "::", "handleD16VData", "(", "SDValue", "VData", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "EVT", "StoreVT", "=", "VData", ".", "getValueType", "(", ")", ";", "if", "(", "!", "StoreVT", ".", "isVector", "(", ")", ")", "return", "VData", ";", "SDLoc", "DL", "(", "VData", ")", ";", "assert", "(", "(", "StoreVT", ".", "getVectorNumElements", "(", ")", "!=", "3", ")", "&&", "\"Handle v3f16\"", ")", ";", "if", "(", "Subtarget", "->", "hasUnpackedD16VMem", "(", ")", ")", "{", "EVT", "IntStoreVT", "=", "StoreVT", ".", "changeTypeToInteger", "(", ")", ";", "SDValue", "IntVData", "=", "DAG", ".", "getNode", "(", "ISD", "::", "BITCAST", ",", "DL", ",", "IntStoreVT", ",", "VData", ")", ";", "EVT", "EquivStoreVT", "=", "EVT", "::", "getVectorVT", "(", "*", "DAG", ".", "getContext", "(", ")", ",", "MVT", "::", "i32", ",", "StoreVT", ".", "getVectorNumElements", "(", ")", ")", ";", "SDValue", "ZExt", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "DL", ",", "EquivStoreVT", ",", "IntVData", ")", ";", "return", "DAG", ".", "UnrollVectorOp", "(", "ZExt", ".", "getNode", "(", ")", ")", ";", "}", "assert", "(", "isTypeLegal", "(", "StoreVT", ")", ")", ";", "return", "VData", ";", "}", "</s>" ]

[ "Handle", "register", "layout", "difference", "for", "f16", "images", "for", "some", "subtargets", "." ]

[ "AMDGPU", "SI", "3", "\"Handle v3f16\"", "ISD::BITCAST", "MVT::i32", "ISD::ZERO_EXTEND" ]

[]

[ "<s>", "MCFragment", "*", "findAssociatedFragment", "(", ")", "const", "override", "{", "return", "getSubExpr", "(", ")", "->", "findAssociatedFragment", "(", ")", ";", "}", "</s>" ]

[ "Find", "the", "``", "associated", "section", "''", "for", "this", "expression", ",", "which", "is", "currently", "defined", "as", "the", "absolute", "section", "for", "constants", ",", "or", "otherwise", "the", "section", "associated", "with", "the", "first", "defined", "symbol", "in", "the", "expression", "." ]

[ "RI5CY" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "LiveIntervals", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "LiveIntervals", ">", "(", ")", ";", "AU", ".", "addPreserved", "<", "SlotIndexes", ">", "(", ")", ";", "AU", ".", "setPreservesCFG", "(", ")", ";", "MachineFunctionPass", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "unsigned", "int", "call_properties", "(", "const", "function_instance", "&", ")", "const", "override", "{", "return", "0", ";", "}", "</s>" ]

[ "Default", "implementation", "of", "function_base", ":", ":call_properties", ",", "with", "conservatively", "correct", "behavior", "for", "floating-point", "instructions", "." ]

[ "aarch64", "0" ]

[]

[ "<s>", "const", "SystemZInstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "Subtarget", "->", "getInstrInfo", "(", ")", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "void", "GCNScheduleDAGMILive", "::", "finalizeSchedule", "(", ")", "{", "GCNMaxOccupancySchedStrategy", "&", "S", "=", "(", "GCNMaxOccupancySchedStrategy", "&", ")", "*", "SchedImpl", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"All regions recorded, starting actual scheduling.\\n\"", ")", ";", "LiveIns", ".", "resize", "(", "Regions", ".", "size", "(", ")", ")", ";", "Pressure", ".", "resize", "(", "Regions", ".", "size", "(", ")", ")", ";", "if", "(", "!", "Regions", ".", "empty", "(", ")", ")", "BBLiveInMap", "=", "getBBLiveInMap", "(", ")", ";", "do", "{", "Stage", "++", ";", "RegionIdx", "=", "0", ";", "MachineBasicBlock", "*", "MBB", "=", "nullptr", ";", "if", "(", "Stage", ">", "1", ")", "{", "if", "(", "!", "LIS", "||", "StartingOccupancy", "<=", "MinOccupancy", ")", "break", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Retrying function scheduling with lowest recorded occupancy \"", "<<", "MinOccupancy", "<<", "\".\\n\"", ")", ";", "S", ".", "setTargetOccupancy", "(", "MinOccupancy", ")", ";", "}", "for", "(", "auto", "Region", ":", "Regions", ")", "{", "RegionBegin", "=", "Region", ".", "first", ";", "RegionEnd", "=", "Region", ".", "second", ";", "if", "(", "RegionBegin", "->", "getParent", "(", ")", "!=", "MBB", ")", "{", "if", "(", "MBB", ")", "finishBlock", "(", ")", ";", "MBB", "=", "RegionBegin", "->", "getParent", "(", ")", ";", "startBlock", "(", "MBB", ")", ";", "if", "(", "Stage", "==", "1", ")", "computeBlockPressure", "(", "MBB", ")", ";", "}", "unsigned", "NumRegionInstrs", "=", "std", "::", "distance", "(", "begin", "(", ")", ",", "end", "(", ")", ")", ";", "enterRegion", "(", "MBB", ",", "begin", "(", ")", ",", "end", "(", ")", ",", "NumRegionInstrs", ")", ";", "if", "(", "begin", "(", ")", "==", "end", "(", ")", "||", "begin", "(", ")", "==", "std", "::", "prev", "(", "end", "(", ")", ")", ")", "{", "exitRegion", "(", ")", ";", "continue", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"********** MI Scheduling **********\\n\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "MF", ".", "getName", "(", ")", "<<", "\":\"", "<<", "printMBBReference", "(", "*", "MBB", ")", "<<", "\" \"", "<<", "MBB", "->", "getName", "(", ")", "<<", "\"\\n From: \"", "<<", "*", "begin", "(", ")", "<<", "\" To: \"", ";", "if", "(", "RegionEnd", "!=", "MBB", "->", "end", "(", ")", ")", "dbgs", "(", ")", "<<", "*", "RegionEnd", ";", "else", "dbgs", "(", ")", "<<", "\"End\"", ";", "dbgs", "(", ")", "<<", "\" RegionInstrs: \"", "<<", "NumRegionInstrs", "<<", "'\\n'", ")", ";", "schedule", "(", ")", ";", "exitRegion", "(", ")", ";", "++", "RegionIdx", ";", "}", "finishBlock", "(", ")", ";", "}", "while", "(", "Stage", "<", "2", ")", ";", "}", "</s>" ]

[ "After", "the", "schedule", "has", "been", "formed", ",", "call", "this", "function", "to", "combine", "the", "instructions", "from", "the", "different", "stages/cycles", "." ]

[ "AMDGPU", "\"All regions recorded, starting actual scheduling.\\n\"", "0", "1", "\"Retrying function scheduling with lowest recorded occupancy \"", "\".\\n\"", "1", "\"********** MI Scheduling **********\\n\"", "\":\"", "\" \"", "\"\\n From: \"", "\" To: \"", "\"End\"", "\" RegionInstrs: \"", "2" ]

[]

[ "<s>", "void", "emit_symbolic_move", "(", "rtx", "*", "operands", ")", "{", "rtx", "temp", "=", "no_new_pseudos", "?", "operands", "[", "0", "]", ":", "gen_reg_rtx", "(", "Pmode", ")", ";", "if", "(", "GET_CODE", "(", "operands", "[", "0", "]", ")", "==", "MEM", ")", "operands", "[", "1", "]", "=", "force_reg", "(", "Pmode", ",", "operands", "[", "1", "]", ")", ";", "else", "if", "(", "TLS_SYMBOLIC_CONST", "(", "operands", "[", "1", "]", ")", ")", "operands", "[", "1", "]", "=", "legitimize_tls_address", "(", "operands", "[", "1", "]", ",", "temp", ")", ";", "else", "if", "(", "flag_pic", ")", "operands", "[", "1", "]", "=", "legitimize_pic_address", "(", "operands", "[", "1", "]", ",", "temp", ")", ";", "}", "</s>" ]

[ "Emit", "insns", "to", "move", "operands", "[", "1", "]", "into", "operands", "[", "0", "]", "." ]

[ "s390", "0", "0", "1", "1", "1", "1", "1", "1", "1" ]

[]

[ "<s>", "const", "RISCVTargetLowering", "*", "getTLI", "(", ")", "const", "{", "return", "TLI", ";", "}", "</s>" ]

[ "Getter", "for", "generic", "TargetLowering", "class", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "static", "bool", "arc_function_ok_for_sibcall", "(", "tree", "decl", "ATTRIBUTE_UNUSED", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "ARC_INTERRUPT_P", "(", "arc_compute_function_type", "(", "cfun", ")", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "ok", "to", "make", "a", "tail-call", "to", "DECL", "." ]

[ "arc" ]

[]

[ "<s>", "static", "machine_mode", "mips_get_reg_raw_mode", "(", "int", "regno", ")", "{", "if", "(", "TARGET_FLOATXX", "&&", "FP_REG_P", "(", "regno", ")", ")", "return", "DFmode", ";", "return", "default_get_reg_raw_mode", "(", "regno", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_GET_RAW_RESULT_MODE", "and", "TARGET_GET_RAW_ARG_MODE", "." ]

[ "mips" ]

[]

[ "<s>", "void", "visium_split_cbranch", "(", "enum", "rtx_code", "code", ",", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "label", ")", "{", "enum", "machine_mode", "cc_mode", "=", "visium_select_cc_mode", "(", "code", ",", "op0", ",", "op1", ")", ";", "rtx", "flags", "=", "gen_rtx_REG", "(", "cc_mode", ",", "FLAGS_REGNUM", ")", ";", "rtx", "x", "=", "gen_rtx_COMPARE", "(", "cc_mode", ",", "op0", ",", "op1", ")", ";", "x", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "flags", ",", "x", ")", ";", "emit_insn", "(", "x", ")", ";", "x", "=", "gen_rtx_fmt_ee", "(", "code", ",", "VOIDmode", ",", "flags", ",", "const0_rtx", ")", ";", "x", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "x", ",", "gen_rtx_LABEL_REF", "(", "Pmode", ",", "label", ")", ",", "pc_rtx", ")", ";", "x", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "x", ")", ";", "emit_jump_insn", "(", "x", ")", ";", "visium_flags_exposed", "=", "true", ";", "}", "</s>" ]

[ "Split", "a", "compare-and-branch", "with", "CODE", ",", "operands", "OP0", "and", "OP1", ",", "and", "LABEL", "." ]

[ "visium" ]

[]

[ "<s>", "BaseKind", "getKind", "(", ")", "const", "{", "return", "Kind", ";", "}", "</s>" ]

[ "Returns", "the", "Kind", "of", "lane", "offset", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "virtual", "const", "TargetRegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ".", "getRegisterInfo", "(", ")", ";", "}", "</s>" ]

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

[ "Patmos" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "isInlineConstant", "(", "const", "MachineOperand", "&", "MO", ",", "uint8_t", "OperandType", ")", "const", "{", "if", "(", "!", "MO", ".", "isImm", "(", ")", "||", "OperandType", "<", "AMDGPU", "::", "OPERAND_SRC_FIRST", "||", "OperandType", ">", "AMDGPU", "::", "OPERAND_SRC_LAST", ")", "return", "false", ";", "int64_t", "Imm", "=", "MO", ".", "getImm", "(", ")", ";", "switch", "(", "OperandType", ")", "{", "case", "AMDGPU", "::", "OPERAND_REG_IMM_INT32", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP32", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP32_DEFERRED", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_INT32", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP32", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_V2FP32", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_V2FP32", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_V2INT32", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_V2INT32", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_AC_INT32", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_AC_FP32", ":", "{", "int32_t", "Trunc", "=", "static_cast", "<", "int32_t", ">", "(", "Imm", ")", ";", "return", "AMDGPU", "::", "isInlinableLiteral32", "(", "Trunc", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "case", "AMDGPU", "::", "OPERAND_REG_IMM_INT64", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP64", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_INT64", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP64", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_AC_FP64", ":", "return", "AMDGPU", "::", "isInlinableLiteral64", "(", "MO", ".", "getImm", "(", ")", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "case", "AMDGPU", "::", "OPERAND_REG_IMM_INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_AC_INT16", ":", "return", "AMDGPU", "::", "isInlinableIntLiteral", "(", "Imm", ")", ";", "case", "AMDGPU", "::", "OPERAND_REG_IMM_V2INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_V2INT16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_AC_V2INT16", ":", "return", "AMDGPU", "::", "isInlinableIntLiteralV216", "(", "Imm", ")", ";", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP16", ":", "case", "AMDGPU", "::", "OPERAND_REG_IMM_FP16_DEFERRED", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_FP16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_AC_FP16", ":", "{", "if", "(", "isInt", "<", "16", ">", "(", "Imm", ")", "||", "isUInt", "<", "16", ">", "(", "Imm", ")", ")", "{", "int16_t", "Trunc", "=", "static_cast", "<", "int16_t", ">", "(", "Imm", ")", ";", "return", "ST", ".", "has16BitInsts", "(", ")", "&&", "AMDGPU", "::", "isInlinableLiteral16", "(", "Trunc", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "return", "false", ";", "}", "case", "AMDGPU", "::", "OPERAND_REG_IMM_V2FP16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_C_V2FP16", ":", "case", "AMDGPU", "::", "OPERAND_REG_INLINE_AC_V2FP16", ":", "{", "uint32_t", "Trunc", "=", "static_cast", "<", "uint32_t", ">", "(", "Imm", ")", ";", "return", "AMDGPU", "::", "isInlinableLiteralV216", "(", "Trunc", ",", "ST", ".", "hasInv2PiInlineImm", "(", ")", ")", ";", "}", "default", ":", "llvm_unreachable", "(", "\"invalid bitwidth\"", ")", ";", "}", "}", "</s>" ]

[ "returns", "true", "if", "the", "operand", "OpIdx", "in", "MI", "is", "a", "valid", "inline", "immediate", "." ]

[ "AMDGPU", "SI", "AMDGPU::OPERAND_SRC_FIRST", "AMDGPU::OPERAND_SRC_LAST", "AMDGPU::OPERAND_REG_IMM_INT32", "AMDGPU::OPERAND_REG_IMM_FP32", "AMDGPU::OPERAND_REG_IMM_FP32_DEFERRED", "AMDGPU::OPERAND_REG_INLINE_C_INT32", "AMDGPU::OPERAND_REG_INLINE_C_FP32", "AMDGPU::OPERAND_REG_IMM_V2FP32", "AMDGPU::OPERAND_REG_INLINE_C_V2FP32", "AMDGPU::OPERAND_REG_IMM_V2INT32", "AMDGPU::OPERAND_REG_INLINE_C_V2INT32", "AMDGPU::OPERAND_REG_INLINE_AC_INT32", "AMDGPU::OPERAND_REG_INLINE_AC_FP32", "AMDGPU::isInlinableLiteral32", "AMDGPU::OPERAND_REG_IMM_INT64", "AMDGPU::OPERAND_REG_IMM_FP64", "AMDGPU::OPERAND_REG_INLINE_C_INT64", "AMDGPU::OPERAND_REG_INLINE_C_FP64", "AMDGPU::OPERAND_REG_INLINE_AC_FP64", "AMDGPU::isInlinableLiteral64", "AMDGPU::OPERAND_REG_IMM_INT16", "AMDGPU::OPERAND_REG_INLINE_C_INT16", "AMDGPU::OPERAND_REG_INLINE_AC_INT16", "AMDGPU::isInlinableIntLiteral", "AMDGPU::OPERAND_REG_IMM_V2INT16", "AMDGPU::OPERAND_REG_INLINE_C_V2INT16", "AMDGPU::OPERAND_REG_INLINE_AC_V2INT16", "AMDGPU::isInlinableIntLiteralV216", "AMDGPU::OPERAND_REG_IMM_FP16", "AMDGPU::OPERAND_REG_IMM_FP16_DEFERRED", "AMDGPU::OPERAND_REG_INLINE_C_FP16", "AMDGPU::OPERAND_REG_INLINE_AC_FP16", "16", "16", "AMDGPU::isInlinableLiteral16", "AMDGPU::OPERAND_REG_IMM_V2FP16", "AMDGPU::OPERAND_REG_INLINE_C_V2FP16", "AMDGPU::OPERAND_REG_INLINE_AC_V2FP16", "AMDGPU::isInlinableLiteralV216", "\"invalid bitwidth\"" ]

[]

[ "<s>", "SMLoc", "getStartLoc", "(", ")", "const", "override", "{", "return", "StartLoc", ";", "}", "</s>" ]

[ "getStartLoc", "-", "Get", "the", "location", "of", "the", "first", "token", "of", "this", "operand", "." ]

[ "MINA32" ]

[]

[ "<s>", "MachineInstrBuilder", "R600InstrInfo", "::", "buildDefaultInstruction", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "Opcode", ",", "unsigned", "DstReg", ",", "unsigned", "Src0Reg", ",", "unsigned", "Src1Reg", ")", "const", "{", "MachineInstrBuilder", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "MBB", ".", "findDebugLoc", "(", "I", ")", ",", "get", "(", "Opcode", ")", ",", "DstReg", ")", ";", "if", "(", "Src1Reg", ")", "{", "MIB", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ";", "}", "MIB", ".", "addImm", "(", "1", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "Src0Reg", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ";", "if", "(", "Src1Reg", ")", "{", "MIB", ".", "addReg", "(", "Src1Reg", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ".", "addImm", "(", "0", ")", ";", "}", "MIB", ".", "addImm", "(", "1", ")", ".", "addReg", "(", "AMDGPU", "::", "PRED_SEL_OFF", ")", ".", "addImm", "(", "0", ")", ";", "return", "MIB", ";", "}", "</s>" ]

[ "buildDefaultInstruction", "-", "This", "function", "returns", "a", "MachineInstr", "with", "all", "the", "instruction", "modifiers", "initialized", "to", "their", "default", "values", "." ]

[ "R600", "0", "0", "1", "0", "0", "0", "0", "0", "0", "0", "0", "0", "1", "0" ]

[]

[ "<s>", "int", "riscv_load_store_insns", "(", "rtx", "mem", ",", "rtx_insn", "*", "insn", ")", "{", "machine_mode", "mode", ";", "bool", "might_split_p", ";", "rtx", "set", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "might_split_p", "=", "true", ";", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "<=", "32", ")", "might_split_p", "=", "false", ";", "else", "if", "(", "GET_MODE_BITSIZE", "(", "mode", ")", "==", "64", ")", "{", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", "&&", "!", "riscv_split_64bit_move_p", "(", "SET_DEST", "(", "set", ")", ",", "SET_SRC", "(", "set", ")", ")", ")", "might_split_p", "=", "false", ";", "}", "return", "riscv_address_insns", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "mode", ",", "might_split_p", ")", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "needed", "to", "implement", "INSN", ",", "given", "that", "it", "loads", "from", "or", "stores", "to", "MEM", "." ]

[ "riscv", "32", "64", "0" ]

[]

[ "<s>", "void", "AVRInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "Register", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "AVRMachineFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "AVRMachineFunctionInfo", ">", "(", ")", ";", "AFI", "->", "setHasSpills", "(", "true", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "{", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "}", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlign", "(", "FrameIndex", ")", ")", ";", "unsigned", "Opcode", "=", "0", ";", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i8", ")", ")", "{", "Opcode", "=", "AVR", "::", "STDPtrQRr", ";", "}", "else", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i16", ")", ")", "{", "Opcode", "=", "AVR", "::", "STDWPtrQRr", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot store this register into a stack slot!\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "AVR", "AVR", "AVR", "AVR", "0", "MVT::i8", "AVR::STDPtrQRr", "MVT::i16", "AVR::STDWPtrQRr", "\"Cannot store this register into a stack slot!\"", "0" ]

[]

[ "<s>", "bool", "ARMBaseTargetMachine", "::", "addPreSched2", "(", "PassManagerBase", "&", "PM", ",", "CodeGenOpt", "::", "Level", "OptLevel", ")", "{", "if", "(", "OptLevel", "!=", "CodeGenOpt", "::", "None", ")", "{", "if", "(", "!", "Subtarget", ".", "isThumb1Only", "(", ")", ")", "PM", ".", "add", "(", "createARMLoadStoreOptimizationPass", "(", ")", ")", ";", "if", "(", "Subtarget", ".", "hasNEON", "(", ")", ")", "PM", ".", "add", "(", "createNEONMoveFixPass", "(", ")", ")", ";", "}", "PM", ".", "add", "(", "createARMExpandPseudoPass", "(", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "method", "may", "be", "implemented", "by", "targets", "that", "want", "to", "run", "passes", "after", "prolog-epilog", "insertion", "and", "before", "the", "second", "instruction", "scheduling", "pass", "." ]

[ "ARM", "ARM", "ARM", "ARM" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "I", ",", "unsigned", "Intrinsic", ")", "const", "{", "const", "IntrinsicData", "*", "IntrData", "=", "getIntrinsicWithChain", "(", "Intrinsic", ")", ";", "if", "(", "!", "IntrData", ")", "return", "false", ";", "switch", "(", "IntrData", "->", "Type", ")", "{", "case", "LOADA", ":", "case", "LOADU", ":", "{", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "I", ".", "getType", "(", ")", ")", ";", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "offset", "=", "0", ";", "Info", ".", "align", "=", "(", "IntrData", "->", "Type", "==", "LOADA", "?", "Info", ".", "memVT", ".", "getSizeInBits", "(", ")", "/", "8", ":", "1", ")", ";", "Info", ".", "vol", "=", "false", ";", "Info", ".", "readMem", "=", "true", ";", "Info", ".", "writeMem", "=", "false", ";", "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", ")", "." ]

[ "X86", "X86", "ISD::INTRINSIC_W_CHAIN", "MVT::getVT", "0", "0", "8", "1" ]

[]

[ "<s>", "static", "void", "assign_int_registers", "(", "HOST_WIDE_INT", "bitpos", ",", "assign_data_t", "*", "data", ")", "{", "int", "intoffset", "=", "data", "->", "intoffset", ";", "machine_mode", "mode", ";", "int", "nregs", ";", "if", "(", "!", "compute_int_layout", "(", "bitpos", ",", "data", ",", "&", "nregs", ")", ")", "return", ";", "if", "(", "intoffset", "%", "BITS_PER_WORD", "!=", "0", ")", "mode", "=", "smallest_int_mode_for_size", "(", "BITS_PER_WORD", "-", "intoffset", "%", "BITS_PER_WORD", ")", ";", "else", "mode", "=", "word_mode", ";", "const", "int", "this_slotno", "=", "data", "->", "slotno", "+", "intoffset", "/", "BITS_PER_WORD", ";", "unsigned", "int", "regno", "=", "data", "->", "regbase", "+", "this_slotno", ";", "intoffset", "/=", "BITS_PER_UNIT", ";", "do", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "mode", ",", "regno", ")", ";", "XVECEXP", "(", "data", "->", "ret", ",", "0", ",", "data", "->", "stack", "+", "data", "->", "nregs", ")", "=", "gen_rtx_EXPR_LIST", "(", "VOIDmode", ",", "reg", ",", "GEN_INT", "(", "intoffset", ")", ")", ";", "data", "->", "nregs", "+=", "1", ";", "mode", "=", "word_mode", ";", "regno", "+=", "1", ";", "intoffset", "=", "(", "intoffset", "|", "(", "UNITS_PER_WORD", "-", "1", ")", ")", "+", "1", ";", "}", "while", "(", "--", "nregs", ">", "0", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "function_arg_record_value", ".", "Assign", "the", "bits", "of", "the", "structure", "between", "PARMS-", ">", "intoffset", "and", "BITPOS", "to", "integer", "registers", "." ]

[ "sparc", "0", "0", "1", "1", "1", "1", "0" ]

[]

[ "<s>", "bool", "PPCInstrInfo", "::", "ClobbersPredicate", "(", "MachineInstr", "&", "MI", ",", "std", "::", "vector", "<", "MachineOperand", ">", "&", "Pred", ",", "bool", "SkipDead", ")", "const", "{", "const", "TargetRegisterClass", "*", "RCs", "[", "]", "=", "{", "&", "PPC", "::", "CRRCRegClass", ",", "&", "PPC", "::", "CRBITRCRegClass", ",", "&", "PPC", "::", "CTRRCRegClass", ",", "&", "PPC", "::", "CTRRC8RegClass", "}", ";", "bool", "Found", "=", "false", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", ".", "operands", "(", ")", ")", "{", "for", "(", "unsigned", "c", "=", "0", ";", "c", "<", "array_lengthof", "(", "RCs", ")", "&&", "!", "Found", ";", "++", "c", ")", "{", "const", "TargetRegisterClass", "*", "RC", "=", "RCs", "[", "c", "]", ";", "if", "(", "MO", ".", "isReg", "(", ")", ")", "{", "if", "(", "MO", ".", "isDef", "(", ")", "&&", "RC", "->", "contains", "(", "MO", ".", "getReg", "(", ")", ")", ")", "{", "Pred", ".", "push_back", "(", "MO", ")", ";", "Found", "=", "true", ";", "}", "}", "else", "if", "(", "MO", ".", "isRegMask", "(", ")", ")", "{", "for", "(", "MCPhysReg", "R", ":", "*", "RC", ")", "if", "(", "MO", ".", "clobbersPhysReg", "(", "R", ")", ")", "{", "Pred", ".", "push_back", "(", "MO", ")", ";", "Found", "=", "true", ";", "}", "}", "}", "}", "return", "Found", ";", "}", "</s>" ]

[ "If", "the", "specified", "instruction", "defines", "any", "predicate", "or", "condition", "code", "register", "(", "s", ")", "used", "for", "predication", ",", "returns", "true", "as", "well", "as", "the", "definition", "predicate", "(", "s", ")", "by", "reference", "." ]

[ "PowerPC", "PPC", "PPC::CRRCRegClass", "PPC::CRBITRCRegClass", "PPC::CTRRCRegClass", "PPC::CTRRC8RegClass", "0" ]

[]

[ "<s>", "void", "AVRTargetStreamer", "::", "finish", "(", ")", "{", "MCStreamer", "&", "OS", "=", "getStreamer", "(", ")", ";", "MCContext", "&", "Context", "=", "OS", ".", "getContext", "(", ")", ";", "MCSymbol", "*", "DoCopyData", "=", "Context", ".", "getOrCreateSymbol", "(", "\"__do_copy_data\"", ")", ";", "MCSymbol", "*", "DoClearBss", "=", "Context", ".", "getOrCreateSymbol", "(", "\"__do_clear_bss\"", ")", ";", "OS", ".", "emitRawComment", "(", "\" Declaring this symbol tells the CRT that it should\"", ")", ";", "OS", ".", "emitRawComment", "(", "\"copy all variables from program memory to RAM on startup\"", ")", ";", "OS", ".", "emitSymbolAttribute", "(", "DoCopyData", ",", "MCSA_Global", ")", ";", "OS", ".", "emitRawComment", "(", "\" Declaring this symbol tells the CRT that it should\"", ")", ";", "OS", ".", "emitRawComment", "(", "\"clear the zeroed data section on startup\"", ")", ";", "OS", ".", "emitSymbolAttribute", "(", "DoClearBss", ",", "MCSA_Global", ")", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "\"__do_copy_data\"", "\"__do_clear_bss\"", "\" Declaring this symbol tells the CRT that it should\"", "\"copy all variables from program memory to RAM on startup\"", "\" Declaring this symbol tells the CRT that it should\"", "\"clear the zeroed data section on startup\"" ]

[]

[ "<s>", "unsigned", "Nios2RegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "Nios2", "::", "SP", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "Nios2", "Nios2", "Nios2::SP" ]

[]

[ "<s>", "static", "void", "aarch64_override_options", "(", "void", ")", "{", "uint64_t", "cpu_isa", "=", "0", ";", "uint64_t", "arch_isa", "=", "0", ";", "aarch64_isa_flags", "=", "0", ";", "bool", "valid_cpu", "=", "true", ";", "bool", "valid_tune", "=", "true", ";", "bool", "valid_arch", "=", "true", ";", "selected_cpu", "=", "NULL", ";", "selected_arch", "=", "NULL", ";", "selected_tune", "=", "NULL", ";", "if", "(", "aarch64_harden_sls_string", ")", "aarch64_validate_sls_mitigation", "(", "aarch64_harden_sls_string", ")", ";", "if", "(", "aarch64_branch_protection_string", ")", "aarch64_validate_mbranch_protection", "(", "aarch64_branch_protection_string", ")", ";", "if", "(", "aarch64_cpu_string", ")", "valid_cpu", "=", "aarch64_validate_mcpu", "(", "aarch64_cpu_string", ",", "&", "selected_cpu", ",", "&", "cpu_isa", ")", ";", "if", "(", "aarch64_arch_string", ")", "valid_arch", "=", "aarch64_validate_march", "(", "aarch64_arch_string", ",", "&", "selected_arch", ",", "&", "arch_isa", ")", ";", "if", "(", "aarch64_tune_string", ")", "valid_tune", "=", "aarch64_validate_mtune", "(", "aarch64_tune_string", ",", "&", "selected_tune", ")", ";", "SUBTARGET_OVERRIDE_OPTIONS", ";", "if", "(", "!", "selected_cpu", ")", "{", "if", "(", "selected_arch", ")", "{", "selected_cpu", "=", "&", "all_cores", "[", "selected_arch", "->", "ident", "]", ";", "aarch64_isa_flags", "=", "arch_isa", ";", "explicit_arch", "=", "selected_arch", "->", "arch", ";", "}", "else", "{", "selected_cpu", "=", "aarch64_get_tune_cpu", "(", "aarch64_none", ")", ";", "aarch64_isa_flags", "=", "TARGET_CPU_DEFAULT", ">>", "6", ";", "}", "if", "(", "selected_tune", ")", "explicit_tune_core", "=", "selected_tune", "->", "ident", ";", "}", "else", "if", "(", "selected_arch", ")", "{", "if", "(", "selected_arch", "->", "arch", "!=", "selected_cpu", "->", "arch", ")", "{", "warning", "(", "0", ",", "\"switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch\"", ",", "aarch64_cpu_string", ",", "aarch64_arch_string", ")", ";", "}", "aarch64_isa_flags", "=", "arch_isa", ";", "explicit_arch", "=", "selected_arch", "->", "arch", ";", "explicit_tune_core", "=", "selected_tune", "?", "selected_tune", "->", "ident", ":", "selected_cpu", "->", "ident", ";", "}", "else", "{", "aarch64_isa_flags", "=", "cpu_isa", ";", "explicit_tune_core", "=", "selected_tune", "?", "selected_tune", "->", "ident", ":", "selected_cpu", "->", "ident", ";", "gcc_assert", "(", "selected_cpu", ")", ";", "selected_arch", "=", "&", "all_architectures", "[", "selected_cpu", "->", "arch", "]", ";", "explicit_arch", "=", "selected_arch", "->", "arch", ";", "}", "if", "(", "!", "selected_arch", ")", "{", "gcc_assert", "(", "selected_cpu", ")", ";", "selected_arch", "=", "&", "all_architectures", "[", "selected_cpu", "->", "arch", "]", ";", "}", "if", "(", "!", "selected_tune", ")", "selected_tune", "=", "selected_cpu", ";", "if", "(", "aarch64_enable_bti", "==", "2", ")", "{", "aarch64_enable_bti", "=", "1", ";", "aarch64_enable_bti", "=", "0", ";", "}", "if", "(", "!", "TARGET_ILP32", "&&", "accepted_branch_protection_string", "==", "NULL", ")", "{", "aarch64_ra_sign_scope", "=", "AARCH64_FUNCTION_NON_LEAF", ";", "aarch64_ra_sign_scope", "=", "AARCH64_FUNCTION_NONE", ";", "}", "if", "(", "TARGET_ILP32", ")", "error", "(", "\"assembler does not support %<-mabi=ilp32%>\"", ")", ";", "aarch64_sve_vg", "=", "aarch64_convert_sve_vector_bits", "(", "aarch64_sve_vector_bits", ")", ";", "if", "(", "aarch64_ra_sign_scope", "!=", "AARCH64_FUNCTION_NONE", "&&", "TARGET_ILP32", ")", "sorry", "(", "\"return address signing is only supported for %<-mabi=lp64%>\"", ")", ";", "if", "(", "(", "aarch64_cpu_string", "&&", "valid_cpu", ")", "||", "(", "aarch64_tune_string", "&&", "valid_tune", ")", ")", "gcc_assert", "(", "explicit_tune_core", "!=", "aarch64_none", ")", ";", "if", "(", "(", "aarch64_cpu_string", "&&", "valid_cpu", ")", "||", "(", "aarch64_arch_string", "&&", "valid_arch", ")", ")", "gcc_assert", "(", "explicit_arch", "!=", "aarch64_no_arch", ")", ";", "if", "(", "aarch64_track_speculation", ")", "flag_shrink_wrap", "=", "0", ";", "aarch64_override_options_internal", "(", "&", "global_options", ")", ";", "target_option_default_node", "=", "target_option_current_node", "=", "build_target_option_node", "(", "&", "global_options", ",", "&", "global_options_set", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_OPTION_OVERRIDE", "." ]

[ "aarch64", "0", "0", "0", "6", "0", "\"switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch\"", "2", "1", "0", "\"assembler does not support %<-mabi=ilp32%>\"", "\"return address signing is only supported for %<-mabi=lp64%>\"", "0" ]

[]

[ "<s>", "static", "int", "frv_function_contains_far_jump", "(", "void", ")", "{", "rtx", "insn", "=", "get_insns", "(", ")", ";", "while", "(", "insn", "!=", "NULL", "&&", "!", "(", "GET_CODE", "(", "insn", ")", "==", "JUMP_INSN", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_VEC", "&&", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "!=", "ADDR_DIFF_VEC", "&&", "get_attr_far_jump", "(", "insn", ")", "==", "FAR_JUMP_YES", ")", ")", "insn", "=", "NEXT_INSN", "(", "insn", ")", ";", "return", "(", "insn", "!=", "NULL", ")", ";", "}", "</s>" ]

[ "True", "if", "the", "current", "function", "contains", "a", "far", "jump", "." ]

[ "frv" ]

[]

[ "<s>", "static", "int", "const_int_cost", "(", "HOST_WIDE_INT", "i", ")", "{", "switch", "(", "m68k_const_method", "(", "i", ")", ")", "{", "case", "MOVQ", ":", "return", "0", ";", "case", "MVZ", ":", "case", "MVS", ":", "case", "NOTB", ":", "case", "NOTW", ":", "case", "NEGW", ":", "case", "SWAP", ":", "return", "1", ";", "case", "MOVL", ":", "return", "2", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "the", "cost", "of", "moving", "constant", "I", "into", "a", "data", "register", "." ]

[ "m68k", "0", "1", "2" ]

[]

[ "<s>", "static", "int", "m68hc11_address_cost", "(", "rtx", "addr", ")", "{", "int", "cost", "=", "4", ";", "switch", "(", "GET_CODE", "(", "addr", ")", ")", "{", "case", "REG", ":", "if", "(", "REGNO", "(", "addr", ")", "<", "FIRST_PSEUDO_REGISTER", ")", "cost", "=", "0", ";", "else", "cost", "=", "1", ";", "break", ";", "case", "SYMBOL_REF", ":", "cost", "=", "8", ";", "break", ";", "case", "LABEL_REF", ":", "case", "CONST", ":", "cost", "=", "0", ";", "break", ";", "case", "PLUS", ":", "{", "register", "rtx", "plus0", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "register", "rtx", "plus1", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "plus0", ")", "!=", "REG", ")", "break", ";", "switch", "(", "GET_CODE", "(", "plus1", ")", ")", "{", "case", "CONST_INT", ":", "if", "(", "INTVAL", "(", "plus1", ")", ">=", "2", "*", "m68hc11_max_offset", "||", "INTVAL", "(", "plus1", ")", "<", "m68hc11_min_offset", ")", "cost", "=", "3", ";", "else", "if", "(", "INTVAL", "(", "plus1", ")", ">=", "m68hc11_max_offset", ")", "cost", "=", "2", ";", "else", "cost", "=", "1", ";", "if", "(", "REGNO", "(", "plus0", ")", "<", "FIRST_PSEUDO_REGISTER", ")", "cost", "+=", "0", ";", "else", "cost", "+=", "1", ";", "break", ";", "case", "SYMBOL_REF", ":", "cost", "=", "8", ";", "break", ";", "case", "CONST", ":", "case", "LABEL_REF", ":", "cost", "=", "0", ";", "break", ";", "default", ":", "break", ";", "}", "break", ";", "}", "case", "PRE_DEC", ":", "case", "PRE_INC", ":", "if", "(", "SP_REG_P", "(", "XEXP", "(", "addr", ",", "0", ")", ")", ")", "cost", "=", "1", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "debug_m6811", ")", "{", "printf", "(", "\"Address cost: %d for :\"", ",", "cost", ")", ";", "fflush", "(", "stdout", ")", ";", "debug_rtx", "(", "addr", ")", ";", "}", "return", "cost", ";", "}", "</s>" ]

[ "Provide", "the", "costs", "of", "an", "addressing", "mode", "that", "contains", "ADDR", ".", "If", "ADDR", "is", "not", "a", "valid", "address", ",", "its", "cost", "is", "irrelevant", "." ]

[ "m68hc11", "4", "0", "1", "8", "0", "0", "1", "2", "3", "2", "1", "0", "1", "8", "0", "0", "1", "\"Address cost: %d for :\"" ]

[]

[ "<s>", "bool", "aarch64_operands_ok_for_ldpstp", "(", "rtx", "*", "operands", ",", "bool", "load", ",", "machine_mode", "mode", ")", "{", "HOST_WIDE_INT", "offval_1", ",", "offval_2", ",", "msize", ";", "enum", "reg_class", "rclass_1", ",", "rclass_2", ";", "rtx", "mem_1", ",", "mem_2", ",", "reg_1", ",", "reg_2", ",", "base_1", ",", "base_2", ",", "offset_1", ",", "offset_2", ";", "if", "(", "load", ")", "{", "mem_1", "=", "operands", "[", "1", "]", ";", "mem_2", "=", "operands", "[", "3", "]", ";", "reg_1", "=", "operands", "[", "0", "]", ";", "reg_2", "=", "operands", "[", "2", "]", ";", "gcc_assert", "(", "REG_P", "(", "reg_1", ")", "&&", "REG_P", "(", "reg_2", ")", ")", ";", "if", "(", "REGNO", "(", "reg_1", ")", "==", "REGNO", "(", "reg_2", ")", ")", "return", "false", ";", "}", "else", "{", "mem_1", "=", "operands", "[", "0", "]", ";", "mem_2", "=", "operands", "[", "2", "]", ";", "reg_1", "=", "operands", "[", "1", "]", ";", "reg_2", "=", "operands", "[", "3", "]", ";", "}", "if", "(", "MEM_VOLATILE_P", "(", "mem_1", ")", "||", "MEM_VOLATILE_P", "(", "mem_2", ")", ")", "return", "false", ";", "if", "(", "mode", "==", "SImode", "&&", "(", "aarch64_tune_params", ".", "extra_tuning_flags", "&", "AARCH64_EXTRA_TUNE_SLOW_UNALIGNED_LDPW", ")", "&&", "!", "optimize_size", "&&", "MEM_ALIGN", "(", "mem_1", ")", "<", "8", "*", "BITS_PER_UNIT", ")", "return", "false", ";", "extract_base_offset_in_addr", "(", "mem_1", ",", "&", "base_1", ",", "&", "offset_1", ")", ";", "if", "(", "base_1", "==", "NULL_RTX", "||", "offset_1", "==", "NULL_RTX", ")", "return", "false", ";", "extract_base_offset_in_addr", "(", "mem_2", ",", "&", "base_2", ",", "&", "offset_2", ")", ";", "if", "(", "base_2", "==", "NULL_RTX", "||", "offset_2", "==", "NULL_RTX", ")", "return", "false", ";", "if", "(", "!", "rtx_equal_p", "(", "base_1", ",", "base_2", ")", ")", "return", "false", ";", "gcc_assert", "(", "known_eq", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "mem_1", ")", ")", ",", "GET_MODE_SIZE", "(", "GET_MODE", "(", "mem_2", ")", ")", ")", ")", ";", "offval_1", "=", "INTVAL", "(", "offset_1", ")", ";", "offval_2", "=", "INTVAL", "(", "offset_2", ")", ";", "msize", "=", "GET_MODE_SIZE", "(", "mode", ")", ".", "to_constant", "(", ")", ";", "if", "(", "offval_1", "!=", "(", "offval_2", "+", "msize", ")", "&&", "offval_2", "!=", "(", "offval_1", "+", "msize", ")", ")", "return", "false", ";", "if", "(", "load", ")", "{", "if", "(", "reg_mentioned_p", "(", "reg_1", ",", "mem_1", ")", ")", "return", "false", ";", "if", "(", "offval_1", ">", "offval_2", "&&", "reg_mentioned_p", "(", "reg_2", ",", "mem_2", ")", ")", "return", "false", ";", "}", "if", "(", "!", "aarch64_mem_pair_operand", "(", "mem_1", ",", "GET_MODE", "(", "mem_1", ")", ")", "&&", "!", "aarch64_mem_pair_operand", "(", "mem_2", ",", "GET_MODE", "(", "mem_2", ")", ")", ")", "return", "false", ";", "if", "(", "REG_P", "(", "reg_1", ")", "&&", "FP_REGNUM_P", "(", "REGNO", "(", "reg_1", ")", ")", ")", "rclass_1", "=", "FP_REGS", ";", "else", "rclass_1", "=", "GENERAL_REGS", ";", "if", "(", "REG_P", "(", "reg_2", ")", "&&", "FP_REGNUM_P", "(", "REGNO", "(", "reg_2", ")", ")", ")", "rclass_2", "=", "FP_REGS", ";", "else", "rclass_2", "=", "GENERAL_REGS", ";", "if", "(", "rclass_1", "!=", "rclass_2", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Given", "OPERANDS", "of", "consecutive", "load/store", ",", "check", "if", "we", "can", "merge", "them", "into", "ldp/stp", ".", "LOAD", "is", "true", "if", "they", "are", "load", "instructions", ".", "MODE", "is", "the", "mode", "of", "memory", "operands", "." ]

[ "aarch64", "1", "3", "0", "2", "0", "2", "1", "3", "8" ]

[]

[ "<s>", "static", "void", "print_address_offset", "(", "FILE", "*", "file", ",", "rtx", "off", ",", "machine_mode", "mem_mode", ")", "{", "rtx", "pat", ";", "if", "(", "c6x_current_insn", "!=", "NULL_RTX", ")", "{", "pat", "=", "PATTERN", "(", "c6x_current_insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "COND_EXEC", ")", "pat", "=", "COND_EXEC_CODE", "(", "pat", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "pat", "=", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", "&&", "GET_CODE", "(", "SET_SRC", "(", "pat", ")", ")", "==", "UNSPEC", "&&", "XINT", "(", "SET_SRC", "(", "pat", ")", ",", "1", ")", "==", "UNSPEC_MISALIGNED_ACCESS", ")", "{", "gcc_assert", "(", "CONST_INT_P", "(", "off", ")", "&&", "(", "INTVAL", "(", "off", ")", "&", "(", "GET_MODE_SIZE", "(", "mem_mode", ")", "-", "1", ")", ")", "==", "0", ")", ";", "fprintf", "(", "file", ",", "\"[\"", "HOST_WIDE_INT_PRINT_DEC", "\"]\"", ",", "INTVAL", "(", "off", ")", "/", "GET_MODE_SIZE", "(", "mem_mode", ")", ")", ";", "return", ";", "}", "}", "fputs", "(", "\"(\"", ",", "file", ")", ";", "output_address", "(", "mem_mode", ",", "off", ")", ";", "fputs", "(", "\")\"", ",", "file", ")", ";", "}", "</s>" ]

[ "Subroutine", "of", "print_address_operand", ",", "print", "a", "single", "address", "offset", "OFF", "for", "a", "memory", "access", "of", "mode", "MEM_MODE", ",", "choosing", "between", "normal", "form", "and", "scaled", "form", "depending", "on", "the", "type", "of", "the", "insn", ".", "Misaligned", "memory", "references", "must", "use", "the", "scaled", "form", "." ]

[ "c6x", "0", "0", "1", "1", "0", "\"[\"", "\"]\"", "\"(\"", "\")\"" ]

[]

[ "<s>", "bool", "NVPTXAsmPrinter", "::", "lowerOperand", "(", "const", "MachineOperand", "&", "MO", ",", "MCOperand", "&", "MCOp", ")", "{", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_Register", ":", "MCOp", "=", "MCOperand", "::", "createReg", "(", "encodeVirtualRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "createImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "MCSymbolRefExpr", "::", "create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "OutContext", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_ExternalSymbol", ":", "MCOp", "=", "GetSymbolRef", "(", "GetExternalSymbolSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_GlobalAddress", ":", "MCOp", "=", "GetSymbolRef", "(", "getSymbol", "(", "MO", ".", "getGlobal", "(", ")", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_FPImmediate", ":", "{", "const", "ConstantFP", "*", "Cnt", "=", "MO", ".", "getFPImm", "(", ")", ";", "const", "APFloat", "&", "Val", "=", "Cnt", "->", "getValueAPF", "(", ")", ";", "switch", "(", "Cnt", "->", "getType", "(", ")", "->", "getTypeID", "(", ")", ")", "{", "default", ":", "report_fatal_error", "(", "\"Unsupported FP type\"", ")", ";", "break", ";", "case", "Type", "::", "HalfTyID", ":", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "NVPTXFloatMCExpr", "::", "createConstantFPHalf", "(", "Val", ",", "OutContext", ")", ")", ";", "break", ";", "case", "Type", "::", "FloatTyID", ":", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "NVPTXFloatMCExpr", "::", "createConstantFPSingle", "(", "Val", ",", "OutContext", ")", ")", ";", "break", ";", "case", "Type", "::", "DoubleTyID", ":", "MCOp", "=", "MCOperand", "::", "createExpr", "(", "NVPTXFloatMCExpr", "::", "createConstantFPDouble", "(", "Val", ",", "OutContext", ")", ")", ";", "break", ";", "}", "break", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

[ "Wrapper", "for", "MCInstLowering.lowerOperand", "(", ")", "for", "the", "tblgen'erated", "pseudo", "lowering", "." ]

[ "NVPTX", "NVPTX", "\"unknown operand type\"", "\"Unsupported FP type\"", "NVPTX", "NVPTX", "NVPTX" ]

[]

[ "<s>", "bool", "ARM64DAGToDAGISel", "::", "SelectInlineAsmMemoryOperand", "(", "const", "SDValue", "&", "Op", ",", "char", "ConstraintCode", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "OutOps", ")", "{", "assert", "(", "ConstraintCode", "==", "'m'", "&&", "\"unexpected asm memory constraint\"", ")", ";", "OutOps", ".", "push_back", "(", "Op", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "\"unexpected asm memory constraint\"" ]

[]

[ "<s>", "const", "char", "*", "mcore_output_bclri", "(", "rtx", "dst", ",", "int", "mask", ")", "{", "rtx", "out_operands", "[", "2", "]", ";", "int", "bit", ";", "out_operands", "[", "0", "]", "=", "dst", ";", "for", "(", "bit", "=", "0", ";", "bit", "<", "32", ";", "bit", "++", ")", "{", "if", "(", "(", "mask", "&", "0x1", ")", "==", "0x0", ")", "{", "out_operands", "[", "1", "]", "=", "GEN_INT", "(", "bit", ")", ";", "output_asm_insn", "(", "\"bclri\\t%0,%1\"", ",", "out_operands", ")", ";", "}", "mask", ">>=", "1", ";", "}", "return", "\"\"", ";", "}", "</s>" ]

[ "Output", "a", "series", "of", "bclri", "'s", "corresponding", "to", "mask", "." ]

[ "mcore", "2", "0", "0", "32", "0x1", "0x0", "1", "\"bclri\\t%0,%1\"", "1", "\"\"" ]

[]

[ "<s>", "bool", "arm_expand_vec_perm_const", "(", "rtx", "target", ",", "rtx", "op0", ",", "rtx", "op1", ",", "rtx", "sel", ")", "{", "struct", "expand_vec_perm_d", "d", ";", "int", "i", ",", "nelt", ",", "which", ";", "d", ".", "target", "=", "target", ";", "d", ".", "op0", "=", "op0", ";", "d", ".", "op1", "=", "op1", ";", "d", ".", "vmode", "=", "GET_MODE", "(", "target", ")", ";", "gcc_assert", "(", "VECTOR_MODE_P", "(", "d", ".", "vmode", ")", ")", ";", "d", ".", "nelt", "=", "nelt", "=", "GET_MODE_NUNITS", "(", "d", ".", "vmode", ")", ";", "d", ".", "testing_p", "=", "false", ";", "for", "(", "i", "=", "which", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "{", "rtx", "e", "=", "XVECEXP", "(", "sel", ",", "0", ",", "i", ")", ";", "int", "ei", "=", "INTVAL", "(", "e", ")", "&", "(", "2", "*", "nelt", "-", "1", ")", ";", "which", "|=", "(", "ei", "<", "nelt", "?", "1", ":", "2", ")", ";", "d", ".", "perm", "[", "i", "]", "=", "ei", ";", "}", "switch", "(", "which", ")", "{", "default", ":", "gcc_unreachable", "(", ")", ";", "case", "3", ":", "d", ".", "one_vector_p", "=", "false", ";", "if", "(", "!", "rtx_equal_p", "(", "op0", ",", "op1", ")", ")", "break", ";", "case", "2", ":", "for", "(", "i", "=", "0", ";", "i", "<", "nelt", ";", "++", "i", ")", "d", ".", "perm", "[", "i", "]", "&=", "nelt", "-", "1", ";", "d", ".", "op0", "=", "op1", ";", "d", ".", "one_vector_p", "=", "true", ";", "break", ";", "case", "1", ":", "d", ".", "op1", "=", "op0", ";", "d", ".", "one_vector_p", "=", "true", ";", "break", ";", "}", "return", "arm_expand_vec_perm_const_1", "(", "&", "d", ")", ";", "}", "</s>" ]

[ "Expand", "a", "vec_perm_const", "pattern", "." ]

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

[]

[ "<s>", "TargetLoweringBase", "::", "LegalizeTypeAction", "NVPTXTargetLowering", "::", "getPreferredVectorAction", "(", "MVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isScalableVector", "(", ")", "&&", "VT", ".", "getVectorNumElements", "(", ")", "!=", "1", "&&", "VT", ".", "getScalarType", "(", ")", "==", "MVT", "::", "i1", ")", "return", "TypeSplitVector", ";", "if", "(", "VT", "==", "MVT", "::", "v2f16", ")", "return", "TypeLegal", ";", "return", "TargetLoweringBase", "::", "getPreferredVectorAction", "(", "VT", ")", ";", "}", "</s>" ]

[ "Customize", "the", "preferred", "legalization", "strategy", "for", "certain", "types", "." ]

[ "NVPTX", "NVPTX", "1", "MVT::i1", "MVT::v2f16" ]

[]

[ "<s>", "static", "const", "uint16_t", "*", "lookup", "(", "unsigned", "opcode", ",", "unsigned", "domain", ",", "ArrayRef", "<", "uint16_t", "[", "3", "]", ">", "Table", ")", "{", "for", "(", "const", "uint16_t", "(", "&", "Row", ")", "[", "3", "]", ":", "Table", ")", "if", "(", "Row", "[", "domain", "-", "1", "]", "==", "opcode", ")", "return", "Row", ";", "return", "nullptr", ";", "}", "</s>" ]

[ "This", "method", "finds", "the", "value", "with", "the", "given", "Name", "in", "the", "the", "symbol", "table", "." ]

[ "X86", "3", "3", "1" ]

[]

[ "<s>", "bool", "SITargetLowering", "::", "isFMAFasterThanFMulAndFAdd", "(", "EVT", "VT", ")", "const", "{", "VT", "=", "VT", ".", "getScalarType", "(", ")", ";", "if", "(", "!", "VT", ".", "isSimple", "(", ")", ")", "return", "false", ";", "switch", "(", "VT", ".", "getSimpleVT", "(", ")", ".", "SimpleTy", ")", "{", "case", "MVT", "::", "f32", ":", "return", "Subtarget", "->", "hasFP32Denormals", "(", ")", "&&", "Subtarget", "->", "hasFastFMAF32", "(", ")", ";", "case", "MVT", "::", "f64", ":", "return", "true", ";", "default", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "an", "FMA", "operation", "is", "faster", "than", "a", "pair", "of", "fmul", "and", "fadd", "instructions", "." ]

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

[]

[ "<s>", "void", "SNESInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "SNESMachineFunctionInfo", "*", "AFI", "=", "MF", ".", "getInfo", "<", "SNESMachineFunctionInfo", ">", "(", ")", ";", "AFI", "->", "setHasSpills", "(", "true", ")", ";", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "{", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "}", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOStore", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ")", ";", "unsigned", "Opcode", "=", "0", ";", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i8", ")", ")", "{", "Opcode", "=", "SNES", "::", "STDPtrQRr", ";", "}", "else", "if", "(", "TRI", "->", "isTypeLegalForClass", "(", "*", "RC", ",", "MVT", "::", "i16", ")", ")", "{", "Opcode", "=", "SNES", "::", "STDWPtrQRr", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot store this register into a stack slot!\"", ")", ";", "}", "fddfd", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "Opcode", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

[ "Store", "the", "specified", "register", "of", "the", "given", "register", "class", "to", "the", "specified", "stack", "frame", "index", "." ]

[ "SNES", "SNES", "SNES", "SNES", "0", "MVT::i8", "SNES::STDPtrQRr", "MVT::i16", "SNES::STDWPtrQRr", "\"Cannot store this register into a stack slot!\"", "0" ]

[]

[ "<s>", "static", "rtx", "restore_gprs", "(", "rtx", "base", ",", "int", "offset", ",", "int", "first", ",", "int", "last", ")", "{", "rtx", "addr", ",", "insn", ";", "addr", "=", "plus_constant", "(", "base", ",", "offset", ")", ";", "addr", "=", "gen_rtx_MEM", "(", "Pmode", ",", "addr", ")", ";", "set_mem_alias_set", "(", "addr", ",", "get_frame_alias_set", "(", ")", ")", ";", "if", "(", "first", "==", "last", ")", "{", "if", "(", "TARGET_64BIT", ")", "insn", "=", "gen_movdi", "(", "gen_rtx_REG", "(", "Pmode", ",", "first", ")", ",", "addr", ")", ";", "else", "insn", "=", "gen_movsi", "(", "gen_rtx_REG", "(", "Pmode", ",", "first", ")", ",", "addr", ")", ";", "return", "insn", ";", "}", "insn", "=", "gen_load_multiple", "(", "gen_rtx_REG", "(", "Pmode", ",", "first", ")", ",", "addr", ",", "GEN_INT", "(", "last", "-", "first", "+", "1", ")", ")", ";", "return", "insn", ";", "}", "</s>" ]

[ "Generate", "insn", "to", "restore", "registers", "FIRST", "to", "LAST", "from", "the", "register", "save", "area", "located", "at", "offset", "OFFSET", "relative", "to", "register", "BASE", "." ]

[ "s390", "1" ]

[]

[ "<s>", "void", "ix86_split_simple_return_pop_internal", "(", "rtx", "popc", ")", "{", "struct", "machine_function", "*", "m", "=", "cfun", "->", "machine", ";", "rtx", "ecx", "=", "gen_rtx_REG", "(", "SImode", ",", "CX_REG", ")", ";", "rtx_insn", "*", "insn", ";", "gcc_assert", "(", "!", "TARGET_64BIT", ")", ";", "insn", "=", "emit_insn", "(", "gen_pop", "(", "ecx", ")", ")", ";", "m", "->", "fs", ".", "cfa_offset", "-=", "UNITS_PER_WORD", ";", "m", "->", "fs", ".", "sp_offset", "-=", "UNITS_PER_WORD", ";", "rtx", "x", "=", "plus_constant", "(", "Pmode", ",", "stack_pointer_rtx", ",", "UNITS_PER_WORD", ")", ";", "x", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "x", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "x", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_REGISTER", ",", "gen_rtx_SET", "(", "ecx", ",", "pc_rtx", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "popc", ")", ";", "x", "=", "gen_rtx_SET", "(", "stack_pointer_rtx", ",", "x", ")", ";", "insn", "=", "emit_insn", "(", "x", ")", ";", "add_reg_note", "(", "insn", ",", "REG_CFA_ADJUST_CFA", ",", "x", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "emit_jump_insn", "(", "gen_simple_return_indirect_internal", "(", "ecx", ")", ")", ";", "}", "</s>" ]

[ "Split", "simple", "return", "with", "popping", "POPC", "bytes", "from", "stack", "to", "indirect", "branch", "with", "stack", "adjustment", "." ]

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

[]

[ "<s>", "void", "SparcTargetLowering", "::", "LowerAsmOperandForConstraint", "(", "SDValue", "Op", ",", "std", "::", "string", "&", "Constraint", ",", "std", "::", "vector", "<", "SDValue", ">", "&", "Ops", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SDValue", "Result", "(", "nullptr", ",", "0", ")", ";", "if", "(", "Constraint", ".", "length", "(", ")", ">", "1", ")", "return", ";", "char", "ConstraintLetter", "=", "Constraint", "[", "0", "]", ";", "switch", "(", "ConstraintLetter", ")", "{", "default", ":", "break", ";", "case", "'I'", ":", "if", "(", "ConstantSDNode", "*", "C", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "Op", ")", ")", "{", "if", "(", "isInt", "<", "13", ">", "(", "C", "->", "getSExtValue", "(", ")", ")", ")", "{", "Result", "=", "DAG", ".", "getTargetConstant", "(", "C", "->", "getSExtValue", "(", ")", ",", "Op", ".", "getValueType", "(", ")", ")", ";", "break", ";", "}", "return", ";", "}", "}", "if", "(", "Result", ".", "getNode", "(", ")", ")", "{", "Ops", ".", "push_back", "(", "Result", ")", ";", "return", ";", "}", "TargetLowering", "::", "LowerAsmOperandForConstraint", "(", "Op", ",", "Constraint", ",", "Ops", ",", "DAG", ")", ";", "}", "</s>" ]

[ "Lower", "the", "specified", "operand", "into", "the", "Ops", "vector", "." ]

[ "Sparc", "Sparc", "0", "1", "0", "13" ]

[]

[ "<s>", "void", "BPFAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "BPFMCInstLower", "MCInstLowering", "(", "OutContext", ",", "*", "this", ")", ";", "MCInst", "TmpInst", ";", "MCInstLowering", ".", "Lower", "(", "MI", ",", "TmpInst", ")", ";", "EmitToStreamer", "(", "OutStreamer", ",", "TmpInst", ")", ";", "}", "</s>" ]

[ "EmitInstruction", "-", "This", "callback", "is", "invoked", "when", "an", "instruction", "is", "emitted", ",", "to", "advance", "the", "hazard", "state", "." ]

[ "BPF", "BPF", "BPF" ]

[]

[ "<s>", "bool", "MipsSEInstrInfo", "::", "expandPostRAPseudo", "(", "MachineBasicBlock", "::", "iterator", "MI", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "*", "MI", "->", "getParent", "(", ")", ";", "switch", "(", "MI", "->", "getDesc", "(", ")", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "return", "false", ";", "case", "Mips", "::", "RetRA", ":", "expandRetRA", "(", "MBB", ",", "MI", ",", "Mips", "::", "RET", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_S_W", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_S_W", ",", "Mips", "::", "MTC1", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_D32_W", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_D32_W", ",", "Mips", "::", "MTC1", ",", "false", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_S_L", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_S_L", ",", "Mips", "::", "DMTC1", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_D64_W", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_D64_W", ",", "Mips", "::", "MTC1", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "PseudoCVT_D64_L", ":", "expandCvtFPInt", "(", "MBB", ",", "MI", ",", "Mips", "::", "CVT_D64_L", ",", "Mips", "::", "DMTC1", ",", "true", ")", ";", "break", ";", "case", "Mips", "::", "BuildPairF64", ":", "expandBuildPairF64", "(", "MBB", ",", "MI", ")", ";", "break", ";", "case", "Mips", "::", "ExtractElementF64", ":", "expandExtractElementF64", "(", "MBB", ",", "MI", ")", ";", "break", ";", "case", "Mips", "::", "PseudoLDC1", ":", "expandDPLoadStore", "(", "MBB", ",", "MI", ",", "Mips", "::", "LDC1", ",", "Mips", "::", "LWC1", ")", ";", "break", ";", "case", "Mips", "::", "PseudoSDC1", ":", "expandDPLoadStore", "(", "MBB", ",", "MI", ",", "Mips", "::", "SDC1", ",", "Mips", "::", "SWC1", ")", ";", "break", ";", "case", "Mips", "::", "MIPSeh_return32", ":", "case", "Mips", "::", "MIPSeh_return64", ":", "expandEhReturn", "(", "MBB", ",", "MI", ")", ";", "break", ";", "}", "MBB", ".", "erase", "(", "MI", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "function", "is", "called", "for", "all", "pseudo", "instructions", "that", "remain", "after", "register", "allocation", "." ]

[ "Mips", "Mips", "Mips::RetRA", "Mips::RET", "Mips::PseudoCVT_S_W", "Mips::CVT_S_W", "Mips::MTC1", "Mips::PseudoCVT_D32_W", "Mips::CVT_D32_W", "Mips::MTC1", "Mips::PseudoCVT_S_L", "Mips::CVT_S_L", "Mips::DMTC1", "Mips::PseudoCVT_D64_W", "Mips::CVT_D64_W", "Mips::MTC1", "Mips::PseudoCVT_D64_L", "Mips::CVT_D64_L", "Mips::DMTC1", "Mips::BuildPairF64", "Mips::ExtractElementF64", "Mips::PseudoLDC1", "Mips::LDC1", "Mips::LWC1", "Mips::PseudoSDC1", "Mips::SDC1", "Mips::SWC1", "Mips::MIPSeh_return32", "Mips::MIPSeh_return64" ]

[]

[ "<s>", "bool", "AMDGPUCodeGenPrepare", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "auto", "*", "TPC", "=", "getAnalysisIfAvailable", "<", "TargetPassConfig", ">", "(", ")", ";", "if", "(", "!", "TPC", ")", "return", "false", ";", "const", "AMDGPUTargetMachine", "&", "TM", "=", "TPC", "->", "getTM", "<", "AMDGPUTargetMachine", ">", "(", ")", ";", "ST", "=", "&", "TM", ".", "getSubtarget", "<", "SISubtarget", ">", "(", "F", ")", ";", "DA", "=", "&", "getAnalysis", "<", "DivergenceAnalysis", ">", "(", ")", ";", "HasUnsafeFPMath", "=", "hasUnsafeFPMath", "(", "F", ")", ";", "AMDGPUASI", "=", "TM", ".", "getAMDGPUAS", "(", ")", ";", "bool", "MadeChange", "=", "false", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "BasicBlock", "::", "iterator", "Next", ";", "for", "(", "BasicBlock", "::", "iterator", "I", "=", "BB", ".", "begin", "(", ")", ",", "E", "=", "BB", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MadeChange", "|=", "visit", "(", "*", "I", ")", ";", "}", "}", "return", "MadeChange", ";", "}", "</s>" ]

[ "runOnFunction", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "the", "per-function", "processing", "of", "the", "pass", "." ]

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

[]

[ "<s>", "static", "bool", "cortexa7_older_only", "(", "rtx_insn", "*", "insn", ")", "{", "if", "(", "recog_memoized", "(", "insn", ")", "<", "0", ")", "return", "false", ";", "switch", "(", "get_attr_type", "(", "insn", ")", ")", "{", "case", "TYPE_ALU_DSP_REG", ":", "case", "TYPE_ALU_SREG", ":", "case", "TYPE_ALUS_SREG", ":", "case", "TYPE_LOGIC_REG", ":", "case", "TYPE_LOGICS_REG", ":", "case", "TYPE_ADC_REG", ":", "case", "TYPE_ADCS_REG", ":", "case", "TYPE_ADR", ":", "case", "TYPE_BFM", ":", "case", "TYPE_REV", ":", "case", "TYPE_MVN_REG", ":", "case", "TYPE_SHIFT_IMM", ":", "case", "TYPE_SHIFT_REG", ":", "case", "TYPE_LOAD_BYTE", ":", "case", "TYPE_LOAD1", ":", "case", "TYPE_STORE1", ":", "case", "TYPE_FFARITHS", ":", "case", "TYPE_FADDS", ":", "case", "TYPE_FFARITHD", ":", "case", "TYPE_FADDD", ":", "case", "TYPE_FMOV", ":", "case", "TYPE_F_CVT", ":", "case", "TYPE_FCMPS", ":", "case", "TYPE_FCMPD", ":", "case", "TYPE_FCONSTS", ":", "case", "TYPE_FCONSTD", ":", "case", "TYPE_FMULS", ":", "case", "TYPE_FMACS", ":", "case", "TYPE_FMULD", ":", "case", "TYPE_FMACD", ":", "case", "TYPE_FDIVS", ":", "case", "TYPE_FDIVD", ":", "case", "TYPE_F_MRC", ":", "case", "TYPE_F_MRRC", ":", "case", "TYPE_F_FLAG", ":", "case", "TYPE_F_LOADS", ":", "case", "TYPE_F_STORES", ":", "return", "true", ";", "default", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "and", "only", "if", "this", "insn", "can", "dual-issue", "only", "as", "older", "." ]

[ "arm", "0" ]

[]

[ "<s>", "SDValue", "MipsTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "AND", ":", "return", "LowerANDOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BRCOND", ":", "return", "LowerBRCOND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_SINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalTLSAddress", ":", "return", "LowerGlobalTLSAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "JumpTable", ":", "return", "LowerJumpTable", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "OR", ":", "return", "LowerANDOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SELECT", ":", "return", "LowerSELECT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SETCC", ":", "return", "LowerSETCC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "}", "return", "SDValue", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "ISD::AND", "ISD::BRCOND", "ISD::ConstantPool", "ISD::DYNAMIC_STACKALLOC", "ISD::FP_TO_SINT", "ISD::GlobalAddress", "ISD::GlobalTLSAddress", "ISD::JumpTable", "ISD::OR", "ISD::SELECT", "ISD::SETCC", "ISD::VASTART" ]

[]

[ "<s>", "bool", "X86FastISel", "::", "tryToFoldLoadIntoMI", "(", "MachineInstr", "*", "MI", ",", "unsigned", "OpNo", ",", "const", "LoadInst", "*", "LI", ")", "{", "const", "Value", "*", "Ptr", "=", "LI", "->", "getPointerOperand", "(", ")", ";", "X86AddressMode", "AM", ";", "if", "(", "!", "X86SelectAddress", "(", "Ptr", ",", "AM", ")", ")", "return", "false", ";", "const", "X86InstrInfo", "&", "XII", "=", "(", "const", "X86InstrInfo", "&", ")", "TII", ";", "unsigned", "Size", "=", "DL", ".", "getTypeAllocSize", "(", "LI", "->", "getType", "(", ")", ")", ";", "unsigned", "Alignment", "=", "LI", "->", "getAlignment", "(", ")", ";", "if", "(", "Alignment", "==", "0", ")", "Alignment", "=", "DL", ".", "getABITypeAlignment", "(", "LI", "->", "getType", "(", ")", ")", ";", "SmallVector", "<", "MachineOperand", ",", "8", ">", "AddrOps", ";", "AM", ".", "getFullAddress", "(", "AddrOps", ")", ";", "MachineInstr", "*", "Result", "=", "XII", ".", "foldMemoryOperandImpl", "(", "*", "FuncInfo", ".", "MF", ",", "*", "MI", ",", "OpNo", ",", "AddrOps", ",", "FuncInfo", ".", "InsertPt", ",", "Size", ",", "Alignment", ",", "true", ")", ";", "if", "(", "!", "Result", ")", "return", "false", ";", "unsigned", "OperandNo", "=", "0", ";", "for", "(", "MachineInstr", "::", "mop_iterator", "I", "=", "Result", "->", "operands_begin", "(", ")", ",", "E", "=", "Result", "->", "operands_end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ",", "++", "OperandNo", ")", "{", "MachineOperand", "&", "MO", "=", "*", "I", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "MO", ".", "isDef", "(", ")", "||", "MO", ".", "getReg", "(", ")", "!=", "AM", ".", "IndexReg", ")", "continue", ";", "unsigned", "IndexReg", "=", "constrainOperandRegClass", "(", "Result", "->", "getDesc", "(", ")", ",", "MO", ".", "getReg", "(", ")", ",", "OperandNo", ")", ";", "if", "(", "IndexReg", "==", "MO", ".", "getReg", "(", ")", ")", "continue", ";", "MO", ".", "setReg", "(", "IndexReg", ")", ";", "}", "Result", "->", "addMemOperand", "(", "*", "FuncInfo", ".", "MF", ",", "createMachineMemOperandFor", "(", "LI", ")", ")", ";", "Result", "->", "cloneInstrSymbols", "(", "*", "FuncInfo", ".", "MF", ",", "*", "MI", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "(", "MI", ")", ";", "removeDeadCode", "(", "I", ",", "std", "::", "next", "(", "I", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "The", "specified", "machine", "instr", "operand", "is", "a", "vreg", ",", "and", "that", "vreg", "is", "being", "provided", "by", "the", "specified", "load", "instruction", "." ]

[ "X86", "X86", "X86", "X86", "X86", "X86", "0", "8", "0" ]

[]

[ "<s>", "void", "SITargetLowering", "::", "AdjustInstrPostInstrSelection", "(", "MachineInstr", "*", "MI", ",", "SDNode", "*", "Node", ")", "const", "{", "const", "SIInstrInfo", "*", "TII", "=", "static_cast", "<", "const", "SIInstrInfo", "*", ">", "(", "Subtarget", "->", "getInstrInfo", "(", ")", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "if", "(", "TII", "->", "isVOP3", "(", "MI", "->", "getOpcode", "(", ")", ")", ")", "{", "TII", "->", "legalizeOperandsVOP3", "(", "MRI", ",", "MI", ")", ";", "return", ";", "}", "if", "(", "TII", "->", "isMIMG", "(", "*", "MI", ")", ")", "{", "unsigned", "VReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "unsigned", "DmaskIdx", "=", "MI", "->", "getNumOperands", "(", ")", "==", "12", "?", "3", ":", "4", ";", "unsigned", "Writemask", "=", "MI", "->", "getOperand", "(", "DmaskIdx", ")", ".", "getImm", "(", ")", ";", "unsigned", "BitsSet", "=", "0", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "4", ";", "++", "i", ")", "BitsSet", "+=", "Writemask", "&", "(", "1", "<<", "i", ")", "?", "1", ":", "0", ";", "const", "TargetRegisterClass", "*", "RC", ";", "switch", "(", "BitsSet", ")", "{", "default", ":", "return", ";", "case", "1", ":", "RC", "=", "&", "AMDGPU", "::", "VGPR_32RegClass", ";", "break", ";", "case", "2", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_64RegClass", ";", "break", ";", "case", "3", ":", "RC", "=", "&", "AMDGPU", "::", "VReg_96RegClass", ";", "break", ";", "}", "unsigned", "NewOpcode", "=", "TII", "->", "getMaskedMIMGOp", "(", "MI", "->", "getOpcode", "(", ")", ",", "BitsSet", ")", ";", "MI", "->", "setDesc", "(", "TII", "->", "get", "(", "NewOpcode", ")", ")", ";", "MRI", ".", "setRegClass", "(", "VReg", ",", "RC", ")", ";", "return", ";", "}", "int", "NoRetAtomicOp", "=", "AMDGPU", "::", "getAtomicNoRetOp", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "if", "(", "NoRetAtomicOp", "!=", "-", "1", ")", "{", "if", "(", "!", "Node", "->", "hasAnyUseOfValue", "(", "0", ")", ")", "{", "MI", "->", "setDesc", "(", "TII", "->", "get", "(", "NoRetAtomicOp", ")", ")", ";", "MI", "->", "RemoveOperand", "(", "0", ")", ";", "return", ";", "}", "if", "(", "(", "Node", "->", "hasNUsesOfValue", "(", "1", ",", "0", ")", "&&", "Node", "->", "use_begin", "(", ")", "->", "isMachineOpcode", "(", ")", "&&", "Node", "->", "use_begin", "(", ")", "->", "getMachineOpcode", "(", ")", "==", "AMDGPU", "::", "EXTRACT_SUBREG", "&&", "!", "Node", "->", "use_begin", "(", ")", "->", "hasAnyUseOfValue", "(", "0", ")", ")", ")", "{", "unsigned", "Def", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "MI", "->", "setDesc", "(", "TII", "->", "get", "(", "NoRetAtomicOp", ")", ")", ";", "MI", "->", "RemoveOperand", "(", "0", ")", ";", "BuildMI", "(", "*", "MI", "->", "getParent", "(", ")", ",", "MI", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "TII", "->", "get", "(", "AMDGPU", "::", "IMPLICIT_DEF", ")", ",", "Def", ")", ";", "}", "return", ";", "}", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "SI", "0", "12", "3", "4", "0", "0", "4", "1", "1", "0", "1", "AMDGPU::VGPR_32RegClass", "2", "AMDGPU::VReg_64RegClass", "3", "AMDGPU::VReg_96RegClass", "AMDGPU::getAtomicNoRetOp", "1", "0", "0", "1", "0", "AMDGPU::EXTRACT_SUBREG", "0", "0", "0", "AMDGPU::IMPLICIT_DEF" ]

[]

[ "<s>", "void", "ConvergingVLIWScheduler", "::", "releaseBottomNode", "(", "SUnit", "*", "SU", ")", "{", "assert", "(", "SU", "->", "getInstr", "(", ")", "&&", "\"Scheduled SUnit must have instr\"", ")", ";", "for", "(", "SUnit", "::", "succ_iterator", "I", "=", "SU", "->", "Succs", ".", "begin", "(", ")", ",", "E", "=", "SU", "->", "Succs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "unsigned", "SuccReadyCycle", "=", "I", "->", "getSUnit", "(", ")", "->", "BotReadyCycle", ";", "unsigned", "MinLatency", "=", "I", "->", "getLatency", "(", ")", ";", "Bot", ".", "MaxMinLatency", "=", "std", "::", "max", "(", "MinLatency", ",", "Bot", ".", "MaxMinLatency", ")", ";", "if", "(", "SU", "->", "BotReadyCycle", "<", "SuccReadyCycle", "+", "MinLatency", ")", "SU", "->", "BotReadyCycle", "=", "SuccReadyCycle", "+", "MinLatency", ";", "}", "if", "(", "!", "SU", "->", "isScheduled", ")", "Bot", ".", "releaseNode", "(", "SU", ",", "SU", "->", "BotReadyCycle", ")", ";", "}", "</s>" ]

[ "Currently", "only", "scheduling", "top-down", ",", "so", "this", "method", "is", "empty", "." ]

[ "Hexagon", "\"Scheduled SUnit must have instr\"" ]

[]

[ "<s>", "bool", "MipsTargetObjectFile", "::", "IsConstantInSmallSection", "(", "const", "Constant", "*", "CN", ",", "const", "TargetMachine", "&", "TM", ")", "const", "{", "return", "(", "TM", ".", "getSubtarget", "<", "MipsSubtarget", ">", "(", ")", ".", "useSmallSection", "(", ")", "&&", "LocalSData", "&&", "IsInSmallSection", "(", "TM", ".", "getDataLayout", "(", ")", "->", "getTypeAllocSize", "(", "CN", "->", "getType", "(", ")", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "this", "constant", "should", "be", "placed", "into", "small", "data", "section", "." ]

[ "Mips", "Mips", "Mips" ]

[]

[ "<s>", "bool", "MBlazeAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ",", "MCStreamer", "&", "Out", ")", "{", "MCInst", "Inst", ";", "unsigned", "Kind", ";", "unsigned", "ErrorInfo", ";", "SmallVector", "<", "std", "::", "pair", "<", "unsigned", ",", "std", "::", "string", ">", ",", "4", ">", "MapAndConstraints", ";", "switch", "(", "MatchInstructionImpl", "(", "Operands", ",", "Kind", ",", "Inst", ",", "MapAndConstraints", ",", "ErrorInfo", ",", "false", ")", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "Out", ".", "EmitInstruction", "(", "Inst", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction use requires an option to be enabled\"", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"unrecognized instruction mnemonic\"", ")", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "MBlazeOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "}", "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", "." ]

[ "MBlaze", "MBlaze", "4", "\"instruction use requires an option to be enabled\"", "\"unrecognized instruction mnemonic\"", "0U", "\"too few operands for instruction\"", "MBlaze", "\"invalid operand for instruction\"", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "bool", "m16_based_address_p", "(", "rtx", "x", ",", "machine_mode", "mode", ",", "insn_operand_predicate_fn", "offset_predicate", ")", "{", "struct", "mips_address_info", "addr", ";", "return", "(", "mips_classify_address", "(", "&", "addr", ",", "x", ",", "mode", ",", "false", ")", "&&", "addr", ".", "type", "==", "ADDRESS_REG", "&&", "M16_REG_P", "(", "REGNO", "(", "addr", ".", "reg", ")", ")", "&&", "offset_predicate", "(", "addr", ".", "offset", ",", "mode", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "X", "is", "legitimate", "for", "accessing", "values", "of", "mode", "MODE", ",", "if", "it", "is", "based", "on", "a", "MIPS16", "register", ",", "and", "if", "the", "offset", "satisfies", "OFFSET_PREDICATE", "." ]

[ "mips" ]

[]

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

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "SITargetLowering", "::", "ConstraintType", "SITargetLowering", "::", "getConstraintType", "(", "StringRef", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'s'", ":", "case", "'v'", ":", "return", "C_RegisterClass", ";", "}", "}", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "SI", "1", "0" ]

[]

[ "<s>", "static", "rtx", "riscv_legitimize_address", "(", "rtx", "x", ",", "rtx", "oldx", "ATTRIBUTE_UNUSED", ",", "machine_mode", "mode", ")", "{", "rtx", "addr", ";", "if", "(", "riscv_tls_symbol_p", "(", "x", ")", ")", "return", "riscv_legitimize_tls_address", "(", "x", ")", ";", "if", "(", "riscv_split_symbol", "(", "NULL", ",", "x", ",", "mode", ",", "&", "addr", ")", ")", "return", "riscv_force_address", "(", "addr", ",", "mode", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", "&&", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", "&&", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", "!=", "0", ")", "{", "rtx", "base", "=", "XEXP", "(", "x", ",", "0", ")", ";", "HOST_WIDE_INT", "offset", "=", "INTVAL", "(", "XEXP", "(", "x", ",", "1", ")", ")", ";", "if", "(", "!", "riscv_valid_base_register_p", "(", "base", ",", "mode", ",", "false", ")", ")", "base", "=", "copy_to_mode_reg", "(", "Pmode", ",", "base", ")", ";", "addr", "=", "riscv_add_offset", "(", "NULL", ",", "base", ",", "offset", ")", ";", "return", "riscv_force_address", "(", "addr", ",", "mode", ")", ";", "}", "return", "x", ";", "}", "</s>" ]

[ "This", "function", "is", "used", "to", "implement", "LEGITIMIZE_ADDRESS", ".", "If", "X", "can", "be", "legitimized", "in", "a", "way", "that", "the", "generic", "machinery", "might", "not", "expect", ",", "return", "a", "new", "address", ",", "otherwise", "return", "NULL", ".", "MODE", "is", "the", "mode", "of", "the", "memory", "being", "accessed", "." ]

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

[]

[ "<s>", "void", "ARMTargetLowering", "::", "computeKnownBitsForTargetNode", "(", "const", "SDValue", "Op", ",", "APInt", "&", "KnownZero", ",", "APInt", "&", "KnownOne", ",", "const", "SelectionDAG", "&", "DAG", ",", "unsigned", "Depth", ")", "const", "{", "unsigned", "BitWidth", "=", "KnownOne", ".", "getBitWidth", "(", ")", ";", "KnownZero", "=", "KnownOne", "=", "APInt", "(", "BitWidth", ",", "0", ")", ";", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARMISD", "::", "ADDC", ":", "case", "ARMISD", "::", "ADDE", ":", "case", "ARMISD", "::", "SUBC", ":", "case", "ARMISD", "::", "SUBE", ":", "if", "(", "Op", ".", "getResNo", "(", ")", "==", "0", ")", "break", ";", "KnownZero", "|=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "1", ")", ";", "break", ";", "case", "ARMISD", "::", "CMOV", ":", "{", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "0", ")", ",", "KnownZero", ",", "KnownOne", ",", "Depth", "+", "1", ")", ";", "if", "(", "KnownZero", "==", "0", "&&", "KnownOne", "==", "0", ")", "return", ";", "APInt", "KnownZeroRHS", ",", "KnownOneRHS", ";", "DAG", ".", "computeKnownBits", "(", "Op", ".", "getOperand", "(", "1", ")", ",", "KnownZeroRHS", ",", "KnownOneRHS", ",", "Depth", "+", "1", ")", ";", "KnownZero", "&=", "KnownZeroRHS", ";", "KnownOne", "&=", "KnownOneRHS", ";", "return", ";", "}", "case", "ISD", "::", "INTRINSIC_W_CHAIN", ":", "{", "ConstantSDNode", "*", "CN", "=", "cast", "<", "ConstantSDNode", ">", "(", "Op", "->", "getOperand", "(", "1", ")", ")", ";", "Intrinsic", "::", "ID", "IntID", "=", "static_cast", "<", "Intrinsic", "::", "ID", ">", "(", "CN", "->", "getZExtValue", "(", ")", ")", ";", "switch", "(", "IntID", ")", "{", "default", ":", "return", ";", "case", "Intrinsic", "::", "arm_ldaex", ":", "case", "Intrinsic", "::", "arm_ldrex", ":", "{", "EVT", "VT", "=", "cast", "<", "MemIntrinsicSDNode", ">", "(", "Op", ")", "->", "getMemoryVT", "(", ")", ";", "unsigned", "MemBits", "=", "VT", ".", "getScalarSizeInBits", "(", ")", ";", "KnownZero", "|=", "APInt", "::", "getHighBitsSet", "(", "BitWidth", ",", "BitWidth", "-", "MemBits", ")", ";", "return", ";", "}", "}", "}", "}", "}", "</s>" ]

[ "Determine", "which", "of", "the", "bits", "specified", "in", "Mask", "are", "known", "to", "be", "either", "zero", "or", "one", "and", "return", "them", "in", "the", "KnownZero/KnownOne", "bitsets", "." ]

[ "ARM", "ARM", "0", "ARMISD::ADDC", "ARMISD::ADDE", "ARMISD::SUBC", "ARMISD::SUBE", "0", "1", "ARMISD::CMOV", "0", "1", "0", "0", "1", "1", "ISD::INTRINSIC_W_CHAIN", "1", "Intrinsic::ID", "Intrinsic::ID", "Intrinsic::arm_ldaex", "Intrinsic::arm_ldrex" ]

[]

[ "<s>", "void", "output_profile_hook", "(", "int", "labelno", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "TARGET_PROFILE_KERNEL", ")", "return", ";", "if", "(", "DEFAULT_ABI", "==", "ABI_AIX", "||", "DEFAULT_ABI", "==", "ABI_ELFv2", ")", "{", "if", "(", "NO_PROFILE_COUNTERS", ")", "emit_library_call", "(", "init_one_libfunc", "(", "RS6000_MCOUNT", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "0", ")", ";", "else", "{", "char", "buf", "[", "30", "]", ";", "const", "char", "*", "label_name", ";", "rtx", "fun", ";", "ASM_GENERATE_INTERNAL_LABEL", "(", "buf", ",", "\"LP\"", ",", "labelno", ")", ";", "label_name", "=", "ggc_strdup", "(", "(", "*", "targetm", ".", "strip_name_encoding", ")", "(", "buf", ")", ")", ";", "fun", "=", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "label_name", ")", ";", "emit_library_call", "(", "init_one_libfunc", "(", "RS6000_MCOUNT", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "1", ",", "fun", ",", "Pmode", ")", ";", "}", "}", "else", "if", "(", "DEFAULT_ABI", "==", "ABI_DARWIN", ")", "{", "const", "char", "*", "mcount_name", "=", "RS6000_MCOUNT", ";", "int", "caller_addr_regno", "=", "LR_REGNO", ";", "crtl", "->", "uses_pic_offset_table", "=", "1", ";", "if", "(", "MACHOPIC_INDIRECT", "&&", "crtl", "->", "uses_pic_offset_table", ")", "caller_addr_regno", "=", "0", ";", "emit_library_call", "(", "gen_rtx_SYMBOL_REF", "(", "Pmode", ",", "mcount_name", ")", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "1", ",", "gen_rtx_REG", "(", "Pmode", ",", "caller_addr_regno", ")", ",", "Pmode", ")", ";", "}", "}", "</s>" ]

[ "Emit", "profile", "function", "." ]

[ "rs6000", "0", "30", "\"LP\"", "1", "1", "0", "1" ]

[]

[ "<s>", "static", "bool", "riscv_symbol_binds_local_p", "(", "const_rtx", "x", ")", "{", "if", "(", "SYMBOL_REF_P", "(", "x", ")", ")", "return", "(", "SYMBOL_REF_DECL", "(", "x", ")", "?", "targetm", ".", "binds_local_p", "(", "SYMBOL_REF_DECL", "(", "x", ")", ")", ":", "SYMBOL_REF_LOCAL_P", "(", "x", ")", ")", ";", "else", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "symbol", "X", "binds", "locally", "." ]

[ "riscv" ]

[]

[ "<s>", "static", "void", "frv_output_const_unspec", "(", "FILE", "*", "stream", ",", "const", "struct", "frv_unspec", "*", "unspec", ")", "{", "fprintf", "(", "stream", ",", "\"#%s(\"", ",", "unspec_got_name", "(", "unspec", "->", "reloc", ")", ")", ";", "output_addr_const", "(", "stream", ",", "plus_constant", "(", "Pmode", ",", "unspec", "->", "symbol", ",", "unspec", "->", "offset", ")", ")", ";", "fputs", "(", "\")\"", ",", "stream", ")", ";", "}", "</s>" ]

[ "Write", "the", "assembler", "syntax", "for", "UNSPEC", "to", "STREAM", ".", "Note", "that", "any", "offset", "is", "added", "inside", "the", "relocation", "operator", "." ]

[ "frv", "\"#%s(\"", "\")\"" ]

[]

[ "<s>", "virtual", "const", "SparcInstrInfo", "*", "getInstrInfo", "(", ")", "const", "{", "return", "&", "InstrInfo", ";", "}", "</s>" ]

[ "TargetInstrInfo", "getter", "." ]

[ "Sparc", "Sparc" ]

[]

[ "<s>", "void", "X86PassConfig", "::", "addPreEmitPass", "(", ")", "{", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createExecutionDependencyFixPass", "(", "&", "X86", "::", "VR128XRegClass", ")", ")", ";", "if", "(", "UseVZeroUpper", ")", "addPass", "(", "createX86IssueVZeroUpperPass", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createX86FixupBWInsts", "(", ")", ")", ";", "addPass", "(", "createX86PadShortFunctions", "(", ")", ")", ";", "addPass", "(", "createX86FixupLEAs", "(", ")", ")", ";", "addPass", "(", "createX86EvexToVexInsts", "(", ")", ")", ";", "}", "}", "</s>" ]

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

[ "X86", "X86", "X86::VR128XRegClass", "X86", "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "void", "Z80InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "DstReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "TRC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "unsigned", "Opc", ";", "switch", "(", "TRI", "->", "getSpillSize", "(", "*", "TRC", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unexpected regclass size\"", ")", ";", "case", "1", ":", "Opc", "=", "Z80", "::", "LD8ro", ";", "break", ";", "case", "2", ":", "Opc", "=", "Subtarget", ".", "has16BitEZ80Ops", "(", ")", "?", "Z80", "::", "LD16ro", ":", "Z80", "::", "LD88ro", ";", "break", ";", "case", "3", ":", "assert", "(", "Subtarget", ".", "is24Bit", "(", ")", "&&", "\"Only 24-bit should have 3 byte stack slots\"", ")", ";", "Opc", "=", "Z80", "::", "LD24ro", ";", "break", ";", "}", "BuildMI", "(", "MBB", ",", "MI", ",", "MBB", ".", "findDebugLoc", "(", "MI", ")", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "return", ";", "unsigned", "RC", ",", "LoOpc", ",", "LoIdx", ",", "HiOpc", ",", "HiIdx", ",", "HiOff", ";", "bool", "Split", "=", "Z80", "::", "splitReg", "(", "TRI", "->", "getSpillSize", "(", "*", "TRC", ")", ",", "Z80", "::", "LD8ro", ",", "Z80", "::", "LD16ro", ",", "Z80", "::", "LD24ro", ",", "RC", ",", "LoOpc", ",", "LoIdx", ",", "HiOpc", ",", "HiIdx", ",", "HiOff", ",", "Subtarget", ".", "hasEZ80Ops", "(", ")", ")", ";", "MachineInstrBuilder", "LoMIB", "=", "addSubReg", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "MBB", ".", "findDebugLoc", "(", "MI", ")", ",", "get", "(", "LoOpc", ")", ")", ",", "DstReg", ",", "LoIdx", ",", "TRI", ",", "RegState", "::", "DefineNoRead", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ";", "if", "(", "Split", ")", "{", "MachineInstrBuilder", "HiMIB", "=", "addSubReg", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "MBB", ".", "findDebugLoc", "(", "MI", ")", ",", "get", "(", "HiOpc", ")", ")", ",", "DstReg", ",", "HiIdx", ",", "TRI", ",", "RegState", "::", "Define", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "HiOff", ")", ";", "HiMIB", "->", "addRegisterDefined", "(", "DstReg", ",", "TRI", ")", ";", "}", "}", "</s>" ]

[ "Load", "the", "specified", "register", "of", "the", "given", "register", "class", "from", "the", "specified", "stack", "frame", "index", "." ]

[ "Z80", "Z80", "\"Unexpected regclass size\"", "1", "Z80::LD8ro", "2", "Z80", "Z80::LD16ro", "Z80::LD88ro", "3", "\"Only 24-bit should have 3 byte stack slots\"", "Z80::LD24ro", "0", "Z80::splitReg", "Z80::LD8ro", "Z80::LD16ro", "Z80::LD24ro", "Z80", "0" ]

[]

[ "<s>", "bool", "SSEDomainFixPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "mf", ")", "{", "MF", "=", "&", "mf", ";", "TII", "=", "static_cast", "<", "const", "X86InstrInfo", "*", ">", "(", "MF", "->", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "MF", "->", "getTarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MBB", "=", "0", ";", "LiveRegs", "=", "0", ";", "Distance", "=", "0", ";", "assert", "(", "NumRegs", "==", "X86", "::", "VR128RegClass", ".", "getNumRegs", "(", ")", "&&", "\"Bad regclass\"", ")", ";", "bool", "anyregs", "=", "false", ";", "for", "(", "TargetRegisterClass", "::", "const_iterator", "I", "=", "X86", "::", "VR128RegClass", ".", "begin", "(", ")", ",", "E", "=", "X86", "::", "VR128RegClass", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "if", "(", "MF", "->", "getRegInfo", "(", ")", ".", "isPhysRegUsed", "(", "*", "I", ")", ")", "{", "anyregs", "=", "true", ";", "break", ";", "}", "if", "(", "!", "anyregs", ")", "return", "false", ";", "MachineBasicBlock", "*", "Entry", "=", "MF", "->", "begin", "(", ")", ";", "SmallPtrSet", "<", "MachineBasicBlock", "*", ",", "16", ">", "Visited", ";", "for", "(", "df_ext_iterator", "<", "MachineBasicBlock", "*", ",", "SmallPtrSet", "<", "MachineBasicBlock", "*", ",", "16", ">", ">", "DFI", "=", "df_ext_begin", "(", "Entry", ",", "Visited", ")", ",", "DFE", "=", "df_ext_end", "(", "Entry", ",", "Visited", ")", ";", "DFI", "!=", "DFE", ";", "++", "DFI", ")", "{", "MBB", "=", "*", "DFI", ";", "enterBasicBlock", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", "->", "begin", "(", ")", ",", "E", "=", "MBB", "->", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "MachineInstr", "*", "mi", "=", "I", ";", "if", "(", "mi", "->", "isDebugValue", "(", ")", ")", "continue", ";", "++", "Distance", ";", "std", "::", "pair", "<", "uint16_t", ",", "uint16_t", ">", "domp", "=", "TII", "->", "GetSSEDomain", "(", "mi", ")", ";", "if", "(", "domp", ".", "first", ")", "if", "(", "domp", ".", "second", ")", "visitSoftInstr", "(", "mi", ",", "domp", ".", "second", ")", ";", "else", "visitHardInstr", "(", "mi", ",", "domp", ".", "first", ")", ";", "else", "if", "(", "LiveRegs", ")", "visitGenericInstr", "(", "mi", ")", ";", "}", "if", "(", "LiveRegs", ")", "LiveOuts", ".", "insert", "(", "std", "::", "make_pair", "(", "MBB", ",", "LiveRegs", ")", ")", ";", "LiveRegs", "=", "0", ";", "}", "for", "(", "LiveOutMap", "::", "const_iterator", "i", "=", "LiveOuts", ".", "begin", "(", ")", ",", "e", "=", "LiveOuts", ".", "end", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "delete", "[", "]", "i", "->", "second", ";", "LiveOuts", ".", "clear", "(", ")", ";", "Avail", ".", "clear", "(", ")", ";", "Allocator", ".", "DestroyAll", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "runOnMachineFunction", "-", "Emit", "the", "function", "body", "." ]

[ "X86", "X86", "0", "0", "0", "X86::VR128RegClass", "\"Bad regclass\"", "X86::VR128RegClass", "X86::VR128RegClass", "16", "16", "0" ]

[]

[ "<s>", "static", "enum", "insn_path", "get_insn_path", "(", "rtx_insn", "*", "insn", ")", "{", "enum", "attr_amdfam10_decode", "path", "=", "get_attr_amdfam10_decode", "(", "insn", ")", ";", "if", "(", "(", "int", ")", "path", "==", "0", ")", "return", "path_single", ";", "if", "(", "(", "int", ")", "path", "==", "1", ")", "return", "path_double", ";", "return", "path_multi", ";", "}", "</s>" ]

[ "Return", "single", "or", "double", "path", "for", "instructions", "." ]

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

[]

[ "<s>", "static", "inline", "TOCKey", "getTombstoneKey", "(", ")", "{", "return", "{", "nullptr", ",", "MCSymbolRefExpr", "::", "VariantKind", "::", "VK_Invalid", "}", ";", "}", "</s>" ]

[ "Difference", "in", "tombstone", "is", "that", "the", "Optional", "is", "meaningful", "." ]

[ "PowerPC" ]

[]

[ "<s>", "void", "HexagonTTIImpl", "::", "getUnrollingPreferences", "(", "Loop", "*", "L", ",", "TTI", "::", "UnrollingPreferences", "&", "UP", ")", "{", "UP", ".", "Runtime", "=", "UP", ".", "Partial", "=", "true", ";", "}", "</s>" ]

[ "Get", "target-customized", "preferences", "for", "the", "generic", "loop", "unrolling", "transformation", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "unsigned", "BPFMCCodeEmitter", "::", "getMachineOpValue", "(", "const", "MCInst", "&", "MI", ",", "const", "MCOperand", "&", "MO", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "if", "(", "MO", ".", "isReg", "(", ")", ")", "return", "MRI", ".", "getEncodingValue", "(", "MO", ".", "getReg", "(", ")", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "static_cast", "<", "unsigned", ">", "(", "MO", ".", "getImm", "(", ")", ")", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "MCExpr", "::", "ExprKind", "Kind", "=", "Expr", "->", "getKind", "(", ")", ";", "assert", "(", "Kind", "==", "MCExpr", "::", "SymbolRef", ")", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "BPF", "::", "JAL", ")", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "Expr", ",", "FK_SecRel_4", ")", ")", ";", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "BPF", "::", "LD_imm64", ")", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "Expr", ",", "FK_SecRel_8", ")", ")", ";", "else", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "Expr", ",", "FK_PCRel_2", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getMachineOpValue", "-", "Return", "binary", "encoding", "of", "operand", "." ]

[ "BPF", "BPF", "BPF::JAL", "0", "BPF::LD_imm64", "0", "0", "0" ]

[]

[ "<s>", "void", "DarwinARMAsmBackend", "::", "applyFixup", "(", "const", "MCFixup", "&", "Fixup", ",", "char", "*", "Data", ",", "unsigned", "DataSize", ",", "uint64_t", "Value", ")", "const", "{", "unsigned", "NumBytes", "=", "getFixupKindNumBytes", "(", "Fixup", ".", "getKind", "(", ")", ")", ";", "Value", "=", "adjustFixupValue", "(", "Fixup", ",", "Value", ")", ";", "if", "(", "!", "Value", ")", "return", ";", "unsigned", "Offset", "=", "Fixup", ".", "getOffset", "(", ")", ";", "assert", "(", "Offset", "+", "NumBytes", "<=", "DataSize", "&&", "\"Invalid fixup offset!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumBytes", ";", "++", "i", ")", "Data", "[", "Offset", "+", "i", "]", "|=", "uint8_t", "(", "(", "Value", ">>", "(", "i", "*", "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", "." ]

[ "ARM", "ARM", "\"Invalid fixup offset!\"", "0", "8", "0xff" ]

[]

[ "<s>", "uint64_t", "evaluateBranch", "(", "const", "MCInst", "&", "Inst", ",", "uint64_t", "Addr", ",", "uint64_t", "Size", ")", "const", "{", "if", "(", "Info", "->", "get", "(", "Inst", ".", "getOpcode", "(", ")", ")", ".", "OpInfo", "[", "0", "]", ".", "OperandType", "!=", "MCOI", "::", "OPERAND_PCREL", ")", "return", "-", "1ULL", ";", "int64_t", "Imm", "=", "Inst", ".", "getOperand", "(", "0", ")", ".", "getImm", "(", ")", ";", "return", "Addr", "+", "Imm", "+", "8", ";", "}", "</s>" ]

[ "Given", "a", "branch", "instruction", "try", "to", "get", "the", "address", "the", "branch", "targets", "." ]

[ "ARM", "0", "1ULL", "0", "8" ]

[]

[ "<s>", "void", "R600DAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "unsigned", "int", "Opc", "=", "N", "->", "getOpcode", "(", ")", ";", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", ";", "}", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "AMDGPUISD", "::", "BUILD_VERTICAL_VECTOR", ":", "case", "ISD", "::", "SCALAR_TO_VECTOR", ":", "case", "ISD", "::", "BUILD_VECTOR", ":", "{", "EVT", "VT", "=", "N", "->", "getValueType", "(", "0", ")", ";", "unsigned", "NumVectorElts", "=", "VT", ".", "getVectorNumElements", "(", ")", ";", "unsigned", "RegClassID", ";", "switch", "(", "NumVectorElts", ")", "{", "case", "2", ":", "RegClassID", "=", "R600", "::", "R600_Reg64RegClassID", ";", "break", ";", "case", "4", ":", "if", "(", "Opc", "==", "AMDGPUISD", "::", "BUILD_VERTICAL_VECTOR", ")", "RegClassID", "=", "R600", "::", "R600_Reg128VerticalRegClassID", ";", "else", "RegClassID", "=", "R600", "::", "R600_Reg128RegClassID", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Do not know how to lower this BUILD_VECTOR\"", ")", ";", "}", "SelectBuildVector", "(", "N", ",", "RegClassID", ")", ";", "return", ";", "}", "}", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "AMDGPU", "R600", "1", "AMDGPUISD::BUILD_VERTICAL_VECTOR", "ISD::SCALAR_TO_VECTOR", "ISD::BUILD_VECTOR", "0", "2", "R600::R600_Reg64RegClassID", "4", "AMDGPUISD::BUILD_VERTICAL_VECTOR", "R600::R600_Reg128VerticalRegClassID", "R600::R600_Reg128RegClassID", "\"Do not know how to lower this BUILD_VECTOR\"" ]

[]

[ "<s>", "bool", "mips_expand_block_move", "(", "rtx", "dest", ",", "rtx", "src", ",", "rtx", "length", ")", "{", "if", "(", "GET_CODE", "(", "length", ")", "==", "CONST_INT", ")", "{", "if", "(", "INTVAL", "(", "length", ")", "<=", "2", "*", "MAX_MOVE_BYTES", ")", "{", "mips_block_move_straight", "(", "dest", ",", "src", ",", "INTVAL", "(", "length", ")", ")", ";", "return", "true", ";", "}", "else", "if", "(", "optimize", ")", "{", "mips_block_move_loop", "(", "dest", ",", "src", ",", "INTVAL", "(", "length", ")", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Expand", "a", "movmemsi", "instruction", ",", "which", "copies", "LENGTH", "bytes", "from", "memory", "reference", "SRC", "to", "memory", "reference", "DEST", "." ]

[ "mips", "2" ]

[]

[ "<s>", "MCSection", "*", "getNonexecutableStackSection", "(", "MCContext", "&", "Ctx", ")", "const", "override", "{", "return", "nullptr", ";", "}", "</s>" ]

[ "Targets", "can", "implement", "this", "method", "to", "specify", "a", "section", "to", "switch", "to", "if", "the", "translation", "unit", "does", "n't", "have", "any", "trampolines", "that", "require", "an", "executable", "stack", "." ]

[ "X86" ]

[]

[ "<s>", "void", "Mips16InstrInfo", "::", "adjustStackPtr", "(", "unsigned", "SP", ",", "int64_t", "Amount", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "if", "(", "Amount", "==", "0", ")", "return", ";", "if", "(", "isInt", "<", "16", ">", "(", "Amount", ")", ")", "BuildAddiuSpImm", "(", "MBB", ",", "I", ",", "Amount", ")", ";", "else", "adjustStackPtrBigUnrestricted", "(", "SP", ",", "Amount", ",", "MBB", ",", "I", ")", ";", "}", "</s>" ]

[ "Adjust", "SP", "by", "Amount", "bytes", "." ]

[ "Mips", "Mips", "0", "16" ]

[]

[ "<s>", "static", "const", "char", "*", "tilegx_output_simple_cbranch_with_opcode", "(", "rtx_insn", "*", "insn", ",", "const", "char", "*", "opcode", ",", "int", "regop", ",", "bool", "reverse_predicted", ")", "{", "static", "char", "buf", "[", "64", "]", ";", "sprintf", "(", "buf", ",", "\"%s%s\\t%%r%d, %%l0\"", ",", "opcode", ",", "(", "cbranch_predicted_p", "(", "insn", ")", "^", "reverse_predicted", ")", "?", "\"t\"", ":", "\"\"", ",", "regop", ")", ";", "return", "buf", ";", "}", "</s>" ]

[ "Output", "assembly", "code", "for", "a", "specific", "branch", "instruction", ",", "appending", "the", "branch", "prediction", "flag", "to", "the", "opcode", "if", "appropriate", "." ]

[ "tilegx", "64", "\"%s%s\\t%%r%d, %%l0\"", "\"t\"", "\"\"" ]

[]

[ "<s>", "int", "arm_count_ldrdstrd_insns", "(", "rtx", "*", "operands", ",", "bool", "load", ")", "{", "int", "count", ";", "rtx", "ops", "[", "2", "]", ";", "int", "regnum", ",", "memnum", ";", "if", "(", "load", ")", "regnum", "=", "0", ",", "memnum", "=", "1", ";", "else", "regnum", "=", "1", ",", "memnum", "=", "0", ";", "ops", "[", "regnum", "]", "=", "gen_rtx_REG", "(", "DImode", ",", "REGNO", "(", "operands", "[", "0", "]", ")", ")", ";", "ops", "[", "memnum", "]", "=", "adjust_address", "(", "operands", "[", "2", "]", ",", "DImode", ",", "0", ")", ";", "output_move_double", "(", "ops", ",", "false", ",", "&", "count", ")", ";", "return", "count", ";", "}", "</s>" ]

[ "Same", "as", "above", ",", "but", "operands", "are", "a", "register/memory", "pair", "in", "SImode", ".", "Assumes", "operands", "has", "the", "base", "register", "in", "position", "0", "and", "memory", "in", "position", "2", "(", "which", "is", "the", "order", "provided", "by", "the", "arm_", "{", "ldrd", ",", "strd", "}", "patterns", ")", "." ]

[ "arm", "2", "0", "1", "1", "0", "0", "2", "0" ]

[]

[ "<s>", "bool", "forceScalarizeMaskedGather", "(", "VectorType", "*", "VTy", ",", "Align", "Alignment", ")", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "forces", "scalarizing", "of", "llvm.masked.gather", "intrinsics", "." ]

[ "ARM" ]

[]

[ "<s>", "bool", "TeakFrameLowering", "::", "spillCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "const", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "CSI", ".", "empty", "(", ")", ")", "return", "false", ";", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "MI", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "const", "TeakSubtarget", "&", "STI", "=", "MF", ".", "getSubtarget", "<", "TeakSubtarget", ">", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "STI", ".", "getInstrInfo", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "CSI", ".", "size", "(", ")", ";", "i", "++", ")", "{", "unsigned", "Reg", "=", "CSI", "[", "i", "]", ".", "getReg", "(", ")", ";", "bool", "IsNotLiveIn", "=", "!", "MBB", ".", "isLiveIn", "(", "Reg", ")", ";", "if", "(", "IsNotLiveIn", ")", "MBB", ".", "addLiveIn", "(", "Reg", ")", ";", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "TII", ".", "get", "(", "Teak", "::", "PUSH_regnob16", ")", ")", ".", "addReg", "(", "Reg", ",", "getKillRegState", "(", "IsNotLiveIn", ")", ")", ".", "setMIFlag", "(", "MachineInstr", "::", "FrameSetup", ")", ";", "}", "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", "(", ")", "." ]

[ "Teak", "Teak", "Teak", "Teak", "0", "Teak::PUSH_regnob16" ]

[]

[ "<s>", "void", "RISCVInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "O", ",", "StringRef", "Annot", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "bool", "Res", "=", "false", ";", "const", "MCInst", "*", "NewMI", "=", "MI", ";", "MCInst", "UncompressedMI", ";", "if", "(", "!", "NoAliases", ")", "Res", "=", "uncompressInst", "(", "UncompressedMI", ",", "*", "MI", ",", "MRI", ",", "STI", ")", ";", "if", "(", "Res", ")", "NewMI", "=", "const_cast", "<", "MCInst", "*", ">", "(", "&", "UncompressedMI", ")", ";", "if", "(", "NoAliases", "||", "!", "printAliasInstr", "(", "NewMI", ",", "STI", ",", "O", ")", ")", "printInstruction", "(", "NewMI", ",", "STI", ",", "O", ")", ";", "printAnnotation", "(", "O", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV" ]

[]

[ "<s>", "bool", "HexagonGenInsert", "::", "removeDeadCode", "(", "MachineDomTreeNode", "*", "N", ")", "{", "bool", "Changed", "=", "false", ";", "for", "(", "auto", "*", "DTN", ":", "children", "<", "MachineDomTreeNode", "*", ">", "(", "N", ")", ")", "Changed", "|=", "removeDeadCode", "(", "DTN", ")", ";", "MachineBasicBlock", "*", "B", "=", "N", "->", "getBlock", "(", ")", ";", "std", "::", "vector", "<", "MachineInstr", "*", ">", "Instrs", ";", "for", "(", "MachineInstr", "&", "MI", ":", "llvm", "::", "reverse", "(", "*", "B", ")", ")", "Instrs", ".", "push_back", "(", "&", "MI", ")", ";", "for", "(", "MachineInstr", "*", "MI", ":", "Instrs", ")", "{", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "if", "(", "Opc", "==", "TargetOpcode", "::", "LIFETIME_START", "||", "Opc", "==", "TargetOpcode", "::", "LIFETIME_END", ")", "continue", ";", "bool", "Store", "=", "false", ";", "if", "(", "MI", "->", "isInlineAsm", "(", ")", "||", "!", "MI", "->", "isSafeToMove", "(", "nullptr", ",", "Store", ")", ")", "continue", ";", "bool", "AllDead", "=", "true", ";", "SmallVector", "<", "unsigned", ",", "2", ">", "Regs", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "operands", "(", ")", ")", "{", "if", "(", "!", "MO", ".", "isReg", "(", ")", "||", "!", "MO", ".", "isDef", "(", ")", ")", "continue", ";", "Register", "R", "=", "MO", ".", "getReg", "(", ")", ";", "if", "(", "!", "R", ".", "isVirtual", "(", ")", "||", "!", "MRI", "->", "use_nodbg_empty", "(", "R", ")", ")", "{", "AllDead", "=", "false", ";", "break", ";", "}", "Regs", ".", "push_back", "(", "R", ")", ";", "}", "if", "(", "!", "AllDead", ")", "continue", ";", "B", "->", "erase", "(", "MI", ")", ";", "for", "(", "unsigned", "I", "=", "0", ",", "N", "=", "Regs", ".", "size", "(", ")", ";", "I", "!=", "N", ";", "++", "I", ")", "MRI", "->", "markUsesInDebugValueAsUndef", "(", "Regs", "[", "I", "]", ")", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

[ "Remove", "all", "dead", "instructions", "between", "the", "I", "and", "E", "." ]

[ "Hexagon", "Hexagon", "2", "0" ]

[]

[ "<s>", "unsigned", "AMDGPURegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "AMDGPU", "::", "NoRegister", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "R600" ]

[]

[ "<s>", "void", "ix86_expand_vector_move_misalign", "(", "enum", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "rtx", "op0", ",", "op1", ",", "m", ";", "op0", "=", "operands", "[", "0", "]", ";", "op1", "=", "operands", "[", "1", "]", ";", "if", "(", "MEM_P", "(", "op1", ")", ")", "{", "if", "(", "optimize_size", ")", "{", "op0", "=", "gen_lowpart", "(", "V4SFmode", ",", "op0", ")", ";", "op1", "=", "gen_lowpart", "(", "V4SFmode", ",", "op1", ")", ";", "emit_insn", "(", "gen_sse_movups", "(", "op0", ",", "op1", ")", ")", ";", "return", ";", "}", "if", "(", "TARGET_SSE2", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_INT", ")", "{", "op0", "=", "gen_lowpart", "(", "V16QImode", ",", "op0", ")", ";", "op1", "=", "gen_lowpart", "(", "V16QImode", ",", "op1", ")", ";", "emit_insn", "(", "gen_sse2_movdqu", "(", "op0", ",", "op1", ")", ")", ";", "return", ";", "}", "if", "(", "TARGET_SSE2", "&&", "mode", "==", "V2DFmode", ")", "{", "rtx", "zero", ";", "if", "(", "TARGET_SSE_SPLIT_REGS", ")", "{", "emit_insn", "(", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "op0", ")", ")", ";", "zero", "=", "op0", ";", "}", "else", "{", "zero", "=", "CONST0_RTX", "(", "V2DFmode", ")", ";", "}", "m", "=", "adjust_address", "(", "op1", ",", "DFmode", ",", "0", ")", ";", "emit_insn", "(", "gen_sse2_loadlpd", "(", "op0", ",", "zero", ",", "m", ")", ")", ";", "m", "=", "adjust_address", "(", "op1", ",", "DFmode", ",", "8", ")", ";", "emit_insn", "(", "gen_sse2_loadhpd", "(", "op0", ",", "op0", ",", "m", ")", ")", ";", "}", "else", "{", "if", "(", "TARGET_SSE_PARTIAL_REG_DEPENDENCY", ")", "emit_move_insn", "(", "op0", ",", "CONST0_RTX", "(", "mode", ")", ")", ";", "else", "emit_insn", "(", "gen_rtx_CLOBBER", "(", "VOIDmode", ",", "op0", ")", ")", ";", "if", "(", "mode", "!=", "V4SFmode", ")", "op0", "=", "gen_lowpart", "(", "V4SFmode", ",", "op0", ")", ";", "m", "=", "adjust_address", "(", "op1", ",", "V2SFmode", ",", "0", ")", ";", "emit_insn", "(", "gen_sse_loadlps", "(", "op0", ",", "op0", ",", "m", ")", ")", ";", "m", "=", "adjust_address", "(", "op1", ",", "V2SFmode", ",", "8", ")", ";", "emit_insn", "(", "gen_sse_loadhps", "(", "op0", ",", "op0", ",", "m", ")", ")", ";", "}", "}", "else", "if", "(", "MEM_P", "(", "op0", ")", ")", "{", "if", "(", "optimize_size", ")", "{", "op0", "=", "gen_lowpart", "(", "V4SFmode", ",", "op0", ")", ";", "op1", "=", "gen_lowpart", "(", "V4SFmode", ",", "op1", ")", ";", "emit_insn", "(", "gen_sse_movups", "(", "op0", ",", "op1", ")", ")", ";", "return", ";", "}", "if", "(", "TARGET_SSE2", "&&", "!", "TARGET_SSE_TYPELESS_STORES", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_INT", ")", "{", "op0", "=", "gen_lowpart", "(", "V16QImode", ",", "op0", ")", ";", "op1", "=", "gen_lowpart", "(", "V16QImode", ",", "op1", ")", ";", "emit_insn", "(", "gen_sse2_movdqu", "(", "op0", ",", "op1", ")", ")", ";", "return", ";", "}", "if", "(", "TARGET_SSE2", "&&", "mode", "==", "V2DFmode", ")", "{", "m", "=", "adjust_address", "(", "op0", ",", "DFmode", ",", "0", ")", ";", "emit_insn", "(", "gen_sse2_storelpd", "(", "m", ",", "op1", ")", ")", ";", "m", "=", "adjust_address", "(", "op0", ",", "DFmode", ",", "8", ")", ";", "emit_insn", "(", "gen_sse2_storehpd", "(", "m", ",", "op1", ")", ")", ";", "}", "else", "{", "if", "(", "mode", "!=", "V4SFmode", ")", "op1", "=", "gen_lowpart", "(", "V4SFmode", ",", "op1", ")", ";", "m", "=", "adjust_address", "(", "op0", ",", "V2SFmode", ",", "0", ")", ";", "emit_insn", "(", "gen_sse_storelps", "(", "m", ",", "op1", ")", ")", ";", "m", "=", "adjust_address", "(", "op0", ",", "V2SFmode", ",", "8", ")", ";", "emit_insn", "(", "gen_sse_storehps", "(", "m", ",", "op1", ")", ")", ";", "}", "}", "else", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Implement", "the", "movmisalign", "patterns", "for", "SSE", ".", "Non-SSE", "modes", "go", "straight", "to", "ix86_expand_vector_move", "." ]

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

[]

[ "<s>", "SDValue", "VETargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "IsVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "IsVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_VE", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "SDValue", "OutVal", "=", "OutVals", "[", "i", "]", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "SExt", ":", "OutVal", "=", "DAG", ".", "getNode", "(", "ISD", "::", "SIGN_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "OutVal", ")", ";", "break", ";", "case", "CCValAssign", "::", "ZExt", ":", "OutVal", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ZERO_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "OutVal", ")", ";", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "OutVal", "=", "DAG", ".", "getNode", "(", "ISD", "::", "ANY_EXTEND", ",", "DL", ",", "VA", ".", "getLocVT", "(", ")", ",", "OutVal", ")", ";", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "{", "assert", "(", "VA", ".", "getLocVT", "(", ")", "==", "MVT", "::", "i64", ")", ";", "assert", "(", "VA", ".", "getValVT", "(", ")", "==", "MVT", "::", "f32", ")", ";", "SDValue", "Undef", "=", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "TargetOpcode", "::", "IMPLICIT_DEF", ",", "DL", ",", "MVT", "::", "i64", ")", ",", "0", ")", ";", "SDValue", "Sub_f32", "=", "DAG", ".", "getTargetConstant", "(", "VE", "::", "sub_f32", ",", "DL", ",", "MVT", "::", "i32", ")", ";", "OutVal", "=", "SDValue", "(", "DAG", ".", "getMachineNode", "(", "TargetOpcode", "::", "INSERT_SUBREG", ",", "DL", ",", "MVT", "::", "i64", ",", "Undef", ",", "OutVal", ",", "Sub_f32", ")", ",", "0", ")", ";", "break", ";", "}", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "}", "assert", "(", "!", "VA", ".", "needsCustom", "(", ")", "&&", "\"Unexpected custom lowering\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "DL", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVal", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "return", "DAG", ".", "getNode", "(", "VEISD", "::", "RET_FLAG", ",", "DL", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "outgoing", "return", "values", ",", "described", "by", "the", "Outs", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "VE", "VE", "ISD::OutputArg", "16", "VE", "4", "1", "0", "\"Can only return in registers!\"", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "ISD::ANY_EXTEND", "MVT::i64", "MVT::f32", "MVT::i64", "0", "VE::sub_f32", "MVT::i32", "MVT::i64", "0", "\"Unknown loc info!\"", "\"Unexpected custom lowering\"", "1", "0", "VEISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "getInstrLatency", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "const", "MachineInstr", "&", "MI", ",", "unsigned", "*", "PredCost", ")", "const", "{", "if", "(", "MI", ".", "isCopyLike", "(", ")", "||", "MI", ".", "isInsertSubreg", "(", ")", "||", "MI", ".", "isRegSequence", "(", ")", "||", "MI", ".", "isImplicitDef", "(", ")", ")", "return", "1", ";", "if", "(", "MI", ".", "isBundle", "(", ")", ")", "{", "unsigned", "Latency", "=", "0", ";", "MachineBasicBlock", "::", "const_instr_iterator", "I", "=", "MI", ".", "getIterator", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "=", "MI", ".", "getParent", "(", ")", "->", "instr_end", "(", ")", ";", "while", "(", "++", "I", "!=", "E", "&&", "I", "->", "isInsideBundle", "(", ")", ")", "{", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "ARM", "::", "t2IT", ")", "Latency", "+=", "getInstrLatency", "(", "ItinData", ",", "*", "I", ",", "PredCost", ")", ";", "}", "return", "Latency", ";", "}", "const", "MCInstrDesc", "&", "MCID", "=", "MI", ".", "getDesc", "(", ")", ";", "if", "(", "PredCost", "&&", "(", "MCID", ".", "isCall", "(", ")", "||", "(", "MCID", ".", "hasImplicitDefOfPhysReg", "(", "ARM", "::", "CPSR", ")", "&&", "!", "Subtarget", ".", "cheapPredicableCPSRDef", "(", ")", ")", ")", ")", "{", "*", "PredCost", "=", "1", ";", "}", "if", "(", "!", "ItinData", ")", "return", "MI", ".", "mayLoad", "(", ")", "?", "3", ":", "1", ";", "unsigned", "Class", "=", "MCID", ".", "getSchedClass", "(", ")", ";", "if", "(", "!", "ItinData", "->", "isEmpty", "(", ")", "&&", "ItinData", "->", "getNumMicroOps", "(", "Class", ")", "<", "0", ")", "return", "getNumMicroOps", "(", "ItinData", ",", "MI", ")", ";", "unsigned", "Latency", "=", "ItinData", "->", "getStageLatency", "(", "Class", ")", ";", "unsigned", "DefAlign", "=", "MI", ".", "hasOneMemOperand", "(", ")", "?", "(", "*", "MI", ".", "memoperands_begin", "(", ")", ")", "->", "getAlign", "(", ")", ".", "value", "(", ")", ":", "0", ";", "int", "Adj", "=", "adjustDefLatency", "(", "Subtarget", ",", "MI", ",", "MCID", ",", "DefAlign", ")", ";", "if", "(", "Adj", ">=", "0", "||", "(", "int", ")", "Latency", ">", "-", "Adj", ")", "{", "return", "Latency", "+", "Adj", ";", "}", "return", "Latency", ";", "}", "</s>" ]

[ "Compute", "the", "instruction", "latency", "of", "a", "given", "instruction", "." ]

[ "ARM", "ARM", "1", "0", "ARM::t2IT", "ARM::CPSR", "1", "3", "1", "0", "0", "0" ]

[]

[ "<s>", "static", "void", "nios2_register_custom_code", "(", "unsigned", "int", "N", ",", "enum", "nios2_ccs_code", "status", ",", "int", "index", ")", "{", "gcc_assert", "(", "N", "<=", "255", ")", ";", "if", "(", "status", "==", "CCS_FPU", ")", "{", "if", "(", "custom_code_status", "[", "N", "]", "==", "CCS_FPU", "&&", "index", "!=", "custom_code_index", "[", "N", "]", ")", "{", "custom_code_conflict", "=", "true", ";", "error", "(", "\"switch %<-mcustom-%s%> conflicts with \"", "\"switch %<-mcustom-%s%>\"", ",", "N2FPU_NAME", "(", "custom_code_index", "[", "N", "]", ")", ",", "N2FPU_NAME", "(", "index", ")", ")", ";", "}", "else", "if", "(", "custom_code_status", "[", "N", "]", "==", "CCS_BUILTIN_CALL", ")", "{", "custom_code_conflict", "=", "true", ";", "error", "(", "\"call to %<__builtin_custom_%s%> conflicts with \"", "\"switch %<-mcustom-%s%>\"", ",", "custom_builtin_name", "[", "custom_code_index", "[", "N", "]", "]", ",", "N2FPU_NAME", "(", "index", ")", ")", ";", "}", "}", "else", "if", "(", "status", "==", "CCS_BUILTIN_CALL", ")", "{", "if", "(", "custom_code_status", "[", "N", "]", "==", "CCS_FPU", ")", "{", "custom_code_conflict", "=", "true", ";", "error", "(", "\"call to %<__builtin_custom_%s%> conflicts with \"", "\"switch %<-mcustom-%s%>\"", ",", "custom_builtin_name", "[", "index", "]", ",", "N2FPU_NAME", "(", "custom_code_index", "[", "N", "]", ")", ")", ";", "}", "else", "{", "}", "}", "else", "gcc_unreachable", "(", ")", ";", "custom_code_status", "[", "N", "]", "=", "status", ";", "custom_code_index", "[", "N", "]", "=", "index", ";", "}", "</s>" ]

[ "Register", "a", "custom", "code", "use", ",", "and", "signal", "error", "if", "a", "conflict", "was", "found", "." ]

[ "nios2", "255", "\"switch %<-mcustom-%s%> conflicts with \"", "\"switch %<-mcustom-%s%>\"", "\"call to %<__builtin_custom_%s%> conflicts with \"", "\"switch %<-mcustom-%s%>\"", "\"call to %<__builtin_custom_%s%> conflicts with \"", "\"switch %<-mcustom-%s%>\"" ]

[]

[ "<s>", "int", "main", "(", "void", ")", "{", "op", "dest", "[", "]", "=", "{", "{", "\"(zero_extract:SI %s\\n\\t\\t\\t (const_int 18)\\n\\t\\t\\t (const_int 0))\"", ",", "\"SI\"", ",", "\"reg_or_mem_operand\"", ",", "\"+r,m\"", "}", ",", "{", "\"(zero_extract:SI %s\\n\\t\\t\\t (const_int 18)\\n\\t\\t\\t (const_int 18))\"", ",", "\"SI\"", ",", "\"reg_or_mem_operand\"", ",", "\"+r,m\"", "}", ",", "{", "\"(subreg:SI %s)\"", ",", "\"HI\"", ",", "\"reg_or_mem_operand\"", ",", "\"=r,m\"", "}", ",", "}", ";", "op", "src", "[", "]", "=", "{", "{", "\"(zero_extract:SI %s\\n\\t\\t\\t (const_int 18)\\n\\t\\t\\t (const_int 0))\"", ",", "\"SI\"", ",", "\"reg_or_mem_operand\"", ",", "\"rm,r\"", "}", ",", "{", "\"(zero_extract:SI %s\\n\\t\\t\\t (const_int 18)\\n\\t\\t\\t (const_int 18))\"", ",", "\"SI\"", ",", "\"reg_or_mem_operand\"", ",", "\"rm,r\"", "}", ",", "{", "\"(sign_extract:SI %s\\n\\t\\t\\t (const_int 18)\\n\\t\\t\\t (const_int 0))\"", ",", "\"SI\"", ",", "\"reg_or_mem_operand\"", ",", "\"rm,r\"", "}", ",", "{", "\"(sign_extract:SI %s\\n\\t\\t\\t (const_int 18)\\n\\t\\t\\t (const_int 18))\"", ",", "\"SI\"", ",", "\"reg_or_mem_operand\"", ",", "\"rm,r\"", "}", ",", "{", "\"(subreg:SI %s)\"", ",", "\"HI\"", ",", "\"reg_or_mem_operand\"", ",", "\"rm,r\"", "}", ",", "{", "\"(and:SI %s\\n\\t\\t(const_int RIGHT_HALF))\"", ",", "\"SI\"", ",", "\"reg_or_mem_operand\"", ",", "\"rm,r\"", "}", ",", "{", "\"(lshiftrt:SI %s\\n\\t\\t (const_int 18))\"", ",", "\"SI\"", ",", "\"reg_or_mem_operand\"", ",", "\"rm,r\"", "}", ",", "{", "\"(ashiftrt:SI %s\\n\\t\\t (const_int 18))\"", ",", "\"SI\"", ",", "\"reg_or_mem_operand\"", ",", "\"rm,r\"", "}", ",", "}", ";", "int", "i", ",", "j", ";", "for", "(", "i", "=", "0", ";", "i", "<", "sizeof", "dest", "/", "sizeof", "dest", "[", "0", "]", ";", "i", "++", ")", "for", "(", "j", "=", "0", ";", "j", "<", "sizeof", "src", "/", "sizeof", "src", "[", "0", "]", ";", "j", "++", ")", "define_insn", "(", "&", "dest", "[", "i", "]", ",", "&", "src", "[", "j", "]", ",", "\"*return pdp10_output_halfword_move (insn);\"", ")", ";", "exit", "(", "0", ")", ";", "}", "</s>" ]

[ "Main", "program", "to", "convert", "flat", "files", "into", "built-in", "initialization", "code", "." ]

[ "pdp10", "\"(zero_extract:SI %s\\n\\t\\t\\t (const_int 18)\\n\\t\\t\\t (const_int 0))\"", "\"SI\"", "\"reg_or_mem_operand\"", "\"+r,m\"", "\"(zero_extract:SI %s\\n\\t\\t\\t (const_int 18)\\n\\t\\t\\t (const_int 18))\"", "\"SI\"", "\"reg_or_mem_operand\"", "\"+r,m\"", "\"(subreg:SI %s)\"", "\"HI\"", "\"reg_or_mem_operand\"", "\"=r,m\"", "\"(zero_extract:SI %s\\n\\t\\t\\t (const_int 18)\\n\\t\\t\\t (const_int 0))\"", "\"SI\"", "\"reg_or_mem_operand\"", "\"rm,r\"", "\"(zero_extract:SI %s\\n\\t\\t\\t (const_int 18)\\n\\t\\t\\t (const_int 18))\"", "\"SI\"", "\"reg_or_mem_operand\"", "\"rm,r\"", "\"(sign_extract:SI %s\\n\\t\\t\\t (const_int 18)\\n\\t\\t\\t (const_int 0))\"", "\"SI\"", "\"reg_or_mem_operand\"", "\"rm,r\"", "\"(sign_extract:SI %s\\n\\t\\t\\t (const_int 18)\\n\\t\\t\\t (const_int 18))\"", "\"SI\"", "\"reg_or_mem_operand\"", "\"rm,r\"", "\"(subreg:SI %s)\"", "\"HI\"", "\"reg_or_mem_operand\"", "\"rm,r\"", "\"(and:SI %s\\n\\t\\t(const_int RIGHT_HALF))\"", "\"SI\"", "\"reg_or_mem_operand\"", "\"rm,r\"", "\"(lshiftrt:SI %s\\n\\t\\t (const_int 18))\"", "\"SI\"", "\"reg_or_mem_operand\"", "\"rm,r\"", "\"(ashiftrt:SI %s\\n\\t\\t (const_int 18))\"", "\"SI\"", "\"reg_or_mem_operand\"", "\"rm,r\"", "0", "0", "0", "0", "\"*return pdp10_output_halfword_move (insn);\"", "0" ]

[]

[ "<s>", "void", "WebAssemblyPassConfig", "::", "addPreEmitPass", "(", ")", "{", "TargetPassConfig", "::", "addPreEmitPass", "(", ")", ";", "addPass", "(", "createWebAssemblyCallIndirectFixup", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyFixIrreducibleControlFlow", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyLateEHPrepare", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyReplacePhysRegs", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "{", "addPass", "(", "createWebAssemblyPrepareForLiveIntervals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyOptimizeLiveIntervals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyMemIntrinsicResults", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegStackify", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegColoring", "(", ")", ")", ";", "}", "addPass", "(", "createWebAssemblyExplicitLocals", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyCFGSort", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyCFGStackify", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyLowerBrUnless", "(", ")", ")", ";", "if", "(", "getOptLevel", "(", ")", "!=", "CodeGenOpt", "::", "None", ")", "addPass", "(", "createWebAssemblyPeephole", "(", ")", ")", ";", "addPass", "(", "createWebAssemblyRegNumbering", "(", ")", ")", ";", "}", "</s>" ]

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

[ "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly", "WebAssembly" ]

[]

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

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

[ "LM32" ]

[]

[ "<s>", "void", "AArch64PassConfig", "::", "addPreRegBankSelect", "(", ")", "{", "bool", "IsOptNone", "=", "getOptLevel", "(", ")", "==", "CodeGenOpt", "::", "None", ";", "if", "(", "!", "IsOptNone", ")", "addPass", "(", "createAArch64PostLegalizeCombiner", "(", "IsOptNone", ")", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "AArch64" ]

[]

[ "<s>", "Align", "getStackAlignment", "(", ")", "const", "{", "return", "Align", "(", "4", ")", ";", "}", "</s>" ]

[ "Returns", "the", "minimum", "alignment", "known", "to", "hold", "of", "the", "stack", "frame", "on", "entry", "to", "the", "function", "and", "which", "must", "be", "maintained", "by", "every", "function", "for", "this", "subtarget", "." ]

[ "AMDGPU", "4" ]

[]

[ "<s>", "void", "SISubtarget", "::", "overrideSchedPolicy", "(", "MachineSchedPolicy", "&", "Policy", ",", "unsigned", "NumRegionInstrs", ")", "const", "{", "Policy", ".", "ShouldTrackPressure", "=", "true", ";", "Policy", ".", "OnlyTopDown", "=", "false", ";", "Policy", ".", "OnlyBottomUp", "=", "false", ";", "if", "(", "!", "enableSIScheduler", "(", ")", ")", "Policy", ".", "ShouldTrackLaneMasks", "=", "true", ";", "}", "</s>" ]

[ "Override", "generic", "scheduling", "policy", "within", "a", "region", "." ]

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

[]

[ "<s>", "Register", "TPCRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "Register", "(", ")", ";", "}", "</s>" ]

[ "Debug", "information", "queries", "." ]

[ "TPC", "TPC" ]

[]

[ "<s>", "unsigned", "SITargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", "VT", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"m0\"", ",", "AMDGPU", "::", "M0", ")", ".", "Case", "(", "\"exec\"", ",", "AMDGPU", "::", "EXEC", ")", ".", "Case", "(", "\"exec_lo\"", ",", "AMDGPU", "::", "EXEC_LO", ")", ".", "Case", "(", "\"exec_hi\"", ",", "AMDGPU", "::", "EXEC_HI", ")", ".", "Case", "(", "\"flat_scratch\"", ",", "AMDGPU", "::", "FLAT_SCR", ")", ".", "Case", "(", "\"flat_scratch_lo\"", ",", "AMDGPU", "::", "FLAT_SCR_LO", ")", ".", "Case", "(", "\"flat_scratch_hi\"", ",", "AMDGPU", "::", "FLAT_SCR_HI", ")", ".", "Default", "(", "AMDGPU", "::", "NoRegister", ")", ";", "if", "(", "Reg", "==", "AMDGPU", "::", "NoRegister", ")", "{", "report_fatal_error", "(", "Twine", "(", "\"invalid register name \\\"\"", "+", "StringRef", "(", "RegName", ")", "+", "\"\\\".\"", ")", ")", ";", "}", "if", "(", "!", "Subtarget", "->", "hasFlatScrRegister", "(", ")", "&&", "Subtarget", "->", "getRegisterInfo", "(", ")", "->", "regsOverlap", "(", "Reg", ",", "AMDGPU", "::", "FLAT_SCR", ")", ")", "{", "report_fatal_error", "(", "Twine", "(", "\"invalid register \\\"\"", "+", "StringRef", "(", "RegName", ")", "+", "\"\\\" for subtarget.\"", ")", ")", ";", "}", "switch", "(", "Reg", ")", "{", "case", "AMDGPU", "::", "M0", ":", "case", "AMDGPU", "::", "EXEC_LO", ":", "case", "AMDGPU", "::", "EXEC_HI", ":", "case", "AMDGPU", "::", "FLAT_SCR_LO", ":", "case", "AMDGPU", "::", "FLAT_SCR_HI", ":", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "32", ")", "return", "Reg", ";", "break", ";", "case", "AMDGPU", "::", "EXEC", ":", "case", "AMDGPU", "::", "FLAT_SCR", ":", "if", "(", "VT", ".", "getSizeInBits", "(", ")", "==", "64", ")", "return", "Reg", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"missing register type checking\"", ")", ";", "}", "report_fatal_error", "(", "Twine", "(", "\"invalid type for register \\\"\"", "+", "StringRef", "(", "RegName", ")", "+", "\"\\\".\"", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "register", "ID", "of", "the", "name", "passed", "in", "." ]

[ "AMDGPU", "SI", "\"m0\"", "AMDGPU::M0", "\"exec\"", "AMDGPU::EXEC", "\"exec_lo\"", "AMDGPU::EXEC_LO", "\"exec_hi\"", "AMDGPU::EXEC_HI", "\"flat_scratch\"", "AMDGPU::FLAT_SCR", "\"flat_scratch_lo\"", "AMDGPU::FLAT_SCR_LO", "\"flat_scratch_hi\"", "AMDGPU::FLAT_SCR_HI", "AMDGPU::NoRegister", "AMDGPU::NoRegister", "\"invalid register name \\\"\"", "\"\\\".\"", "AMDGPU::FLAT_SCR", "\"invalid register \\\"\"", "\"\\\" for subtarget.\"", "AMDGPU::M0", "AMDGPU::EXEC_LO", "AMDGPU::EXEC_HI", "AMDGPU::FLAT_SCR_LO", "AMDGPU::FLAT_SCR_HI", "32", "AMDGPU::EXEC", "AMDGPU::FLAT_SCR", "64", "\"missing register type checking\"", "\"invalid type for register \\\"\"", "\"\\\".\"" ]

[]

[ "<s>", "void", "xstormy16_print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "address", ")", "{", "HOST_WIDE_INT", "offset", ";", "int", "pre_dec", ",", "post_inc", ";", "if", "(", "GET_CODE", "(", "address", ")", "==", "CONST_INT", ")", "{", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "INTVAL", "(", "address", ")", "&", "0xFFFF", ")", ";", "return", ";", "}", "if", "(", "CONSTANT_P", "(", "address", ")", "||", "GET_CODE", "(", "address", ")", "==", "CODE_LABEL", ")", "{", "output_addr_const", "(", "file", ",", "address", ")", ";", "return", ";", "}", "if", "(", "GET_CODE", "(", "address", ")", "==", "PLUS", ")", "{", "gcc_assert", "(", "GET_CODE", "(", "XEXP", "(", "address", ",", "1", ")", ")", "==", "CONST_INT", ")", ";", "offset", "=", "INTVAL", "(", "XEXP", "(", "address", ",", "1", ")", ")", ";", "address", "=", "XEXP", "(", "address", ",", "0", ")", ";", "}", "else", "offset", "=", "0", ";", "pre_dec", "=", "(", "GET_CODE", "(", "address", ")", "==", "PRE_DEC", ")", ";", "post_inc", "=", "(", "GET_CODE", "(", "address", ")", "==", "POST_INC", ")", ";", "if", "(", "pre_dec", "||", "post_inc", ")", "address", "=", "XEXP", "(", "address", ",", "0", ")", ";", "gcc_assert", "(", "GET_CODE", "(", "address", ")", "==", "REG", ")", ";", "fputc", "(", "'('", ",", "file", ")", ";", "if", "(", "pre_dec", ")", "fputs", "(", "\"--\"", ",", "file", ")", ";", "fputs", "(", "reg_names", "[", "REGNO", "(", "address", ")", "]", ",", "file", ")", ";", "if", "(", "post_inc", ")", "fputs", "(", "\"++\"", ",", "file", ")", ";", "if", "(", "offset", "!=", "0", ")", "fprintf", "(", "file", ",", "\",\"", "HOST_WIDE_INT_PRINT_DEC", ",", "offset", ")", ";", "fputc", "(", "')'", ",", "file", ")", ";", "}", "</s>" ]

[ "Print", "a", "memory", "address", "as", "an", "operand", "to", "reference", "that", "memory", "location", "." ]

[ "stormy16", "0xFFFF", "1", "1", "0", "0", "0", "\"--\"", "\"++\"", "0", "\",\"" ]

[]

[ "<s>", "void", "AArch64Operand", "::", "print", "(", "raw_ostream", "&", "OS", ")", "const", "{", "switch", "(", "Kind", ")", "{", "case", "k_FPImm", ":", "OS", "<<", "\"<fpimm \"", "<<", "getFPImm", "(", ")", "<<", "\"(\"", "<<", "AArch64_AM", "::", "getFPImmFloat", "(", "getFPImm", "(", ")", ")", "<<", "\") >\"", ";", "break", ";", "case", "k_Barrier", ":", "{", "bool", "Valid", ";", "StringRef", "Name", "=", "AArch64DB", "::", "DBarrierMapper", "(", ")", ".", "toString", "(", "getBarrier", "(", ")", ",", "Valid", ")", ";", "if", "(", "Valid", ")", "OS", "<<", "\"<barrier \"", "<<", "Name", "<<", "\">\"", ";", "else", "OS", "<<", "\"<barrier invalid #\"", "<<", "getBarrier", "(", ")", "<<", "\">\"", ";", "break", ";", "}", "case", "k_Immediate", ":", "getImm", "(", ")", "->", "print", "(", "OS", ")", ";", "break", ";", "case", "k_ShiftedImm", ":", "{", "unsigned", "Shift", "=", "getShiftedImmShift", "(", ")", ";", "OS", "<<", "\"<shiftedimm \"", ";", "getShiftedImmVal", "(", ")", "->", "print", "(", "OS", ")", ";", "OS", "<<", "\", lsl #\"", "<<", "AArch64_AM", "::", "getShiftValue", "(", "Shift", ")", "<<", "\">\"", ";", "break", ";", "}", "case", "k_CondCode", ":", "OS", "<<", "\"<condcode \"", "<<", "getCondCode", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "k_Register", ":", "OS", "<<", "\"<register \"", "<<", "getReg", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "k_VectorList", ":", "{", "OS", "<<", "\"<vectorlist \"", ";", "unsigned", "Reg", "=", "getVectorListStart", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "getVectorListCount", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "OS", "<<", "Reg", "+", "i", "<<", "\" \"", ";", "OS", "<<", "\">\"", ";", "break", ";", "}", "case", "k_VectorIndex", ":", "OS", "<<", "\"<vectorindex \"", "<<", "getVectorIndex", "(", ")", "<<", "\">\"", ";", "break", ";", "case", "k_SysReg", ":", "OS", "<<", "\"<sysreg: \"", "<<", "getSysReg", "(", ")", "<<", "'>'", ";", "break", ";", "case", "k_Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "case", "k_SysCR", ":", "OS", "<<", "\"c\"", "<<", "getSysCR", "(", ")", ";", "break", ";", "case", "k_Prefetch", ":", "{", "bool", "Valid", ";", "StringRef", "Name", "=", "AArch64PRFM", "::", "PRFMMapper", "(", ")", ".", "toString", "(", "getPrefetch", "(", ")", ",", "Valid", ")", ";", "if", "(", "Valid", ")", "OS", "<<", "\"<prfop \"", "<<", "Name", "<<", "\">\"", ";", "else", "OS", "<<", "\"<prfop invalid #\"", "<<", "getPrefetch", "(", ")", "<<", "\">\"", ";", "break", ";", "}", "case", "k_ShiftExtend", ":", "{", "OS", "<<", "\"<\"", "<<", "AArch64_AM", "::", "getShiftExtendName", "(", "getShiftExtendType", "(", ")", ")", "<<", "\" #\"", "<<", "getShiftExtendAmount", "(", ")", ";", "if", "(", "!", "hasShiftExtendAmount", "(", ")", ")", "OS", "<<", "\"<imp>\"", ";", "OS", "<<", "'>'", ";", "break", ";", "}", "}", "}", "</s>" ]

[ "print", "-", "Print", "a", "debug", "representation", "of", "the", "operand", "to", "the", "given", "stream", "." ]

[ "AArch64", "AArch64", "\"<fpimm \"", "\"(\"", "AArch64_AM::getFPImmFloat", "\") >\"", "AArch64DB::DBarrierMapper", "\"<barrier \"", "\">\"", "\"<barrier invalid #\"", "\">\"", "\"<shiftedimm \"", "\", lsl #\"", "AArch64_AM::getShiftValue", "\">\"", "\"<condcode \"", "\">\"", "\"<register \"", "\">\"", "\"<vectorlist \"", "0", "\" \"", "\">\"", "\"<vectorindex \"", "\">\"", "\"<sysreg: \"", "\"'\"", "\"'\"", "\"c\"", "AArch64PRFM::PRFMMapper", "\"<prfop \"", "\">\"", "\"<prfop invalid #\"", "\">\"", "\"<\"", "AArch64_AM::getShiftExtendName", "\" #\"", "\"<imp>\"" ]

[]

[ "<s>", "SDNode", "*", "NVPTXDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "return", "NULL", ";", "SDNode", "*", "ResNode", "=", "NULL", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "LOAD", ":", "ResNode", "=", "SelectLoad", "(", "N", ")", ";", "break", ";", "case", "ISD", "::", "STORE", ":", "ResNode", "=", "SelectStore", "(", "N", ")", ";", "break", ";", "case", "NVPTXISD", "::", "LoadV2", ":", "case", "NVPTXISD", "::", "LoadV4", ":", "ResNode", "=", "SelectLoadVector", "(", "N", ")", ";", "break", ";", "case", "NVPTXISD", "::", "LDGV2", ":", "case", "NVPTXISD", "::", "LDGV4", ":", "case", "NVPTXISD", "::", "LDUV2", ":", "case", "NVPTXISD", "::", "LDUV4", ":", "ResNode", "=", "SelectLDGLDUVector", "(", "N", ")", ";", "break", ";", "case", "NVPTXISD", "::", "StoreV2", ":", "case", "NVPTXISD", "::", "StoreV4", ":", "ResNode", "=", "SelectStoreVector", "(", "N", ")", ";", "break", ";", "default", ":", "break", ";", "}", "if", "(", "ResNode", ")", "return", "ResNode", ";", "return", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

[ "Main", "hook", "for", "targets", "to", "transform", "nodes", "into", "machine", "nodes", "." ]

[ "NVPTX", "NVPTX", "ISD::LOAD", "ISD::STORE", "NVPTXISD::LoadV2", "NVPTXISD::LoadV4", "NVPTXISD::LDGV2", "NVPTXISD::LDGV4", "NVPTXISD::LDUV2", "NVPTXISD::LDUV4", "NVPTXISD::StoreV2", "NVPTXISD::StoreV4" ]

[]