Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "InstructionCost", "GCNTTIImpl", "::", "getArithmeticReductionCost", "(", "unsigned", "Opcode", ",", "VectorType", "*", "Ty", ",", "bool", "IsPairwise", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "EVT", "OrigTy", "=", "TLI", "->", "getValueType", "(", "DL", ",", "Ty", ")", ";", "if", "(", "IsPairwise", "||", "!", "ST", "->", "hasVOP3PInsts", "(", ")", "||", "OrigTy", ".", "getScalarSizeInBits", "(", ")", "!=", "16", ")", "return", "BaseT", "::", "getArithmeticReductionCost", "(", "Opcode", ",", "Ty", ",", "IsPairwise", ",", "CostKind", ")", ";", "std", "::", "pair", "<", "InstructionCost", ",", "MVT", ">", "LT", "=", "TLI", "->", "getTypeLegalizationCost", "(", "DL", ",", "Ty", ")", ";", "return", "LT", ".", "first", "*", "getFullRateInstrCost", "(", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "vector", "reduction", "intrinsics", "." ]

[ "AMDGPU", "16" ]

[]

[ "<s>", "bool", "avr_has_nibble_0xf", "(", "rtx", "ival", ")", "{", "unsigned", "int", "map", "=", "UINTVAL", "(", "ival", ")", "&", "GET_MODE_MASK", "(", "SImode", ")", ";", "return", "0", "!=", "avr_map_metric", "(", "map", ",", "MAP_MASK_PREIMAGE_F", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "IVAL", "has", "a", "0xf", "in", "its", "hexadecimal", "representation", "and", "false", ",", "otherwise", ".", "Only", "nibbles", "0", "..", "7", "are", "taken", "into", "account", ".", "Used", "as", "constraint", "helper", "for", "C0f", "and", "Cxf", "." ]

[ "avr", "0" ]

[]

[ "<s>", "inline", "bool", "vgpr_vector_mode_p", "(", "machine_mode", "mode", ")", "{", "return", "VECTOR_MODE_P", "(", "mode", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "MODE", "can", "be", "handled", "directly", "by", "VGPR", "operations", "." ]

[ "gcn" ]

[]

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

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

[ "SystemZ", "SystemZ" ]

[]

[ "<s>", "bool", "writeNopData", "(", "uint64_t", "Count", ",", "MCObjectWriter", "*", "OW", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]

[ "Mips" ]

[]

[ "<s>", "void", "getAnalysisUsage", "(", "AnalysisUsage", "&", "AU", ")", "const", "override", "{", "AU", ".", "addRequired", "<", "AMDGPUArgumentUsageInfo", ">", "(", ")", ";", "AU", ".", "addRequired", "<", "DivergenceAnalysis", ">", "(", ")", ";", "SelectionDAGISel", "::", "getAnalysisUsage", "(", "AU", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU" ]

[]

[ "<s>", "static", "const", "char", "*", "expand_lib", "(", "char", "*", "name", ")", "{", "char", "*", "lib_path", ";", "if", "(", "strcmp", "(", "name", ",", "\"c\"", ")", "==", "0", ")", "return", "NULL", ";", "if", "(", "strcmp", "(", "name", ",", "\"m\"", ")", "==", "0", ")", "return", "NULL", ";", "lib_path", "=", "locate_lib", "(", "name", ")", ";", "if", "(", "lib_path", ")", "return", "lib_path", ";", "fprintf", "(", "stderr", ",", "\"Couldn't locate library: lib%s.exe, lib%s.a or lib%s.olb\\n\"", ",", "name", ",", "name", ",", "name", ")", ";", "exit", "(", "EXIT_FAILURE", ")", ";", "}", "</s>" ]

[ "Given", "a", "library", "name", "NAME", ",", "i.e", ".", "foo", ",", "Look", "for", "libfoo.lib", "and", "then", "libfoo.a", "in", "the", "set", "of", "directories", "we", "are", "allowed", "to", "search", "in", ".", "May", "return", "NULL", "if", "the", "library", "can", "be", "discarded", "." ]

[ "vms", "\"c\"", "0", "\"m\"", "0", "\"Couldn't locate library: lib%s.exe, lib%s.a or lib%s.olb\\n\"" ]

[]

[ "<s>", "bool", "func_fma_steering", "::", "put_node", "(", "fma_node", "*", "node", ")", "{", "return", "this", "->", "m_insn_fma_head_map", "->", "put", "(", "node", "->", "get_insn", "(", ")", ",", "node", ")", ";", "}", "</s>" ]

[ "Memorize", "the", "mapping", "of", "this", "instruction", "to", "its", "fma_node", "object", "and", "return", "whether", "such", "a", "mapping", "existed", "." ]

[ "aarch64" ]

[]

[ "<s>", "static", "const", "char", "*", "output_move_const_into_data_reg", "(", "rtx", "*", "operands", ")", "{", "HOST_WIDE_INT", "i", ";", "i", "=", "INTVAL", "(", "operands", "[", "1", "]", ")", ";", "switch", "(", "m68k_const_method", "(", "i", ")", ")", "{", "case", "MVZ", ":", "return", "\"mvzw %1,%0\"", ";", "case", "MVS", ":", "return", "\"mvsw %1,%0\"", ";", "case", "MOVQ", ":", "return", "\"moveq %1,%0\"", ";", "case", "NOTB", ":", "CC_STATUS_INIT", ";", "operands", "[", "1", "]", "=", "GEN_INT", "(", "i", "^", "0xff", ")", ";", "return", "\"moveq %1,%0\\n\\tnot%.b %0\"", ";", "case", "NOTW", ":", "CC_STATUS_INIT", ";", "operands", "[", "1", "]", "=", "GEN_INT", "(", "i", "^", "0xffff", ")", ";", "return", "\"moveq %1,%0\\n\\tnot%.w %0\"", ";", "case", "NEGW", ":", "CC_STATUS_INIT", ";", "return", "\"moveq #-128,%0\\n\\tneg%.w %0\"", ";", "case", "SWAP", ":", "{", "unsigned", "u", "=", "i", ";", "operands", "[", "1", "]", "=", "GEN_INT", "(", "(", "u", "<<", "16", ")", "|", "(", "u", ">>", "16", ")", ")", ";", "return", "\"moveq %1,%0\\n\\tswap %0\"", ";", "}", "case", "MOVL", ":", "return", "\"move%.l %1,%0\"", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Return", "an", "instruction", "to", "move", "CONST_INT", "OPERANDS", "[", "1", "]", "into", "data", "register", "OPERANDS", "[", "0", "]", "." ]

[ "m68k", "1", "\"mvzw %1,%0\"", "\"mvsw %1,%0\"", "\"moveq %1,%0\"", "1", "0xff", "\"moveq %1,%0\\n\\tnot%.b %0\"", "1", "0xffff", "\"moveq %1,%0\\n\\tnot%.w %0\"", "\"moveq #-128,%0\\n\\tneg%.w %0\"", "1", "16", "16", "\"moveq %1,%0\\n\\tswap %0\"", "\"move%.l %1,%0\"" ]

[]

[ "<s>", "SDValue", "XCoreTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "case", "ISD", "::", "EH_RETURN", ":", "return", "LowerEH_RETURN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "GlobalAddress", ":", "return", "LowerGlobalAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BlockAddress", ":", "return", "LowerBlockAddress", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ConstantPool", ":", "return", "LowerConstantPool", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "BR_JT", ":", "return", "LowerBR_JT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "LOAD", ":", "return", "LowerLOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "STORE", ":", "return", "LowerSTORE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VAARG", ":", "return", "LowerVAARG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "VASTART", ":", "return", "LowerVASTART", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SMUL_LOHI", ":", "return", "LowerSMUL_LOHI", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UMUL_LOHI", ":", "return", "LowerUMUL_LOHI", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "SUB", ":", "return", "ExpandADDSUB", "(", "Op", ".", "getNode", "(", ")", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAMEADDR", ":", "return", "LowerFRAMEADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "RETURNADDR", ":", "return", "LowerRETURNADDR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRAME_TO_ARGS_OFFSET", ":", "return", "LowerFRAME_TO_ARGS_OFFSET", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INIT_TRAMPOLINE", ":", "return", "LowerINIT_TRAMPOLINE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ADJUST_TRAMPOLINE", ":", "return", "LowerADJUST_TRAMPOLINE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "INTRINSIC_WO_CHAIN", ":", "return", "LowerINTRINSIC_WO_CHAIN", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_FENCE", ":", "return", "LowerATOMIC_FENCE", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_LOAD", ":", "return", "LowerATOMIC_LOAD", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "ATOMIC_STORE", ":", "return", "LowerATOMIC_STORE", "(", "Op", ",", "DAG", ")", ";", "default", ":", "llvm_unreachable", "(", "\"unimplemented operand\"", ")", ";", "}", "}", "</s>" ]

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

[ "XCore", "XCore", "ISD::EH_RETURN", "ISD::GlobalAddress", "ISD::BlockAddress", "ISD::ConstantPool", "ISD::BR_JT", "ISD::LOAD", "ISD::STORE", "ISD::VAARG", "ISD::VASTART", "ISD::SMUL_LOHI", "ISD::UMUL_LOHI", "ISD::ADD", "ISD::SUB", "ISD::FRAMEADDR", "ISD::RETURNADDR", "ISD::FRAME_TO_ARGS_OFFSET", "ISD::INIT_TRAMPOLINE", "ISD::ADJUST_TRAMPOLINE", "ISD::INTRINSIC_WO_CHAIN", "ISD::ATOMIC_FENCE", "ISD::ATOMIC_LOAD", "ISD::ATOMIC_STORE", "\"unimplemented operand\"" ]

[]

[ "<s>", "void", "avr_adjust_reg_alloc_order", "(", "void", ")", "{", "unsigned", "int", "i", ";", "static", "const", "int", "order_0", "[", "]", "=", "{", "24", ",", "25", ",", "18", ",", "19", ",", "20", ",", "21", ",", "22", ",", "23", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "17", ",", "16", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "0", ",", "1", ",", "32", ",", "33", ",", "34", ",", "35", "}", ";", "static", "const", "int", "tiny_order_0", "[", "]", "=", "{", "20", ",", "21", ",", "22", ",", "23", ",", "24", ",", "25", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "19", ",", "18", ",", "16", ",", "17", ",", "32", ",", "33", ",", "34", ",", "35", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "1", ",", "0", "}", ";", "static", "const", "int", "order_1", "[", "]", "=", "{", "18", ",", "19", ",", "20", ",", "21", ",", "22", ",", "23", ",", "24", ",", "25", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "17", ",", "16", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "0", ",", "1", ",", "32", ",", "33", ",", "34", ",", "35", "}", ";", "static", "const", "int", "tiny_order_1", "[", "]", "=", "{", "22", ",", "23", ",", "24", ",", "25", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "21", ",", "20", ",", "19", ",", "18", ",", "16", ",", "17", ",", "32", ",", "33", ",", "34", ",", "35", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "1", ",", "0", "}", ";", "static", "const", "int", "order_2", "[", "]", "=", "{", "25", ",", "24", ",", "23", ",", "22", ",", "21", ",", "20", ",", "19", ",", "18", ",", "30", ",", "31", ",", "26", ",", "27", ",", "28", ",", "29", ",", "17", ",", "16", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "1", ",", "0", ",", "32", ",", "33", ",", "34", ",", "35", "}", ";", "const", "int", "*", "order", "=", "(", "TARGET_ORDER_1", "?", "(", "AVR_TINY", "?", "tiny_order_1", ":", "order_1", ")", ":", "TARGET_ORDER_2", "?", "(", "AVR_TINY", "?", "tiny_order_0", ":", "order_2", ")", ":", "(", "AVR_TINY", "?", "tiny_order_0", ":", "order_0", ")", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "order_0", ")", ";", "++", "i", ")", "reg_alloc_order", "[", "i", "]", "=", "order", "[", "i", "]", ";", "}", "</s>" ]

[ "Choose", "the", "order", "in", "which", "to", "allocate", "hard", "registers", "for", "pseudo-registers", "local", "to", "a", "basic", "block", ".", "Store", "the", "desired", "register", "order", "in", "the", "array", "`", "reg_alloc_order", "'", ".", "Element", "0", "should", "be", "the", "register", "to", "allocate", "first", ";", "element", "1", ",", "the", "next", "register", ";", "and", "so", "on", "." ]

[ "avr", "24", "25", "18", "19", "20", "21", "22", "23", "30", "31", "26", "27", "28", "29", "17", "16", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "0", "1", "32", "33", "34", "35", "20", "21", "22", "23", "24", "25", "30", "31", "26", "27", "28", "29", "19", "18", "16", "17", "32", "33", "34", "35", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "1", "0", "18", "19", "20", "21", "22", "23", "24", "25", "30", "31", "26", "27", "28", "29", "17", "16", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "0", "1", "32", "33", "34", "35", "22", "23", "24", "25", "30", "31", "26", "27", "28", "29", "21", "20", "19", "18", "16", "17", "32", "33", "34", "35", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "1", "0", "25", "24", "23", "22", "21", "20", "19", "18", "30", "31", "26", "27", "28", "29", "17", "16", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "1", "0", "32", "33", "34", "35", "0" ]

[]

[ "<s>", "MachineInstr", "*", "AlphaInstrInfo", "::", "foldMemoryOperandImpl", "(", "MachineFunction", "&", "MF", ",", "MachineInstr", "*", "MI", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "Ops", ",", "int", "FrameIndex", ")", "const", "{", "if", "(", "Ops", ".", "size", "(", ")", "!=", "1", ")", "return", "NULL", ";", "unsigned", "Opc", "=", "MI", "->", "getOpcode", "(", ")", ";", "MachineInstr", "*", "NewMI", "=", "NULL", ";", "switch", "(", "Opc", ")", "{", "default", ":", "break", ";", "case", "Alpha", "::", "BISr", ":", "case", "Alpha", "::", "CPYSS", ":", "case", "Alpha", "::", "CPYST", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "==", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ")", "{", "if", "(", "Ops", "[", "0", "]", "==", "0", ")", "{", "unsigned", "InReg", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "bool", "isKill", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "isKill", "(", ")", ";", "bool", "isUndef", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "isUndef", "(", ")", ";", "Opc", "=", "(", "Opc", "==", "Alpha", "::", "BISr", ")", "?", "Alpha", "::", "STQ", ":", "(", "(", "Opc", "==", "Alpha", "::", "CPYSS", ")", "?", "Alpha", "::", "STS", ":", "Alpha", "::", "STT", ")", ";", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "InReg", ",", "getKillRegState", "(", "isKill", ")", "|", "getUndefRegState", "(", "isUndef", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "Alpha", "::", "F31", ")", ";", "}", "else", "{", "unsigned", "OutReg", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "bool", "isDead", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "isDead", "(", ")", ";", "bool", "isUndef", "=", "MI", "->", "getOperand", "(", "0", ")", ".", "isUndef", "(", ")", ";", "Opc", "=", "(", "Opc", "==", "Alpha", "::", "BISr", ")", "?", "Alpha", "::", "LDQ", ":", "(", "(", "Opc", "==", "Alpha", "::", "CPYSS", ")", "?", "Alpha", "::", "LDS", ":", "Alpha", "::", "LDT", ")", ";", "NewMI", "=", "BuildMI", "(", "MF", ",", "MI", "->", "getDebugLoc", "(", ")", ",", "get", "(", "Opc", ")", ")", ".", "addReg", "(", "OutReg", ",", "RegState", "::", "Define", "|", "getDeadRegState", "(", "isDead", ")", "|", "getUndefRegState", "(", "isUndef", ")", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addReg", "(", "Alpha", "::", "F31", ")", ";", "}", "}", "break", ";", "}", "return", "NewMI", ";", "}", "</s>" ]

[ "foldMemoryOperand", "-", "Same", "as", "the", "previous", "version", "except", "it", "allows", "folding", "of", "any", "load", "and", "store", "from", "/", "to", "any", "address", ",", "not", "just", "from", "a", "specific", "stack", "slot", "." ]

[ "Alpha", "Alpha", "1", "Alpha::BISr", "Alpha::CPYSS", "Alpha::CPYST", "1", "2", "0", "0", "1", "1", "1", "Alpha::BISr", "Alpha::STQ", "Alpha::CPYSS", "Alpha::STS", "Alpha::STT", "Alpha::F31", "0", "0", "0", "Alpha::BISr", "Alpha::LDQ", "Alpha::CPYSS", "Alpha::LDS", "Alpha::LDT", "Alpha::F31" ]

[]

[ "<s>", "static", "void", "output_stack_adjust", "(", "int", "direction", ",", "int", "size", ")", "{", "if", "(", "direction", "<", "0", "&&", "size", ">", "mcore_stack_increment", "&&", "mcore_stack_increment", ">", "0", ")", "{", "rtx", "tmp", "=", "gen_rtx_REG", "(", "SImode", ",", "1", ")", ";", "rtx", "memref", ";", "emit_insn", "(", "gen_movsi", "(", "tmp", ",", "GEN_INT", "(", "mcore_stack_increment", ")", ")", ")", ";", "do", "{", "emit_insn", "(", "gen_subsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "tmp", ")", ")", ";", "memref", "=", "gen_rtx_MEM", "(", "SImode", ",", "stack_pointer_rtx", ")", ";", "MEM_VOLATILE_P", "(", "memref", ")", "=", "1", ";", "emit_insn", "(", "gen_movsi", "(", "memref", ",", "stack_pointer_rtx", ")", ")", ";", "size", "-=", "mcore_stack_increment", ";", "}", "while", "(", "size", ">", "mcore_stack_increment", ")", ";", "}", "if", "(", "size", ")", "{", "rtx", "insn", ";", "rtx", "val", "=", "GEN_INT", "(", "size", ")", ";", "if", "(", "size", ">", "32", ")", "{", "rtx", "nval", "=", "gen_rtx_REG", "(", "SImode", ",", "1", ")", ";", "emit_insn", "(", "gen_movsi", "(", "nval", ",", "val", ")", ")", ";", "val", "=", "nval", ";", "}", "if", "(", "direction", ">", "0", ")", "insn", "=", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "val", ")", ";", "else", "insn", "=", "gen_subsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "val", ")", ";", "emit_insn", "(", "insn", ")", ";", "}", "}", "</s>" ]

[ "Adjust", "the", "stack", "and", "return", "the", "number", "of", "bytes", "taken", "to", "do", "it" ]

[ "mcore", "0", "0", "1", "1", "32", "1", "0" ]

[]

[ "<s>", "virtual", "const", "PTXRegisterInfo", "&", "getRegisterInfo", "(", ")", "const", "{", "return", "RI", ";", "}", "</s>" ]

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

[ "PTX", "PTX" ]

[]

[ "<s>", "int", "SIFrameLowering", "::", "getFrameIndexReference", "(", "const", "MachineFunction", "&", "MF", ",", "int", "FI", ",", "Register", "&", "FrameReg", ")", "const", "{", "const", "SIRegisterInfo", "*", "RI", "=", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "FrameReg", "=", "RI", "->", "getFrameRegister", "(", "MF", ")", ";", "return", "MF", ".", "getFrameInfo", "(", ")", ".", "getObjectOffset", "(", "FI", ")", ";", "}", "</s>" ]

[ "getFrameIndexReference", "-", "This", "method", "should", "return", "the", "base", "register", "and", "offset", "used", "to", "reference", "a", "frame", "index", "location", "." ]

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

[]

[ "<s>", "bool", "isImm", "(", ")", "const", "{", "return", "Kind", "==", "k_Immediate", ";", "}", "</s>" ]

[ "isImm", "-", "Is", "this", "an", "immediate", "operand", "?" ]

[ "ARM" ]

[]

[ "<s>", "static", "unsigned", "int", "riscv_function_arg_boundary", "(", "enum", "machine_mode", "mode", ",", "const_tree", "type", ")", "{", "unsigned", "int", "alignment", ";", "if", "(", "type", "&&", "!", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "alignment", "=", "TYPE_ALIGN", "(", "TYPE_MAIN_VARIANT", "(", "type", ")", ")", ";", "else", "alignment", "=", "type", "?", "TYPE_ALIGN", "(", "type", ")", ":", "GET_MODE_ALIGNMENT", "(", "mode", ")", ";", "return", "MIN", "(", "STACK_BOUNDARY", ",", "MAX", "(", "PARM_BOUNDARY", ",", "alignment", ")", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG_BOUNDARY", ".", "Every", "parameter", "gets", "at", "least", "PARM_BOUNDARY", "bits", "of", "alignment", ",", "but", "will", "be", "given", "anything", "up", "to", "STACK_BOUNDARY", "bits", "if", "the", "type", "requires", "it", "." ]

[ "riscv" ]

[]

[ "<s>", "enum", "reg_class", "s390_secondary_input_reload_class", "(", "enum", "reg_class", "class", ",", "enum", "machine_mode", "mode", ",", "rtx", "in", ")", "{", "if", "(", "s390_plus_operand", "(", "in", ",", "mode", ")", ")", "return", "ADDR_REGS", ";", "if", "(", "reg_classes_intersect_p", "(", "FP_REGS", ",", "class", ")", "&&", "mode", "==", "TFmode", "&&", "GET_CODE", "(", "in", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "in", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "in", ",", "0", ")", ",", "1", ")", ")", "==", "CONST_INT", "&&", "!", "DISP_IN_RANGE", "(", "INTVAL", "(", "XEXP", "(", "XEXP", "(", "in", ",", "0", ")", ",", "1", ")", ")", "+", "GET_MODE_SIZE", "(", "mode", ")", "-", "1", ")", ")", "return", "ADDR_REGS", ";", "if", "(", "reg_classes_intersect_p", "(", "CC_REGS", ",", "class", ")", ")", "return", "GENERAL_REGS", ";", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Return", "the", "register", "class", "of", "a", "scratch", "register", "needed", "to", "load", "IN", "into", "a", "register", "of", "class", "CLASS", "in", "MODE", ".", "We", "need", "a", "temporary", "when", "loading", "a", "PLUS", "expression", "which", "is", "not", "a", "legitimate", "operand", "of", "the", "LOAD", "ADDRESS", "instruction", "." ]

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

[]

[ "<s>", "bool", "AArch64TargetLowering", "::", "SimplifyDemandedBitsForTargetNode", "(", "SDValue", "Op", ",", "const", "APInt", "&", "OriginalDemandedBits", ",", "const", "APInt", "&", "OriginalDemandedElts", ",", "KnownBits", "&", "Known", ",", "TargetLoweringOpt", "&", "TLO", ",", "unsigned", "Depth", ")", "const", "{", "unsigned", "Opc", "=", "Op", ".", "getOpcode", "(", ")", ";", "switch", "(", "Opc", ")", "{", "case", "AArch64ISD", "::", "VSHL", ":", "{", "SDValue", "ShiftL", "=", "Op", ";", "SDValue", "ShiftR", "=", "Op", "->", "getOperand", "(", "0", ")", ";", "if", "(", "ShiftR", "->", "getOpcode", "(", ")", "!=", "AArch64ISD", "::", "VLSHR", ")", "return", "false", ";", "if", "(", "!", "ShiftL", ".", "hasOneUse", "(", ")", "||", "!", "ShiftR", ".", "hasOneUse", "(", ")", ")", "return", "false", ";", "unsigned", "ShiftLBits", "=", "ShiftL", "->", "getConstantOperandVal", "(", "1", ")", ";", "unsigned", "ShiftRBits", "=", "ShiftR", "->", "getConstantOperandVal", "(", "1", ")", ";", "if", "(", "ShiftRBits", "!=", "ShiftLBits", ")", "return", "false", ";", "unsigned", "ScalarSize", "=", "Op", ".", "getScalarValueSizeInBits", "(", ")", ";", "assert", "(", "ScalarSize", ">", "ShiftLBits", "&&", "\"Invalid shift imm\"", ")", ";", "APInt", "ZeroBits", "=", "APInt", "::", "getLowBitsSet", "(", "ScalarSize", ",", "ShiftLBits", ")", ";", "APInt", "UnusedBits", "=", "~", "OriginalDemandedBits", ";", "if", "(", "(", "ZeroBits", "&", "UnusedBits", ")", "!=", "ZeroBits", ")", "return", "false", ";", "return", "TLO", ".", "CombineTo", "(", "Op", ",", "ShiftR", "->", "getOperand", "(", "0", ")", ")", ";", "}", "}", "return", "TargetLowering", "::", "SimplifyDemandedBitsForTargetNode", "(", "Op", ",", "OriginalDemandedBits", ",", "OriginalDemandedElts", ",", "Known", ",", "TLO", ",", "Depth", ")", ";", "}", "</s>" ]

[ "Attempt", "to", "simplify", "any", "target", "nodes", "based", "on", "the", "demanded", "bits/elts", ",", "returning", "true", "on", "success", "." ]

[ "AArch64", "AArch64", "AArch64ISD::VSHL", "0", "AArch64ISD::VLSHR", "1", "1", "\"Invalid shift imm\"", "0" ]

[]

[ "<s>", "bool", "SILoadStoreOptimizer", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "STM", "=", "&", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "if", "(", "!", "STM", "->", "loadStoreOptEnabled", "(", ")", ")", "return", "false", ";", "TII", "=", "STM", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "STI", "=", "&", "MF", ".", "getSubtarget", "<", "MCSubtargetInfo", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "assert", "(", "MRI", "->", "isSSA", "(", ")", "&&", "\"Must be run on SSA\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Running SILoadStoreOptimizer\\n\"", ")", ";", "bool", "Modified", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "{", "std", "::", "list", "<", "std", "::", "list", "<", "CombineInfo", ">", ">", "MergeableInsts", ";", "Modified", "|=", "collectMergeableInsts", "(", "MBB", ",", "MergeableInsts", ")", ";", "do", "{", "OptimizeAgain", "=", "false", ";", "Modified", "|=", "optimizeBlock", "(", "MergeableInsts", ")", ";", "}", "while", "(", "OptimizeAgain", ")", ";", "}", "return", "Modified", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "\"Must be run on SSA\"", "\"Running SILoadStoreOptimizer\\n\"" ]

[]

[ "<s>", "unsigned", "HexagonInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "Hexagon", "::", "LDriw", ":", "case", "Hexagon", "::", "LDrid", ":", "case", "Hexagon", "::", "LDrih", ":", "case", "Hexagon", "::", "LDrib", ":", "case", "Hexagon", "::", "LDriub", ":", "if", "(", "MI", "->", "getOperand", "(", "2", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", "&&", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", "==", "0", ")", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "2", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::LDriw", "Hexagon::LDrid", "Hexagon::LDrih", "Hexagon::LDrib", "Hexagon::LDriub", "2", "1", "1", "0", "2", "0", "0" ]

[]

[ "<s>", "void", "R600SchedStrategy", "::", "initialize", "(", "ScheduleDAGMI", "*", "dag", ")", "{", "assert", "(", "dag", "->", "hasVRegLiveness", "(", ")", "&&", "\"R600SchedStrategy needs vreg liveness\"", ")", ";", "DAG", "=", "static_cast", "<", "ScheduleDAGMILive", "*", ">", "(", "dag", ")", ";", "TII", "=", "static_cast", "<", "const", "R600InstrInfo", "*", ">", "(", "DAG", "->", "TII", ")", ";", "TRI", "=", "static_cast", "<", "const", "R600RegisterInfo", "*", ">", "(", "DAG", "->", "TRI", ")", ";", "VLIW5", "=", "!", "DAG", "->", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ".", "hasCaymanISA", "(", ")", ";", "MRI", "=", "&", "DAG", "->", "MRI", ";", "CurInstKind", "=", "IDOther", ";", "CurEmitted", "=", "0", ";", "OccupedSlotsMask", "=", "31", ";", "InstKindLimit", "[", "IDAlu", "]", "=", "TII", "->", "getMaxAlusPerClause", "(", ")", ";", "InstKindLimit", "[", "IDOther", "]", "=", "32", ";", "const", "AMDGPUSubtarget", "&", "ST", "=", "DAG", "->", "TM", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "InstKindLimit", "[", "IDFetch", "]", "=", "ST", ".", "getTexVTXClauseSize", "(", ")", ";", "AluInstCount", "=", "0", ";", "FetchInstCount", "=", "0", ";", "}", "</s>" ]

[ "Initialize", "the", "strategy", "after", "building", "the", "DAG", "for", "a", "new", "region", "." ]

[ "R600", "\"R600SchedStrategy needs vreg liveness\"", "0", "31", "32", "0", "0" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "isTypeDesirableForOp", "(", "unsigned", "Opc", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "isTypeLegal", "(", "VT", ")", ")", "return", "false", ";", "if", "(", "VT", "!=", "MVT", "::", "i16", ")", "return", "true", ";", "switch", "(", "Opc", ")", "{", "default", ":", "return", "true", ";", "case", "ISD", "::", "LOAD", ":", "case", "ISD", "::", "SIGN_EXTEND", ":", "case", "ISD", "::", "ZERO_EXTEND", ":", "case", "ISD", "::", "ANY_EXTEND", ":", "case", "ISD", "::", "SHL", ":", "case", "ISD", "::", "SRL", ":", "case", "ISD", "::", "SUB", ":", "case", "ISD", "::", "ADD", ":", "case", "ISD", "::", "MUL", ":", "case", "ISD", "::", "AND", ":", "case", "ISD", "::", "OR", ":", "case", "ISD", "::", "XOR", ":", "return", "false", ";", "}", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "has", "native", "support", "for", "the", "specified", "value", "type", "and", "it", "is", "'desirable", "'", "to", "use", "the", "type", "for", "the", "given", "node", "type", "." ]

[ "X86", "X86", "MVT::i16", "ISD::LOAD", "ISD::SIGN_EXTEND", "ISD::ZERO_EXTEND", "ISD::ANY_EXTEND", "ISD::SHL", "ISD::SRL", "ISD::SUB", "ISD::ADD", "ISD::MUL", "ISD::AND", "ISD::OR", "ISD::XOR" ]

[]

[ "<s>", "bool", "isReg", "(", ")", "const", "override", "{", "return", "Kind", "==", "Register", ";", "}", "</s>" ]

[ "isReg", "-", "Is", "this", "a", "register", "operand", "?" ]

[ "Teak" ]

[]

[ "<s>", "rtx", "ix86_fixup_binary_operands", "(", "enum", "rtx_code", "code", ",", "machine_mode", "mode", ",", "rtx", "operands", "[", "]", ")", "{", "rtx", "dst", "=", "operands", "[", "0", "]", ";", "rtx", "src1", "=", "operands", "[", "1", "]", ";", "rtx", "src2", "=", "operands", "[", "2", "]", ";", "if", "(", "ix86_swap_binary_operands_p", "(", "code", ",", "mode", ",", "operands", ")", ")", "{", "gcc_assert", "(", "GET_MODE", "(", "src1", ")", "==", "GET_MODE", "(", "src2", ")", ")", ";", "std", "::", "swap", "(", "src1", ",", "src2", ")", ";", "}", "if", "(", "MEM_P", "(", "src1", ")", "&&", "MEM_P", "(", "src2", ")", ")", "{", "if", "(", "rtx_equal_p", "(", "src1", ",", "src2", ")", ")", "{", "src2", "=", "force_reg", "(", "mode", ",", "src2", ")", ";", "src1", "=", "src2", ";", "}", "else", "if", "(", "rtx_equal_p", "(", "dst", ",", "src1", ")", ")", "src2", "=", "force_reg", "(", "mode", ",", "src2", ")", ";", "else", "src1", "=", "force_reg", "(", "mode", ",", "src1", ")", ";", "}", "if", "(", "MEM_P", "(", "dst", ")", "&&", "!", "rtx_equal_p", "(", "dst", ",", "src1", ")", ")", "dst", "=", "gen_reg_rtx", "(", "mode", ")", ";", "if", "(", "CONSTANT_P", "(", "src1", ")", ")", "src1", "=", "force_reg", "(", "mode", ",", "src1", ")", ";", "if", "(", "MEM_P", "(", "src1", ")", "&&", "!", "rtx_equal_p", "(", "dst", ",", "src1", ")", ")", "src1", "=", "force_reg", "(", "mode", ",", "src1", ")", ";", "if", "(", "code", "==", "PLUS", "&&", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_INT", "&&", "MEM_P", "(", "src2", ")", ")", "src2", "=", "force_reg", "(", "mode", ",", "src2", ")", ";", "operands", "[", "1", "]", "=", "src1", ";", "operands", "[", "2", "]", "=", "src2", ";", "return", "dst", ";", "}", "</s>" ]

[ "Fix", "up", "OPERANDS", "to", "satisfy", "ix86_binary_operator_ok", ".", "Return", "the", "destination", "to", "use", "for", "the", "operation", ".", "If", "different", "from", "the", "true", "destination", "in", "operands", "[", "0", "]", ",", "a", "copy", "operation", "will", "be", "required", "." ]

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

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "SelectAddressRegRegOnly", "(", "SDValue", "N", ",", "SDValue", "&", "Base", ",", "SDValue", "&", "Index", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "SelectAddressRegReg", "(", "N", ",", "Base", ",", "Index", ",", "DAG", ")", ")", "return", "true", ";", "if", "(", "N", ".", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", ")", "{", "Base", "=", "N", ".", "getOperand", "(", "0", ")", ";", "Index", "=", "N", ".", "getOperand", "(", "1", ")", ";", "return", "true", ";", "}", "Base", "=", "DAG", ".", "getRegister", "(", "PPC", "::", "R0", ",", "N", ".", "getValueType", "(", ")", ")", ";", "Index", "=", "N", ";", "return", "true", ";", "}", "</s>" ]

[ "SelectAddressRegRegOnly", "-", "Given", "the", "specified", "addressed", ",", "force", "it", "to", "be", "represented", "as", "an", "indexed", "[", "r+r", "]", "operation", "." ]

[ "PowerPC", "PPC", "ISD::ADD", "0", "1", "PPC::R0" ]

[]

[ "<s>", "EVT", "PPCTargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsMemset", ",", "bool", "ZeroMemset", ",", "bool", "MemcpyStrSrc", ",", "MachineFunction", "&", "MF", ")", "const", "{", "if", "(", "this", "->", "PPCSubTarget", ".", "isPPC64", "(", ")", ")", "{", "return", "MVT", "::", "i64", ";", "}", "else", "{", "return", "MVT", "::", "i32", ";", "}", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "virtual", "bool", "isProfitableToIfCvt", "(", "MachineBasicBlock", "&", "TMBB", ",", "unsigned", "NumTCycles", ",", "unsigned", "ExtraTCycles", ",", "MachineBasicBlock", "&", "FMBB", ",", "unsigned", "NumFCycles", ",", "unsigned", "ExtraFCycles", ",", "const", "BranchProbability", "&", "Probability", ")", "const", "{", "const", "MCInstrDesc", "&", "TMCID", "=", "prior", "(", "TMBB", ".", "end", "(", ")", ")", "->", "getDesc", "(", ")", ";", "if", "(", "TMCID", ".", "isReturn", "(", ")", "||", "TMCID", ".", "isCall", "(", ")", ")", "return", "false", ";", "const", "MCInstrDesc", "&", "FMCID", "=", "prior", "(", "FMBB", ".", "end", "(", ")", ")", "->", "getDesc", "(", ")", ";", "if", "(", "FMCID", ".", "isReturn", "(", ")", "||", "FMCID", ".", "isCall", "(", ")", ")", "return", "false", ";", "if", "(", "(", "NumTCycles", "+", "NumFCycles", ")", ">", "16", ")", "return", "false", ";", "return", "!", "mayStall", "(", "TMBB", ")", "&&", "!", "mayStall", "(", "FMBB", ")", ";", "}", "</s>" ]

[ "Second", "variant", "of", "isProfitableToIfCvt", "." ]

[ "Patmos", "16" ]

[]

[ "<s>", "unsigned", "int", "darwin_rs6000_special_round_type_align", "(", "tree", "type", ",", "unsigned", "int", "computed", ",", "unsigned", "int", "specified", ")", "{", "unsigned", "int", "align", "=", "MAX", "(", "computed", ",", "specified", ")", ";", "if", "(", "TYPE_PACKED", "(", "type", ")", ")", "return", "align", ";", "do", "{", "tree", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "while", "(", "field", "!=", "NULL", "&&", "TREE_CODE", "(", "field", ")", "!=", "FIELD_DECL", ")", "field", "=", "DECL_CHAIN", "(", "field", ")", ";", "if", "(", "!", "field", ")", "break", ";", "if", "(", "DECL_PACKED", "(", "field", ")", ")", "return", "align", ";", "type", "=", "TREE_TYPE", "(", "field", ")", ";", "while", "(", "TREE_CODE", "(", "type", ")", "==", "ARRAY_TYPE", ")", "type", "=", "TREE_TYPE", "(", "type", ")", ";", "}", "while", "(", "AGGREGATE_TYPE_P", "(", "type", ")", ")", ";", "if", "(", "!", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "type", "!=", "error_mark_node", ")", "align", "=", "MAX", "(", "align", ",", "TYPE_ALIGN", "(", "type", ")", ")", ";", "return", "align", ";", "}", "</s>" ]

[ "Darwin", "increases", "record", "alignment", "to", "the", "natural", "alignment", "of", "the", "first", "field", "." ]

[ "rs6000" ]

[]

[ "<s>", "GCNSubtarget", "&", "GCNSubtarget", "::", "initializeSubtargetDependencies", "(", "const", "Triple", "&", "TT", ",", "StringRef", "GPU", ",", "StringRef", "FS", ")", "{", "SmallString", "<", "256", ">", "FullFS", "(", "\"+promote-alloca,+load-store-opt,+enable-ds128,\"", ")", ";", "if", "(", "isAmdHsaOS", "(", ")", ")", "FullFS", "+=", "\"+flat-for-global,+unaligned-access-mode,+trap-handler,\"", ";", "FullFS", "+=", "\"+enable-prt-strict-null,\"", ";", "if", "(", "FS", ".", "find_insensitive", "(", "\"+wavefrontsize\"", ")", "!=", "StringRef", "::", "npos", ")", "{", "if", "(", "FS", ".", "find_insensitive", "(", "\"wavefrontsize16\"", ")", "==", "StringRef", "::", "npos", ")", "FullFS", "+=", "\"-wavefrontsize16,\"", ";", "if", "(", "FS", ".", "find_insensitive", "(", "\"wavefrontsize32\"", ")", "==", "StringRef", "::", "npos", ")", "FullFS", "+=", "\"-wavefrontsize32,\"", ";", "if", "(", "FS", ".", "find_insensitive", "(", "\"wavefrontsize64\"", ")", "==", "StringRef", "::", "npos", ")", "FullFS", "+=", "\"-wavefrontsize64,\"", ";", "}", "FullFS", "+=", "FS", ";", "ParseSubtargetFeatures", "(", "GPU", ",", "GPU", ",", "FullFS", ")", ";", "if", "(", "Gen", "==", "AMDGPUSubtarget", "::", "INVALID", ")", "{", "Gen", "=", "TT", ".", "getOS", "(", ")", "==", "Triple", "::", "AMDHSA", "?", "AMDGPUSubtarget", "::", "SEA_ISLANDS", ":", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ";", "}", "assert", "(", "!", "hasFP64", "(", ")", "||", "(", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "SOUTHERN_ISLANDS", ")", ")", ";", "assert", "(", "hasAddr64", "(", ")", "||", "hasFlat", "(", ")", ")", ";", "if", "(", "!", "hasAddr64", "(", ")", "&&", "!", "FS", ".", "contains", "(", "\"flat-for-global\"", ")", "&&", "!", "FlatForGlobal", ")", "{", "ToggleFeature", "(", "AMDGPU", "::", "FeatureFlatForGlobal", ")", ";", "FlatForGlobal", "=", "true", ";", "}", "if", "(", "!", "hasFlat", "(", ")", "&&", "!", "FS", ".", "contains", "(", "\"flat-for-global\"", ")", "&&", "FlatForGlobal", ")", "{", "ToggleFeature", "(", "AMDGPU", "::", "FeatureFlatForGlobal", ")", ";", "FlatForGlobal", "=", "false", ";", "}", "if", "(", "MaxPrivateElementSize", "==", "0", ")", "MaxPrivateElementSize", "=", "4", ";", "if", "(", "LDSBankCount", "==", "0", ")", "LDSBankCount", "=", "32", ";", "if", "(", "TT", ".", "getArch", "(", ")", "==", "Triple", "::", "amdgcn", ")", "{", "if", "(", "LocalMemorySize", "==", "0", ")", "LocalMemorySize", "=", "32768", ";", "if", "(", "!", "HasMovrel", "&&", "!", "HasVGPRIndexMode", ")", "HasMovrel", "=", "true", ";", "}", "if", "(", "WavefrontSizeLog2", "==", "0", ")", "WavefrontSizeLog2", "=", "5", ";", "HasFminFmaxLegacy", "=", "getGeneration", "(", ")", "<", "AMDGPUSubtarget", "::", "VOLCANIC_ISLANDS", ";", "HasSMulHi", "=", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "GFX9", ";", "TargetID", ".", "setTargetIDFromFeaturesString", "(", "FS", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"xnack setting for subtarget: \"", "<<", "TargetID", ".", "getXnackSetting", "(", ")", "<<", "'\\n'", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"sramecc setting for subtarget: \"", "<<", "TargetID", ".", "getSramEccSetting", "(", ")", "<<", "'\\n'", ")", ";", "return", "*", "this", ";", "}", "</s>" ]

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

[ "AMDGPU", "256", "\"+promote-alloca,+load-store-opt,+enable-ds128,\"", "\"+flat-for-global,+unaligned-access-mode,+trap-handler,\"", "\"+enable-prt-strict-null,\"", "\"+wavefrontsize\"", "\"wavefrontsize16\"", "\"-wavefrontsize16,\"", "\"wavefrontsize32\"", "\"-wavefrontsize32,\"", "\"wavefrontsize64\"", "\"-wavefrontsize64,\"", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU", "\"flat-for-global\"", "AMDGPU::FeatureFlatForGlobal", "\"flat-for-global\"", "AMDGPU::FeatureFlatForGlobal", "0", "4", "0", "32", "0", "32768", "0", "5", "AMDGPU", "AMDGPU", "\"xnack setting for subtarget: \"", "\"sramecc setting for subtarget: \"" ]

[]

[ "<s>", "unsigned", "X86TargetLowering", "::", "getExceptionPointerRegister", "(", "const", "Constant", "*", "PersonalityFn", ")", "const", "{", "if", "(", "classifyEHPersonality", "(", "PersonalityFn", ")", "==", "EHPersonality", "::", "CoreCLR", ")", "return", "Subtarget", "->", "isTarget64BitLP64", "(", ")", "?", "X86", "::", "RDX", ":", "X86", "::", "EDX", ";", "return", "Subtarget", "->", "isTarget64BitLP64", "(", ")", "?", "X86", "::", "RAX", ":", "X86", "::", "EAX", ";", "}", "</s>" ]

[ "If", "a", "physical", "register", ",", "this", "returns", "the", "register", "that", "receives", "the", "exception", "address", "on", "entry", "to", "an", "EH", "pad", "." ]

[ "X86", "X86", "X86::RDX", "X86::EDX", "X86::RAX", "X86::EAX" ]

[]

[ "<s>", "const", "X86TargetMachine", "*", "getTargetMachine", "(", ")", "const", "{", "return", "static_cast", "<", "const", "X86TargetMachine", "*", ">", "(", "&", "TM", ")", ";", "}", "</s>" ]

[ "Return", "the", "target", "machine", "(", "if", "available", ")", "." ]

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

[]

[ "<s>", "TargetLowering", "::", "AtomicExpansionKind", "ARMTargetLowering", "::", "shouldExpandAtomicRMWInIR", "(", "AtomicRMWInst", "*", "AI", ")", "const", "{", "if", "(", "AI", "->", "isFloatingPointOperation", "(", ")", ")", "return", "AtomicExpansionKind", "::", "CmpXChg", ";", "unsigned", "Size", "=", "AI", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", ";", "bool", "hasAtomicRMW", "=", "!", "Subtarget", "->", "isThumb", "(", ")", "||", "Subtarget", "->", "hasV8MBaselineOps", "(", ")", ";", "return", "(", "Size", "<=", "(", "Subtarget", "->", "isMClass", "(", ")", "?", "32U", ":", "64U", ")", "&&", "hasAtomicRMW", ")", "?", "AtomicExpansionKind", "::", "LLSC", ":", "AtomicExpansionKind", "::", "None", ";", "}", "</s>" ]

[ "Returns", "how", "the", "IR-level", "AtomicExpand", "pass", "should", "expand", "the", "given", "AtomicRMW", ",", "if", "at", "all", "." ]

[ "ARM", "ARM", "32U", "64U" ]

[]

[ "<s>", "const", "TargetRegisterClass", "*", "getMatchingSuperRegClass", "(", "const", "TargetRegisterClass", "*", "A", ",", "const", "TargetRegisterClass", "*", "B", ",", "unsigned", "Idx", ")", "const", "{", "return", "A", ";", "}", "</s>" ]

[ "getMatchingSuperRegClass", "-", "Return", "a", "subclass", "of", "the", "specified", "register", "class", "A", "so", "that", "each", "register", "in", "it", "has", "a", "sub-register", "of", "the", "specified", "sub-register", "index", "which", "is", "in", "the", "specified", "register", "class", "B", "." ]

[ "MSP430" ]

[]

[ "<s>", "bool", "SIFoldOperands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "ST", "=", "&", "MF", ".", "getSubtarget", "<", "GCNSubtarget", ">", "(", ")", ";", "TII", "=", "ST", "->", "getInstrInfo", "(", ")", ";", "TRI", "=", "&", "TII", "->", "getRegisterInfo", "(", ")", ";", "MFI", "=", "MF", ".", "getInfo", "<", "SIMachineFunctionInfo", ">", "(", ")", ";", "bool", "IsIEEEMode", "=", "MFI", "->", "getMode", "(", ")", ".", "IEEE", ";", "bool", "HasNSZ", "=", "MFI", "->", "hasNoSignedZerosFPMath", "(", ")", ";", "for", "(", "MachineBasicBlock", "*", "MBB", ":", "depth_first", "(", "&", "MF", ")", ")", "{", "MachineBasicBlock", "::", "iterator", "I", ",", "Next", ";", "for", "(", "I", "=", "MBB", "->", "begin", "(", ")", ";", "I", "!=", "MBB", "->", "end", "(", ")", ";", "I", "=", "Next", ")", "{", "Next", "=", "std", "::", "next", "(", "I", ")", ";", "MachineInstr", "&", "MI", "=", "*", "I", ";", "tryFoldInst", "(", "TII", ",", "&", "MI", ")", ";", "if", "(", "!", "TII", "->", "isFoldableCopy", "(", "MI", ")", ")", "{", "if", "(", "IsIEEEMode", "||", "(", "!", "HasNSZ", "&&", "!", "MI", ".", "getFlag", "(", "MachineInstr", "::", "FmNsz", ")", ")", "||", "!", "tryFoldOMod", "(", "MI", ")", ")", "tryFoldClamp", "(", "MI", ")", ";", "continue", ";", "}", "MachineOperand", "&", "OpToFold", "=", "MI", ".", "getOperand", "(", "1", ")", ";", "bool", "FoldingImm", "=", "OpToFold", ".", "isImm", "(", ")", "||", "OpToFold", ".", "isFI", "(", ")", "||", "OpToFold", ".", "isGlobal", "(", ")", ";", "if", "(", "!", "FoldingImm", "&&", "!", "OpToFold", ".", "isReg", "(", ")", ")", "continue", ";", "if", "(", "OpToFold", ".", "isReg", "(", ")", "&&", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "OpToFold", ".", "getReg", "(", ")", ")", ")", "continue", ";", "MachineOperand", "&", "Dst", "=", "MI", ".", "getOperand", "(", "0", ")", ";", "if", "(", "Dst", ".", "isReg", "(", ")", "&&", "!", "TargetRegisterInfo", "::", "isVirtualRegister", "(", "Dst", ".", "getReg", "(", ")", ")", ")", "continue", ";", "foldInstOperand", "(", "MI", ",", "OpToFold", ")", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "ix86_function_specific_post_stream_in", "(", "struct", "cl_target_option", "*", "ptr", ")", "{", "if", "(", "flag_pic", ")", "switch", "(", "ptr", "->", "x_ix86_cmodel", ")", "{", "case", "CM_SMALL", ":", "ptr", "->", "x_ix86_cmodel", "=", "CM_SMALL_PIC", ";", "break", ";", "case", "CM_MEDIUM", ":", "ptr", "->", "x_ix86_cmodel", "=", "CM_MEDIUM_PIC", ";", "break", ";", "case", "CM_LARGE", ":", "ptr", "->", "x_ix86_cmodel", "=", "CM_LARGE_PIC", ";", "break", ";", "case", "CM_KERNEL", ":", "error", "(", "\"code model %s does not support PIC mode\"", ",", "\"kernel\"", ")", ";", "break", ";", "default", ":", "break", ";", "}", "else", "switch", "(", "ptr", "->", "x_ix86_cmodel", ")", "{", "case", "CM_SMALL_PIC", ":", "ptr", "->", "x_ix86_cmodel", "=", "CM_SMALL", ";", "break", ";", "case", "CM_MEDIUM_PIC", ":", "ptr", "->", "x_ix86_cmodel", "=", "CM_MEDIUM", ";", "break", ";", "case", "CM_LARGE_PIC", ":", "ptr", "->", "x_ix86_cmodel", "=", "CM_LARGE", ";", "break", ";", "default", ":", "break", ";", "}", "}", "</s>" ]

[ "Adjust", "target", "options", "after", "streaming", "them", "in", ".", "This", "is", "mainly", "about", "reconciling", "them", "with", "global", "options", "." ]

[ "i386", "\"code model %s does not support PIC mode\"", "\"kernel\"" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "isDesirableToCommuteWithShift", "(", "const", "SDNode", "*", "N", ",", "CombineLevel", "Level", ")", "const", "{", "if", "(", "Level", "==", "BeforeLegalizeTypes", ")", "return", "true", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "SHL", ")", "return", "true", ";", "if", "(", "Subtarget", "->", "isThumb1Only", "(", ")", ")", "{", "if", "(", "N", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "SHL", ")", "return", "true", ";", "SDValue", "N1", "=", "N", "->", "getOperand", "(", "0", ")", ";", "if", "(", "N1", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "ADD", "&&", "N1", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "AND", "&&", "N1", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "OR", "&&", "N1", "->", "getOpcode", "(", ")", "!=", "ISD", "::", "XOR", ")", "return", "true", ";", "if", "(", "auto", "*", "Const", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "N1", "->", "getOperand", "(", "1", ")", ")", ")", "{", "if", "(", "Const", "->", "getAPIntValue", "(", ")", ".", "ult", "(", "256", ")", ")", "return", "false", ";", "if", "(", "N1", "->", "getOpcode", "(", ")", "==", "ISD", "::", "ADD", "&&", "Const", "->", "getAPIntValue", "(", ")", ".", "slt", "(", "0", ")", "&&", "Const", "->", "getAPIntValue", "(", ")", ".", "sgt", "(", "-", "256", ")", ")", "return", "false", ";", "}", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "to", "move", "this", "shift", "by", "a", "constant", "amount", "through", "its", "operand", ",", "adjusting", "any", "immediate", "operands", "as", "necessary", "to", "preserve", "semantics", "." ]

[ "ARM", "ARM", "ISD::SHL", "ISD::SHL", "0", "ISD::ADD", "ISD::AND", "ISD::OR", "ISD::XOR", "1", "256", "ISD::ADD", "0", "256" ]

[]

[ "<s>", "void", "GCNILPScheduler", "::", "releasePredecessors", "(", "const", "SUnit", "*", "SU", ")", "{", "for", "(", "const", "auto", "&", "PredEdge", ":", "SU", "->", "Preds", ")", "{", "auto", "PredSU", "=", "PredEdge", ".", "getSUnit", "(", ")", ";", "if", "(", "PredEdge", ".", "isWeak", "(", ")", ")", "continue", ";", "assert", "(", "PredSU", "->", "isBoundaryNode", "(", ")", "||", "PredSU", "->", "NumSuccsLeft", ">", "0", ")", ";", "PredSU", "->", "setHeightToAtLeast", "(", "SU", "->", "getHeight", "(", ")", "+", "PredEdge", ".", "getLatency", "(", ")", ")", ";", "if", "(", "!", "PredSU", "->", "isBoundaryNode", "(", ")", "&&", "--", "PredSU", "->", "NumSuccsLeft", "==", "0", ")", "PendingQueue", ".", "push_front", "(", "*", "new", "(", "Alloc", ".", "Allocate", "(", ")", ")", "Candidate", "(", "PredSU", ")", ")", ";", "}", "}", "</s>" ]

[ "releasePredecessors", "-", "Call", "releasePred", "on", "each", "of", "SU", "'s", "predecessors", "." ]

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

[]

[ "<s>", "bool", "X86IndirectBranchTrackingPass", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "const", "X86Subtarget", "&", "SubTarget", "=", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "Metadata", "*", "isCFProtectionSupported", "=", "MF", ".", "getMMI", "(", ")", ".", "getModule", "(", ")", "->", "getModuleFlag", "(", "\"cf-protection-branch\"", ")", ";", "const", "X86TargetMachine", "*", "TM", "=", "static_cast", "<", "const", "X86TargetMachine", "*", ">", "(", "&", "MF", ".", "getTarget", "(", ")", ")", ";", "bool", "isJITwithCET", "=", "TM", "->", "isJIT", "(", ")", ";", "bool", "isJITwithCET", "=", "false", ";", "if", "(", "!", "isCFProtectionSupported", "&&", "!", "IndirectBranchTracking", "&&", "!", "isJITwithCET", ")", "return", "false", ";", "bool", "Changed", "=", "false", ";", "TII", "=", "SubTarget", ".", "getInstrInfo", "(", ")", ";", "EndbrOpcode", "=", "SubTarget", ".", "is64Bit", "(", ")", "?", "X86", "::", "ENDBR64", ":", "X86", "::", "ENDBR32", ";", "if", "(", "(", "TM", "->", "getCodeModel", "(", ")", "==", "CodeModel", "::", "Large", "||", "MF", ".", "getFunction", "(", ")", ".", "hasAddressTaken", "(", ")", "||", "!", "MF", ".", "getFunction", "(", ")", ".", "hasLocalLinkage", "(", ")", ")", "&&", "!", "MF", ".", "getFunction", "(", ")", ".", "doesNoCfCheck", "(", ")", ")", "{", "auto", "MBB", "=", "MF", ".", "begin", "(", ")", ";", "Changed", "|=", "addENDBR", "(", "*", "MBB", ",", "MBB", "->", "begin", "(", ")", ")", ";", "}", "for", "(", "auto", "&", "MBB", ":", "MF", ")", "{", "if", "(", "MBB", ".", "hasAddressTaken", "(", ")", ")", "Changed", "|=", "addENDBR", "(", "MBB", ",", "MBB", ".", "begin", "(", ")", ")", ";", "bool", "EHPadIBTNeeded", "=", "MBB", ".", "isEHPad", "(", ")", ";", "for", "(", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "begin", "(", ")", ";", "I", "!=", "MBB", ".", "end", "(", ")", ";", "++", "I", ")", "{", "if", "(", "I", "->", "isCall", "(", ")", "&&", "IsCallReturnTwice", "(", "I", "->", "getOperand", "(", "0", ")", ")", ")", "Changed", "|=", "addENDBR", "(", "MBB", ",", "std", "::", "next", "(", "I", ")", ")", ";", "if", "(", "EHPadIBTNeeded", "&&", "I", "->", "isEHLabel", "(", ")", ")", "{", "Changed", "|=", "addENDBR", "(", "MBB", ",", "std", "::", "next", "(", "I", ")", ")", ";", "EHPadIBTNeeded", "=", "false", ";", "}", "}", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "X86", "\"cf-protection-branch\"", "X86", "X86", "X86::ENDBR64", "X86::ENDBR32", "0" ]

[]

[ "<s>", "static", "bool", "aarch64_builtin_support_vector_misalignment", "(", "machine_mode", "mode", ",", "const_tree", "type", ",", "int", "misalignment", ",", "bool", "is_packed", ")", "{", "if", "(", "TARGET_SIMD", "&&", "STRICT_ALIGNMENT", ")", "{", "if", "(", "optab_handler", "(", "movmisalign_optab", ",", "mode", ")", "==", "CODE_FOR_nothing", ")", "return", "false", ";", "if", "(", "misalignment", "==", "-", "1", ")", "return", "false", ";", "}", "return", "default_builtin_support_vector_misalignment", "(", "mode", ",", "type", ",", "misalignment", ",", "is_packed", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "vector", "misalignment", "factor", "is", "supported", "by", "the", "target", "." ]

[ "aarch64", "1" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "shouldSinkOperands", "(", "Instruction", "*", "I", ",", "SmallVectorImpl", "<", "Use", "*", ">", "&", "Ops", ")", "const", "{", "if", "(", "!", "Subtarget", "->", "hasNEON", "(", ")", "||", "!", "I", "->", "getType", "(", ")", "->", "isVectorTy", "(", ")", ")", "return", "false", ";", "switch", "(", "I", "->", "getOpcode", "(", ")", ")", "{", "case", "Instruction", "::", "Sub", ":", "case", "Instruction", "::", "Add", ":", "{", "if", "(", "!", "areExtractExts", "(", "I", "->", "getOperand", "(", "0", ")", ",", "I", "->", "getOperand", "(", "1", ")", ")", ")", "return", "false", ";", "Ops", ".", "push_back", "(", "&", "I", "->", "getOperandUse", "(", "0", ")", ")", ";", "Ops", ".", "push_back", "(", "&", "I", "->", "getOperandUse", "(", "1", ")", ")", ";", "return", "true", ";", "}", "default", ":", "return", "false", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "sinking", "I", "'s", "operands", "to", "the", "same", "basic", "block", "as", "I", "is", "profitable", ",", "e.g", "." ]

[ "ARM", "ARM", "0", "1", "0", "1" ]

[]

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

[ "Return", "the", "DataLayout", "associated", "with", "the", "module", "this", "SCEV", "instance", "is", "operating", "on", "." ]

[ "ARM" ]

[]

[ "<s>", "Optional", "<", "MCFixupKind", ">", "RISCVAsmBackend", "::", "getFixupKind", "(", "StringRef", "Name", ")", "const", "{", "if", "(", "STI", ".", "getTargetTriple", "(", ")", ".", "isOSBinFormatELF", "(", ")", ")", "{", "unsigned", "Type", ";", "Type", "=", "llvm", "::", "StringSwitch", "<", "unsigned", ">", "(", "Name", ")", ".", "Default", "(", "-", "1u", ")", ";", "if", "(", "Type", "!=", "-", "1u", ")", "return", "static_cast", "<", "MCFixupKind", ">", "(", "FirstLiteralRelocationKind", "+", "Type", ")", ";", "}", "return", "None", ";", "}", "</s>" ]

[ "getFixupKind", "-", "Get", "the", "fixup", "kind", "of", "this", "expression", "." ]

[ "RISCV", "RISCV", "1u", "1u" ]

[]

[ "<s>", "BitVector", "WebAssemblyRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "for", "(", "auto", "Reg", ":", "{", "WebAssembly", "::", "SP32", ",", "WebAssembly", "::", "SP64", ",", "WebAssembly", "::", "FP32", ",", "WebAssembly", "::", "FP64", "}", ")", "Reserved", ".", "set", "(", "Reg", ")", ";", "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", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly::SP32", "WebAssembly::SP64", "WebAssembly::FP32", "WebAssembly::FP64" ]

[]

[ "<s>", "EVT", "X86TargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsZeroVal", ",", "bool", "MemcpyStrSrc", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "IsZeroVal", "&&", "!", "F", "->", "getFnAttributes", "(", ")", ".", "hasAttribute", "(", "Attributes", "::", "NoImplicitFloat", ")", ")", "{", "if", "(", "Size", ">=", "16", "&&", "(", "Subtarget", "->", "isUnalignedMemAccessFast", "(", ")", "||", "(", "(", "DstAlign", "==", "0", "||", "DstAlign", ">=", "16", ")", "&&", "(", "SrcAlign", "==", "0", "||", "SrcAlign", ">=", "16", ")", ")", ")", ")", "{", "if", "(", "Size", ">=", "32", ")", "{", "if", "(", "Subtarget", "->", "hasInt256", "(", ")", ")", "return", "MVT", "::", "v8i32", ";", "if", "(", "Subtarget", "->", "hasFp256", "(", ")", ")", "return", "MVT", "::", "v8f32", ";", "}", "if", "(", "Subtarget", "->", "hasSSE2", "(", ")", ")", "return", "MVT", "::", "v4i32", ";", "if", "(", "Subtarget", "->", "hasSSE1", "(", ")", ")", "return", "MVT", "::", "v4f32", ";", "}", "else", "if", "(", "!", "MemcpyStrSrc", "&&", "Size", ">=", "8", "&&", "!", "Subtarget", "->", "is64Bit", "(", ")", "&&", "Subtarget", "->", "hasSSE2", "(", ")", ")", "{", "return", "MVT", "::", "f64", ";", "}", "}", "if", "(", "Subtarget", "->", "is64Bit", "(", ")", "&&", "Size", ">=", "8", ")", "return", "MVT", "::", "i64", ";", "return", "MVT", "::", "i32", ";", "}", "</s>" ]

[ "It", "returns", "EVT", ":", ":Other", "if", "the", "type", "should", "be", "determined", "using", "generic", "target-independent", "logic", "." ]

[ "X86", "X86", "16", "0", "16", "0", "16", "32", "MVT::v8i32", "MVT::v8f32", "MVT::v4i32", "MVT::v4f32", "8", "MVT::f64", "8", "MVT::i64", "MVT::i32" ]

[]

[ "<s>", "static", "bool", "xtensa_function_value_regno_p", "(", "const", "unsigned", "int", "regno", ")", "{", "return", "(", "regno", "==", "GP_RETURN", ")", ";", "}", "</s>" ]

[ "Worker", "function", "TARGET_FUNCTION_VALUE_REGNO_P", "." ]

[ "xtensa" ]

[]

[ "<s>", "static", "void", "pru_function_arg_regi_mark_slot", "(", "int", "regi", ",", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "HOST_WIDE_INT", "param_size", "=", "pru_function_arg_size", "(", "mode", ",", "type", ")", ";", "gcc_assert", "(", "named", ")", ";", "while", "(", "param_size", "--", ")", "{", "gcc_assert", "(", "regi", ">=", "FIRST_ARG_REGNUM", "&&", "regi", "<=", "LAST_ARG_REGNUM", ")", ";", "gcc_assert", "(", "!", "cum", "->", "regs_used", "[", "regi", "-", "FIRST_ARG_REGNUM", "]", ")", ";", "cum", "->", "regs_used", "[", "regi", "-", "FIRST_ARG_REGNUM", "]", "=", "true", ";", "regi", "++", ";", "}", "}", "</s>" ]

[ "Mark", "CUM_V", "that", "a", "function", "argument", "will", "occupy", "HW", "register", "slot", "starting", "at", "REGI", ".", "The", "number", "of", "consecutive", "8-bit", "HW", "registers", "marked", "as", "occupied", "depends", "on", "the", "MODE", "and", "TYPE", "of", "the", "argument", "." ]

[ "pru" ]

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"X86 FP_REG_KILL inserter\"", ";", "}", "</s>" ]

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

[ "X86", "\"X86 FP_REG_KILL inserter\"" ]

[]

[ "<s>", "void", "SITypeRewriter", "::", "visitCallInst", "(", "CallInst", "&", "I", ")", "{", "IRBuilder", "<", ">", "Builder", "(", "&", "I", ")", ";", "SmallVector", "<", "Value", "*", ",", "8", ">", "Args", ";", "SmallVector", "<", "Type", "*", ",", "8", ">", "Types", ";", "bool", "NeedToReplace", "=", "false", ";", "Function", "*", "F", "=", "I", ".", "getCalledFunction", "(", ")", ";", "std", "::", "string", "Name", "=", "F", "->", "getName", "(", ")", ".", "str", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "I", ".", "getNumArgOperands", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "Value", "*", "Arg", "=", "I", ".", "getArgOperand", "(", "i", ")", ";", "if", "(", "Arg", "->", "getType", "(", ")", "==", "v16i8", ")", "{", "Args", ".", "push_back", "(", "Builder", ".", "CreateBitCast", "(", "Arg", ",", "v4i32", ")", ")", ";", "Types", ".", "push_back", "(", "v4i32", ")", ";", "NeedToReplace", "=", "true", ";", "Name", "=", "Name", "+", "\".v4i32\"", ";", "}", "else", "if", "(", "Arg", "->", "getType", "(", ")", "->", "isVectorTy", "(", ")", "&&", "Arg", "->", "getType", "(", ")", "->", "getVectorNumElements", "(", ")", "==", "1", "&&", "Arg", "->", "getType", "(", ")", "->", "getVectorElementType", "(", ")", "==", "Type", "::", "getInt32Ty", "(", "I", ".", "getContext", "(", ")", ")", ")", "{", "Type", "*", "ElementTy", "=", "Arg", "->", "getType", "(", ")", "->", "getVectorElementType", "(", ")", ";", "std", "::", "string", "TypeName", "=", "\"i32\"", ";", "InsertElementInst", "*", "Def", "=", "dyn_cast", "<", "InsertElementInst", ">", "(", "Arg", ")", ";", "assert", "(", "Def", ")", ";", "Args", ".", "push_back", "(", "Def", "->", "getOperand", "(", "1", ")", ")", ";", "Types", ".", "push_back", "(", "ElementTy", ")", ";", "std", "::", "string", "VecTypeName", "=", "\"v1\"", "+", "TypeName", ";", "Name", "=", "Name", ".", "replace", "(", "Name", ".", "find", "(", "VecTypeName", ")", ",", "VecTypeName", ".", "length", "(", ")", ",", "TypeName", ")", ";", "NeedToReplace", "=", "true", ";", "}", "else", "{", "Args", ".", "push_back", "(", "Arg", ")", ";", "Types", ".", "push_back", "(", "Arg", "->", "getType", "(", ")", ")", ";", "}", "}", "if", "(", "!", "NeedToReplace", ")", "{", "return", ";", "}", "Function", "*", "NewF", "=", "Mod", "->", "getFunction", "(", "Name", ")", ";", "if", "(", "!", "NewF", ")", "{", "NewF", "=", "Function", "::", "Create", "(", "FunctionType", "::", "get", "(", "F", "->", "getReturnType", "(", ")", ",", "Types", ",", "false", ")", ",", "GlobalValue", "::", "ExternalLinkage", ",", "Name", ",", "Mod", ")", ";", "NewF", "->", "setAttributes", "(", "F", "->", "getAttributes", "(", ")", ")", ";", "}", "I", ".", "replaceAllUsesWith", "(", "Builder", ".", "CreateCall", "(", "NewF", ",", "Args", ")", ")", ";", "I", ".", "eraseFromParent", "(", ")", ";", "}", "</s>" ]

[ "CallInst", "simplification", "." ]

[ "R600", "SI", "8", "8", "0", "\".v4i32\"", "1", "\"i32\"", "1", "\"v1\"" ]

[]

[ "<s>", "static", "void", "aarch64_sls_emit_function_stub", "(", "FILE", "*", "out_file", ",", "int", "regnum", ")", "{", "asm_fprintf", "(", "out_file", ",", "\"\\tmov\\tx16, x%d\\n\"", ",", "regnum", ")", ";", "asm_fprintf", "(", "out_file", ",", "\"\\tbr\\tx16\\n\"", ")", ";", "}", "</s>" ]

[ "Helper", "function", "for", "aarch64_sls_emit_blr_function_thunks", "and", "aarch64_sls_emit_shared_blr_thunks", "below", "." ]

[ "aarch64", "\"\\tmov\\tx16, x%d\\n\"", "\"\\tbr\\tx16\\n\"" ]

[]

[ "<s>", "const", "char", "*", "ix86_output_indirect_jmp", "(", "rtx", "call_op", ")", "{", "if", "(", "cfun", "->", "machine", "->", "indirect_branch_type", "!=", "indirect_branch_keep", ")", "{", "if", "(", "ix86_red_zone_used", ")", "gcc_unreachable", "(", ")", ";", "ix86_output_indirect_branch", "(", "call_op", ",", "\"%0\"", ",", "true", ")", ";", "}", "else", "output_asm_insn", "(", "\"%!jmp\\t%A0\"", ",", "&", "call_op", ")", ";", "return", "(", "ix86_harden_sls", "&", "harden_sls_indirect_jmp", ")", "?", "\"int3\"", ":", "\"\"", ";", "}", "</s>" ]

[ "Output", "indirect", "jump", ".", "CALL_OP", "is", "the", "jump", "target", "." ]

[ "i386", "\"%0\"", "\"%!jmp\\t%A0\"", "\"int3\"", "\"\"" ]

[]

[ "<s>", "bool", "MipsAsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MipsFI", "=", "MF", ".", "getInfo", "<", "MipsFunctionInfo", ">", "(", ")", ";", "AsmPrinter", "::", "runOnMachineFunction", "(", "MF", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "SDValue", "PatmosTargetLowering", "::", "LowerFormalArguments", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "switch", "(", "CallConv", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unsupported calling convention\"", ")", ";", "case", "CallingConv", "::", "C", ":", "case", "CallingConv", "::", "Fast", ":", "return", "LowerCCCArguments", "(", "Chain", ",", "CallConv", ",", "isVarArg", ",", "Ins", ",", "dl", ",", "DAG", ",", "InVals", ")", ";", "}", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "the", "Ins", "array", ",", "into", "the", "specified", "DAG", "." ]

[ "Patmos", "Patmos", "ISD::InputArg", "\"Unsupported calling convention\"" ]

[]

[ "<s>", "unsigned", "ARM64InstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM64", "::", "LDRWui", ":", "case", "ARM64", "::", "LDRXui", ":", "case", "ARM64", "::", "LDRBui", ":", "case", "ARM64", "::", "LDRHui", ":", "case", "ARM64", "::", "LDRSui", ":", "case", "ARM64", "::", "LDRDui", ":", "case", "ARM64", "::", "LDRQui", ":", "if", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "}", "return", "0", ";", "}", "</s>" ]

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

[ "ARM64", "ARM64", "ARM64::LDRWui", "ARM64::LDRXui", "ARM64::LDRBui", "ARM64::LDRHui", "ARM64::LDRSui", "ARM64::LDRDui", "ARM64::LDRQui", "0", "0", "1", "2", "2", "0", "1", "0", "0" ]

[]

[ "<s>", "static", "rtx", "nvptx_expand_shared_addr", "(", "tree", "exp", ",", "rtx", "target", ",", "machine_mode", "ARG_UNUSED", "(", "mode", ")", ",", "int", "ignore", ",", "int", "vector", ")", "{", "if", "(", "ignore", ")", "return", "target", ";", "unsigned", "align", "=", "TREE_INT_CST_LOW", "(", "CALL_EXPR_ARG", "(", "exp", ",", "2", ")", ")", ";", "unsigned", "offset", "=", "TREE_INT_CST_LOW", "(", "CALL_EXPR_ARG", "(", "exp", ",", "0", ")", ")", ";", "unsigned", "size", "=", "TREE_INT_CST_LOW", "(", "CALL_EXPR_ARG", "(", "exp", ",", "1", ")", ")", ";", "rtx", "addr", "=", "worker_red_sym", ";", "if", "(", "vector", ")", "{", "offload_attrs", "oa", ";", "populate_offload_attrs", "(", "&", "oa", ")", ";", "unsigned", "int", "psize", "=", "ROUND_UP", "(", "size", "+", "offset", ",", "align", ")", ";", "unsigned", "int", "pnum", "=", "nvptx_mach_max_workers", "(", ")", ";", "vector_red_partition", "=", "MAX", "(", "vector_red_partition", ",", "psize", ")", ";", "vector_red_size", "=", "MAX", "(", "vector_red_size", ",", "psize", "*", "pnum", ")", ";", "vector_red_align", "=", "MAX", "(", "vector_red_align", ",", "align", ")", ";", "if", "(", "cfun", "->", "machine", "->", "red_partition", "==", "NULL", ")", "cfun", "->", "machine", "->", "red_partition", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "addr", "=", "gen_reg_rtx", "(", "Pmode", ")", ";", "emit_insn", "(", "gen_nvptx_red_partition", "(", "addr", ",", "GEN_INT", "(", "offset", ")", ")", ")", ";", "}", "else", "{", "worker_red_align", "=", "MAX", "(", "worker_red_align", ",", "align", ")", ";", "worker_red_size", "=", "MAX", "(", "worker_red_size", ",", "size", "+", "offset", ")", ";", "if", "(", "offset", ")", "{", "addr", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "addr", ",", "GEN_INT", "(", "offset", ")", ")", ";", "addr", "=", "gen_rtx_CONST", "(", "Pmode", ",", "addr", ")", ";", "}", "}", "emit_move_insn", "(", "target", ",", "addr", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Shared-memory", "reduction", "address", "expander", "." ]

[ "nvptx", "2", "0", "1" ]

[]

[ "<s>", "static", "rtx", "address_offset", "(", "rtx", "op", ")", "{", "if", "(", "GET_CODE", "(", "op", ")", "==", "PRE_INC", "||", "GET_CODE", "(", "op", ")", "==", "PRE_DEC", ")", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "else", "if", "(", "GET_CODE", "(", "op", ")", "==", "PRE_MODIFY", "||", "GET_CODE", "(", "op", ")", "==", "LO_SUM", ")", "op", "=", "XEXP", "(", "op", ",", "1", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST", ")", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "PLUS", ")", "op", "=", "XEXP", "(", "op", ",", "1", ")", ";", "if", "(", "CONST_INT_P", "(", "op", ")", ")", "return", "op", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Given", "an", "address", ",", "return", "a", "constant", "offset", "term", "if", "one", "exists", "." ]

[ "rs6000", "0", "1", "0", "1" ]

[]

[ "<s>", "void", "h8300_expand_branch", "(", "rtx", "operands", "[", "]", ")", "{", "enum", "rtx_code", "code", "=", "GET_CODE", "(", "operands", "[", "0", "]", ")", ";", "rtx", "op0", "=", "operands", "[", "1", "]", ";", "rtx", "op1", "=", "operands", "[", "2", "]", ";", "rtx", "label", "=", "operands", "[", "3", "]", ";", "rtx", "tmp", ";", "tmp", "=", "gen_rtx_COMPARE", "(", "VOIDmode", ",", "op0", ",", "op1", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "cc0_rtx", ",", "tmp", ")", ")", ";", "tmp", "=", "gen_rtx_fmt_ee", "(", "code", ",", "VOIDmode", ",", "cc0_rtx", ",", "const0_rtx", ")", ";", "tmp", "=", "gen_rtx_IF_THEN_ELSE", "(", "VOIDmode", ",", "tmp", ",", "gen_rtx_LABEL_REF", "(", "VOIDmode", ",", "label", ")", ",", "pc_rtx", ")", ";", "emit_jump_insn", "(", "gen_rtx_SET", "(", "VOIDmode", ",", "pc_rtx", ",", "tmp", ")", ")", ";", "}", "</s>" ]

[ "Expand", "a", "conditional", "branch", "." ]

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

[]

[ "<s>", "bool", "X86AsmParser", "::", "ParseDirective", "(", "AsmToken", "DirectiveID", ")", "{", "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "StringRef", "IDVal", "=", "DirectiveID", ".", "getIdentifier", "(", ")", ";", "if", "(", "IDVal", "==", "\".word\"", ")", "return", "ParseDirectiveWord", "(", "2", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".code\"", ")", ")", "return", "ParseDirectiveCode", "(", "IDVal", ",", "DirectiveID", ".", "getLoc", "(", ")", ")", ";", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".att_syntax\"", ")", ")", "{", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"prefix\"", ")", "Parser", ".", "Lex", "(", ")", ";", "else", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"noprefix\"", ")", "return", "Error", "(", "DirectiveID", ".", "getLoc", "(", ")", ",", "\"'.att_syntax noprefix' is not \"", "\"supported: registers must have a \"", "\"'%' prefix in .att_syntax\"", ")", ";", "}", "getParser", "(", ")", ".", "setAssemblerDialect", "(", "0", ")", ";", "return", "false", ";", "}", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".intel_syntax\"", ")", ")", "{", "getParser", "(", ")", ".", "setAssemblerDialect", "(", "1", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"noprefix\"", ")", "Parser", ".", "Lex", "(", ")", ";", "else", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "==", "\"prefix\"", ")", "return", "Error", "(", "DirectiveID", ".", "getLoc", "(", ")", ",", "\"'.intel_syntax prefix' is not \"", "\"supported: registers must not have \"", "\"a '%' prefix in .intel_syntax\"", ")", ";", "}", "return", "false", ";", "}", "else", "if", "(", "IDVal", ".", "startswith", "(", "\".dwarf_addr_size\"", ")", ")", "{", "if", "(", "Parser", ".", "getTok", "(", ")", ".", "getString", "(", ")", "!=", "\"4\"", ")", "return", "Error", "(", "DirectiveID", ".", "getLoc", "(", ")", ",", "\".dwarf_addr_size must be 4\"", ")", ";", "Parser", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "ParseDirective", "-", "Parse", "a", "target", "specific", "assembler", "directive", "This", "method", "is", "deprecated", ",", "use", "'parseDirective", "'", "instead", "." ]

[ "X86", "X86", "\".word\"", "2", "\".code\"", "\".att_syntax\"", "\"prefix\"", "\"noprefix\"", "\"'.att_syntax noprefix' is not \"", "\"supported: registers must have a \"", "\"'%' prefix in .att_syntax\"", "0", "\".intel_syntax\"", "1", "\"noprefix\"", "\"prefix\"", "\"'.intel_syntax prefix' is not \"", "\"supported: registers must not have \"", "\"a '%' prefix in .intel_syntax\"", "\".dwarf_addr_size\"", "\"4\"", "\".dwarf_addr_size must be 4\"" ]

[]

[ "<s>", "void", "SPUInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FrameIdx", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "unsigned", "opc", ";", "bool", "isValidFrameIdx", "=", "(", "FrameIdx", "<", "SPUFrameInfo", "::", "maxFrameOffset", "(", ")", ")", ";", "if", "(", "RC", "==", "SPU", "::", "GPRCRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr128", ":", "SPU", "::", "STQXr128", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R64CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr64", ":", "SPU", "::", "STQXr64", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R64FPRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr64", ":", "SPU", "::", "STQXr64", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R32CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr32", ":", "SPU", "::", "STQXr32", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R32FPRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr32", ":", "SPU", "::", "STQXr32", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R16CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr16", ":", "SPU", "::", "STQXr16", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "R8CRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", "?", "SPU", "::", "STQDr8", ":", "SPU", "::", "STQXr8", ")", ";", "}", "else", "if", "(", "RC", "==", "SPU", "::", "VECREGRegisterClass", ")", "{", "opc", "=", "(", "isValidFrameIdx", ")", "?", "SPU", "::", "STQDv16i8", ":", "SPU", "::", "STQXv16i8", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Unknown regclass!\"", ")", ";", "}", "DebugLoc", "DL", ";", "if", "(", "MI", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "addFrameReference", "(", "BuildMI", "(", "MBB", ",", "MI", ",", "DL", ",", "get", "(", "opc", ")", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ",", "FrameIdx", ")", ";", "}", "</s>" ]

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

[ "CellSPU", "SPU", "SPU", "SPU::GPRCRegisterClass", "SPU::STQDr128", "SPU::STQXr128", "SPU::R64CRegisterClass", "SPU::STQDr64", "SPU::STQXr64", "SPU::R64FPRegisterClass", "SPU::STQDr64", "SPU::STQXr64", "SPU::R32CRegisterClass", "SPU::STQDr32", "SPU::STQXr32", "SPU::R32FPRegisterClass", "SPU::STQDr32", "SPU::STQXr32", "SPU::R16CRegisterClass", "SPU::STQDr16", "SPU::STQXr16", "SPU::R8CRegisterClass", "SPU::STQDr8", "SPU::STQXr8", "SPU::VECREGRegisterClass", "SPU::STQDv16i8", "SPU::STQXv16i8", "\"Unknown regclass!\"" ]

[]

[ "<s>", "bool", "AArch64FastISel", "::", "isTypeLegal", "(", "Type", "*", "Ty", ",", "MVT", "&", "VT", ")", "{", "EVT", "evt", "=", "TLI", ".", "getValueType", "(", "DL", ",", "Ty", ",", "true", ")", ";", "if", "(", "Subtarget", "->", "isTargetILP32", "(", ")", "&&", "Ty", "->", "isPointerTy", "(", ")", ")", "return", "false", ";", "if", "(", "evt", "==", "MVT", "::", "Other", "||", "!", "evt", ".", "isSimple", "(", ")", ")", "return", "false", ";", "VT", "=", "evt", ".", "getSimpleVT", "(", ")", ";", "if", "(", "VT", "==", "MVT", "::", "f128", ")", "return", "false", ";", "return", "TLI", ".", "isTypeLegal", "(", "VT", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "MVT::Other", "MVT::f128" ]

[]

[ "<s>", "Value", "*", "ARMTargetLowering", "::", "emitStoreConditional", "(", "IRBuilderBase", "&", "Builder", ",", "Value", "*", "Val", ",", "Value", "*", "Addr", ",", "AtomicOrdering", "Ord", ")", "const", "{", "Module", "*", "M", "=", "Builder", ".", "GetInsertBlock", "(", ")", "->", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "bool", "IsRelease", "=", "isReleaseOrStronger", "(", "Ord", ")", ";", "if", "(", "Val", "->", "getType", "(", ")", "->", "getPrimitiveSizeInBits", "(", ")", "==", "64", ")", "{", "Intrinsic", "::", "ID", "Int", "=", "IsRelease", "?", "Intrinsic", "::", "arm_stlexd", ":", "Intrinsic", "::", "arm_strexd", ";", "Function", "*", "Strex", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ")", ";", "Type", "*", "Int32Ty", "=", "Type", "::", "getInt32Ty", "(", "M", "->", "getContext", "(", ")", ")", ";", "Value", "*", "Lo", "=", "Builder", ".", "CreateTrunc", "(", "Val", ",", "Int32Ty", ",", "\"lo\"", ")", ";", "Value", "*", "Hi", "=", "Builder", ".", "CreateTrunc", "(", "Builder", ".", "CreateLShr", "(", "Val", ",", "32", ")", ",", "Int32Ty", ",", "\"hi\"", ")", ";", "if", "(", "!", "Subtarget", "->", "isLittle", "(", ")", ")", "std", "::", "swap", "(", "Lo", ",", "Hi", ")", ";", "Addr", "=", "Builder", ".", "CreateBitCast", "(", "Addr", ",", "Type", "::", "getInt8PtrTy", "(", "M", "->", "getContext", "(", ")", ")", ")", ";", "return", "Builder", ".", "CreateCall", "(", "Strex", ",", "{", "Lo", ",", "Hi", ",", "Addr", "}", ")", ";", "}", "Intrinsic", "::", "ID", "Int", "=", "IsRelease", "?", "Intrinsic", "::", "arm_stlex", ":", "Intrinsic", "::", "arm_strex", ";", "Type", "*", "Tys", "[", "]", "=", "{", "Addr", "->", "getType", "(", ")", "}", ";", "Function", "*", "Strex", "=", "Intrinsic", "::", "getDeclaration", "(", "M", ",", "Int", ",", "Tys", ")", ";", "return", "Builder", ".", "CreateCall", "(", "Strex", ",", "{", "Builder", ".", "CreateZExtOrBitCast", "(", "Val", ",", "Strex", "->", "getFunctionType", "(", ")", "->", "getParamType", "(", "0", ")", ")", ",", "Addr", "}", ")", ";", "}", "</s>" ]

[ "Perform", "a", "store-conditional", "operation", "to", "Addr", "." ]

[ "ARM", "ARM", "64", "Intrinsic::ID", "Intrinsic::arm_stlexd", "Intrinsic::arm_strexd", "Intrinsic::getDeclaration", "\"lo\"", "32", "\"hi\"", "Intrinsic::ID", "Intrinsic::arm_stlex", "Intrinsic::arm_strex", "Intrinsic::getDeclaration", "0" ]

[]

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

[ "Return", "the", "preferred", "loop", "alignment", "." ]

[ "ARM" ]

[]

[ "<s>", "void", "arm_register_target_pragmas", "(", "void", ")", "{", "targetm", ".", "target_option", ".", "pragma_parse", "=", "arm_pragma_target_parse", ";", "REGISTER_SUBTARGET_PRAGMAS", "(", ")", ";", "}", "</s>" ]

[ "Register", "target", "pragmas", ".", "We", "need", "to", "add", "the", "hook", "for", "parsing", "#", "pragma", "GCC", "option", "here", "rather", "than", "in", "arm.cc", "since", "it", "will", "pull", "in", "various", "preprocessor", "functions", ",", "and", "those", "are", "not", "present", "in", "languages", "like", "fortran", "without", "a", "preprocessor", "." ]

[ "arm" ]

[]

[ "<s>", "static", "void", "sparc_atomic_assign_expand_fenv", "(", "tree", "*", "hold", ",", "tree", "*", "clear", ",", "tree", "*", "update", ")", "{", "if", "(", "!", "TARGET_FPU", ")", "return", ";", "const", "unsigned", "HOST_WIDE_INT", "accrued_exception_mask", "=", "0x1f", "<<", "5", ";", "const", "unsigned", "HOST_WIDE_INT", "trap_enable_mask", "=", "0x1f", "<<", "23", ";", "tree", "fenv_var", "=", "create_tmp_var_raw", "(", "unsigned_type_node", ")", ";", "TREE_ADDRESSABLE", "(", "fenv_var", ")", "=", "1", ";", "tree", "fenv_addr", "=", "build_fold_addr_expr", "(", "fenv_var", ")", ";", "tree", "stfsr", "=", "sparc_builtins", "[", "SPARC_BUILTIN_STFSR", "]", ";", "tree", "hold_stfsr", "=", "build4", "(", "TARGET_EXPR", ",", "unsigned_type_node", ",", "fenv_var", ",", "build_call_expr", "(", "stfsr", ",", "1", ",", "fenv_addr", ")", ",", "NULL_TREE", ",", "NULL_TREE", ")", ";", "tree", "tmp1_var", "=", "create_tmp_var_raw", "(", "unsigned_type_node", ")", ";", "TREE_ADDRESSABLE", "(", "tmp1_var", ")", "=", "1", ";", "tree", "masked_fenv_var", "=", "build2", "(", "BIT_AND_EXPR", ",", "unsigned_type_node", ",", "fenv_var", ",", "build_int_cst", "(", "unsigned_type_node", ",", "~", "(", "accrued_exception_mask", "|", "trap_enable_mask", ")", ")", ")", ";", "tree", "hold_mask", "=", "build4", "(", "TARGET_EXPR", ",", "unsigned_type_node", ",", "tmp1_var", ",", "masked_fenv_var", ",", "NULL_TREE", ",", "NULL_TREE", ")", ";", "tree", "tmp1_addr", "=", "build_fold_addr_expr", "(", "tmp1_var", ")", ";", "tree", "ldfsr", "=", "sparc_builtins", "[", "SPARC_BUILTIN_LDFSR", "]", ";", "tree", "hold_ldfsr", "=", "build_call_expr", "(", "ldfsr", ",", "1", ",", "tmp1_addr", ")", ";", "*", "hold", "=", "compound_expr", "(", "compound_expr", "(", "hold_stfsr", ",", "hold_mask", ")", ",", "hold_ldfsr", ")", ";", "*", "clear", "=", "build_call_expr", "(", "ldfsr", ",", "1", ",", "tmp1_addr", ")", ";", "tree", "tmp2_var", "=", "create_tmp_var_raw", "(", "unsigned_type_node", ")", ";", "TREE_ADDRESSABLE", "(", "tmp2_var", ")", "=", "1", ";", "tree", "tmp2_addr", "=", "build_fold_addr_expr", "(", "tmp2_var", ")", ";", "tree", "update_stfsr", "=", "build4", "(", "TARGET_EXPR", ",", "unsigned_type_node", ",", "tmp2_var", ",", "build_call_expr", "(", "stfsr", ",", "1", ",", "tmp2_addr", ")", ",", "NULL_TREE", ",", "NULL_TREE", ")", ";", "tree", "update_ldfsr", "=", "build_call_expr", "(", "ldfsr", ",", "1", ",", "fenv_addr", ")", ";", "tree", "atomic_feraiseexcept", "=", "builtin_decl_implicit", "(", "BUILT_IN_ATOMIC_FERAISEEXCEPT", ")", ";", "tree", "update_call", "=", "build_call_expr", "(", "atomic_feraiseexcept", ",", "1", ",", "fold_convert", "(", "integer_type_node", ",", "tmp2_var", ")", ")", ";", "if", "(", "SPARC_LOW_FE_EXCEPT_VALUES", ")", "{", "tree", "shifted_tmp2_var", "=", "build2", "(", "RSHIFT_EXPR", ",", "unsigned_type_node", ",", "tmp2_var", ",", "build_int_cst", "(", "unsigned_type_node", ",", "5", ")", ")", ";", "tree", "update_shift", "=", "build2", "(", "MODIFY_EXPR", ",", "void_type_node", ",", "tmp2_var", ",", "shifted_tmp2_var", ")", ";", "update_call", "=", "compound_expr", "(", "update_shift", ",", "update_call", ")", ";", "}", "*", "update", "=", "compound_expr", "(", "compound_expr", "(", "update_stfsr", ",", "update_ldfsr", ")", ",", "update_call", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ATOMIC_ASSIGN_EXPAND_FENV", "hook", "." ]

[ "sparc", "0x1f", "5", "0x1f", "23", "1", "1", "1", "1", "1", "1", "1", "1", "1", "5" ]

[]

[ "<s>", "bool", "RegDefsUses", "::", "update", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "Begin", ",", "unsigned", "End", ")", "{", "BitVector", "NewDefs", "(", "TRI", ".", "getNumRegs", "(", ")", ")", ",", "NewUses", "(", "TRI", ".", "getNumRegs", "(", ")", ")", ";", "bool", "HasHazard", "=", "false", ";", "for", "(", "unsigned", "I", "=", "Begin", ";", "I", "!=", "End", ";", "++", "I", ")", "{", "const", "MachineOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "I", ")", ";", "if", "(", "MO", ".", "isReg", "(", ")", "&&", "MO", ".", "getReg", "(", ")", ")", "{", "if", "(", "checkRegDefsUses", "(", "NewDefs", ",", "NewUses", ",", "MO", ".", "getReg", "(", ")", ",", "MO", ".", "isDef", "(", ")", ")", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "DEBUG_TYPE", "\": found register hazard for operand \"", "<<", "I", "<<", "\": \"", ";", "MO", ".", "dump", "(", ")", ")", ";", "HasHazard", "=", "true", ";", "}", "}", "}", "Defs", "|=", "NewDefs", ";", "Uses", "|=", "NewUses", ";", "return", "HasHazard", ";", "}", "</s>" ]

[ "Digest", "more", "data", "." ]

[ "Mips", "\": found register hazard for operand \"", "\": \"" ]

[]

[ "<s>", "int", "main", "(", "void", ")", "{", "enum", "avr_arch_id", "arch_id", "=", "ARCH_UNKNOWN", ";", "size_t", "i", ",", "n_mcus", "=", "0", ";", "const", "avr_mcu_t", "*", "mcu", ";", "printf", "(", "\"@c Copyright (C) 2012-2023 Free Software Foundation, Inc.\\n\"", ")", ";", "printf", "(", "\"@c This is part of the GCC manual.\\n\"", ")", ";", "printf", "(", "\"@c For copying conditions, see the file \"", "\"gcc/doc/include/fdl.texi.\\n\\n\"", ")", ";", "printf", "(", "\"@c This file is generated automatically using\\n\"", ")", ";", "printf", "(", "\"@c gcc/config/avr/gen-avr-mmcu-texi.cc from:\\n\"", ")", ";", "printf", "(", "\"@c\t gcc/config/avr/avr-arch.h\\n\"", ")", ";", "printf", "(", "\"@c\t gcc/config/avr/avr-devices.cc\\n\"", ")", ";", "printf", "(", "\"@c\t gcc/config/avr/avr-mcus.def\\n\\n\"", ")", ";", "printf", "(", "\"@c Please do not edit manually.\\n\\n\"", ")", ";", "printf", "(", "\"@table @code\\n\\n\"", ")", ";", "for", "(", "mcu", "=", "avr_mcu_types", ";", "mcu", "->", "name", ";", "mcu", "++", ")", "{", "if", "(", "mcu", "->", "macro", "==", "NULL", ")", "{", "arch_id", "=", "mcu", "->", "arch_id", ";", "print_mcus", "(", "n_mcus", ")", ";", "n_mcus", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "avr_texinfo", ")", ";", "i", "++", ")", "if", "(", "arch_id", "==", "avr_texinfo", "[", "i", "]", ".", "arch_id", ")", "printf", "(", "\"@item %s\\n%s\\n\"", ",", "mcu", "->", "name", ",", "avr_texinfo", "[", "i", "]", ".", "texinfo", ")", ";", "}", "else", "if", "(", "arch_id", "==", "(", "enum", "avr_arch_id", ")", "mcu", "->", "arch_id", ")", "{", "mcus", "[", "n_mcus", "++", "]", "=", "mcu", ";", "}", "}", "print_mcus", "(", "n_mcus", ")", ";", "printf", "(", "\"@end table\\n\"", ")", ";", "return", "EXIT_SUCCESS", ";", "}", "</s>" ]

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

[ "avr", "0", "\"@c Copyright (C) 2012-2023 Free Software Foundation, Inc.\\n\"", "\"@c This is part of the GCC manual.\\n\"", "\"@c For copying conditions, see the file \"", "\"gcc/doc/include/fdl.texi.\\n\\n\"", "\"@c This file is generated automatically using\\n\"", "\"@c gcc/config/avr/gen-avr-mmcu-texi.cc from:\\n\"", "\"@c\t gcc/config/avr/avr-arch.h\\n\"", "\"@c\t gcc/config/avr/avr-devices.cc\\n\"", "\"@c\t gcc/config/avr/avr-mcus.def\\n\\n\"", "\"@c Please do not edit manually.\\n\\n\"", "\"@table @code\\n\\n\"", "0", "0", "\"@item %s\\n%s\\n\"", "\"@end table\\n\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Branch Coalescing\"", ";", "}", "</s>" ]

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

[ "PowerPC", "\"Branch Coalescing\"" ]

[]

[ "<s>", "static", "void", "v850_set_data_area", "(", "tree", "decl", ",", "v850_data_area", "data_area", ")", "{", "tree", "name", ";", "switch", "(", "data_area", ")", "{", "case", "DATA_AREA_SDA", ":", "name", "=", "get_identifier", "(", "\"sda\"", ")", ";", "break", ";", "case", "DATA_AREA_TDA", ":", "name", "=", "get_identifier", "(", "\"tda\"", ")", ";", "break", ";", "case", "DATA_AREA_ZDA", ":", "name", "=", "get_identifier", "(", "\"zda\"", ")", ";", "break", ";", "default", ":", "return", ";", "}", "DECL_ATTRIBUTES", "(", "decl", ")", "=", "tree_cons", "(", "name", ",", "NULL", ",", "DECL_ATTRIBUTES", "(", "decl", ")", ")", ";", "}", "</s>" ]

[ "Store", "the", "indicated", "data", "area", "in", "the", "decl", "'s", "attributes", "." ]

[ "v850", "\"sda\"", "\"tda\"", "\"zda\"" ]

[]

[ "<s>", "bool", "isIndirect", "(", ")", "{", "return", "Target", "!=", "nullptr", "&&", "Target", "->", "isReg", "(", ")", ";", "}", "</s>" ]

[ "Returns", "whether", "this", "is", "an", "indirect", "value", "." ]

[ "SystemZ" ]

[]

[ "<s>", "static", "void", "release_scratch_register_on_entry", "(", "struct", "scratch_reg", "*", "sr", ")", "{", "if", "(", "sr", "->", "saved", ")", "{", "struct", "machine_function", "*", "m", "=", "cfun", "->", "machine", ";", "rtx", "x", ",", "insn", "=", "emit_insn", "(", "gen_pop", "(", "sr", "->", "reg", ")", ")", ";", "RTX_FRAME_RELATED_P", "(", "insn", ")", "=", "1", ";", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "UNITS_PER_WORD", ")", ")", ";", "x", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "stack_pointer_rtx", ",", "x", ")", ";", "add_reg_note", "(", "insn", ",", "REG_FRAME_RELATED_EXPR", ",", "x", ")", ";", "m", "->", "fs", ".", "sp_offset", "-=", "UNITS_PER_WORD", ";", "}", "}", "</s>" ]

[ "Release", "a", "scratch", "register", "obtained", "from", "the", "preceding", "function", ".", "If", "RELEASE_VIA_POP", "is", "true", ",", "we", "just", "pop", "the", "register", "off", "the", "stack", "to", "release", "it", ".", "This", "is", "what", "non-Linux", "systems", "use", "with", "-fstack-check", ".", "Otherwise", "we", "use", "OFFSET", "to", "locate", "the", "saved", "register", "and", "the", "allocated", "stack", "space", "becomes", "part", "of", "the", "local", "frame", "and", "is", "deallocated", "by", "the", "epilogue", "." ]

[ "i386", "1" ]

[]

[ "<s>", "HOST_WIDE_INT", "sparc_compute_frame_size", "(", "HOST_WIDE_INT", "size", ",", "int", "leaf_function", ")", "{", "HOST_WIDE_INT", "frame_size", ",", "apparent_frame_size", ";", "int", "args_size", ",", "n_global_fp_regs", "=", "0", ";", "bool", "save_local_in_regs_p", "=", "false", ";", "unsigned", "int", "i", ";", "if", "(", "leaf_function", "&&", "!", "cfun", "->", "calls_alloca", ")", "args_size", "=", "0", ";", "else", "args_size", "=", "crtl", "->", "outgoing_args_size", "+", "REG_PARM_STACK_SPACE", "(", "cfun", "->", "decl", ")", ";", "if", "(", "TARGET_ARCH64", ")", "{", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "i", "++", ")", "if", "(", "save_global_or_fp_reg_p", "(", "i", ",", "0", ")", ")", "n_global_fp_regs", "+=", "2", ";", "}", "else", "{", "for", "(", "i", "=", "0", ";", "i", "<", "8", ";", "i", "+=", "2", ")", "if", "(", "save_global_or_fp_reg_p", "(", "i", ",", "0", ")", "||", "save_global_or_fp_reg_p", "(", "i", "+", "1", ",", "0", ")", ")", "n_global_fp_regs", "+=", "2", ";", "}", "if", "(", "TARGET_FLAT", ")", "for", "(", "i", "=", "16", ";", "i", "<", "32", ";", "i", "++", ")", "if", "(", "save_local_or_in_reg_p", "(", "i", ",", "leaf_function", ")", ")", "{", "save_local_in_regs_p", "=", "true", ";", "break", ";", "}", "for", "(", "i", "=", "32", ";", "i", "<", "(", "TARGET_V9", "?", "96", ":", "64", ")", ";", "i", "+=", "2", ")", "if", "(", "save_global_or_fp_reg_p", "(", "i", ",", "0", ")", "||", "save_global_or_fp_reg_p", "(", "i", "+", "1", ",", "0", ")", ")", "n_global_fp_regs", "+=", "2", ";", "if", "(", "size", "==", "0", "&&", "n_global_fp_regs", "==", "0", "&&", "args_size", "==", "0", "&&", "!", "save_local_in_regs_p", ")", "frame_size", "=", "apparent_frame_size", "=", "0", ";", "else", "{", "apparent_frame_size", "=", "ROUND_UP", "(", "size", ",", "8", ")", "+", "n_global_fp_regs", "*", "4", ";", "frame_size", "=", "apparent_frame_size", "+", "ROUND_UP", "(", "args_size", ",", "8", ")", ";", "frame_size", "+=", "FIRST_PARM_OFFSET", "(", "cfun", "->", "decl", ")", ";", "frame_size", "=", "SPARC_STACK_ALIGN", "(", "frame_size", ")", ";", "}", "sparc_frame_size", "=", "frame_size", ";", "sparc_apparent_frame_size", "=", "apparent_frame_size", ";", "sparc_n_global_fp_regs", "=", "n_global_fp_regs", ";", "sparc_save_local_in_regs_p", "=", "save_local_in_regs_p", ";", "return", "frame_size", ";", "}", "</s>" ]

[ "Compute", "the", "frame", "size", "required", "by", "the", "function", ".", "This", "function", "is", "called", "during", "the", "reload", "pass", "and", "also", "by", "sparc_expand_prologue", "." ]

[ "sparc", "0", "0", "0", "8", "0", "2", "0", "8", "2", "0", "1", "0", "2", "16", "32", "32", "96", "64", "2", "0", "1", "0", "2", "0", "0", "0", "0", "8", "4", "8" ]

[]

[ "<s>", "void", "bpf_print_operand", "(", "FILE", "*", "file", ",", "rtx", "op", ",", "int", "code", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "GET_CODE", "(", "op", ")", ")", "{", "case", "REG", ":", "fprintf", "(", "file", ",", "\"%s\"", ",", "reg_names", "[", "REGNO", "(", "op", ")", "]", ")", ";", "break", ";", "case", "MEM", ":", "output_address", "(", "GET_MODE", "(", "op", ")", ",", "XEXP", "(", "op", ",", "0", ")", ")", ";", "break", ";", "case", "CONST_DOUBLE", ":", "if", "(", "CONST_DOUBLE_HIGH", "(", "op", ")", ")", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DOUBLE_HEX", ",", "CONST_DOUBLE_HIGH", "(", "op", ")", ",", "CONST_DOUBLE_LOW", "(", "op", ")", ")", ";", "else", "if", "(", "CONST_DOUBLE_LOW", "(", "op", ")", "<", "0", ")", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_HEX", ",", "CONST_DOUBLE_LOW", "(", "op", ")", ")", ";", "else", "fprintf", "(", "file", ",", "HOST_WIDE_INT_PRINT_DEC", ",", "CONST_DOUBLE_LOW", "(", "op", ")", ")", ";", "break", ";", "default", ":", "output_addr_const", "(", "file", ",", "op", ")", ";", "}", "}", "</s>" ]

[ "Print", "an", "instruction", "operand", ".", "This", "function", "is", "called", "in", "the", "macro", "PRINT_OPERAND", "defined", "in", "bpf.h" ]

[ "bpf", "\"%s\"", "0", "0" ]

[]

[ "<s>", "const", "uint32_t", "*", "AArch64RegisterInfo", "::", "getThisReturnPreservedMask", "(", "const", "MachineFunction", "&", "MF", ",", "CallingConv", "::", "ID", "CC", ")", "const", "{", "assert", "(", "CC", "!=", "CallingConv", "::", "GHC", "&&", "\"should not be GHC calling convention.\"", ")", ";", "return", "CSR_AArch64_AAPCS_ThisReturn_RegMask", ";", "}", "</s>" ]

[ "getThisReturnPreservedMask", "-", "Returns", "a", "call", "preserved", "mask", "specific", "to", "the", "case", "that", "'returned", "'", "is", "on", "an", "i32", "first", "argument", "if", "the", "calling", "convention", "is", "one", "that", "can", "(", "partially", ")", "model", "this", "attribute", "with", "a", "preserved", "mask", "(", "i.e", "." ]

[ "AArch64", "AArch64", "\"should not be GHC calling convention.\"", "AArch64" ]

[]

[ "<s>", "static", "int", "c6x_save_reg", "(", "unsigned", "int", "regno", ")", "{", "return", "(", "(", "df_regs_ever_live_p", "(", "regno", ")", "&&", "!", "call_used_regs", "[", "regno", "]", "&&", "!", "fixed_regs", "[", "regno", "]", ")", "||", "(", "regno", "==", "RETURN_ADDR_REGNO", "&&", "(", "df_regs_ever_live_p", "(", "regno", ")", "||", "!", "crtl", "->", "is_leaf", ")", ")", "||", "(", "regno", "==", "PIC_OFFSET_TABLE_REGNUM", "&&", "must_reload_pic_reg_p", "(", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "1", "if", "we", "need", "to", "save", "REGNO", "." ]

[ "c6x" ]

[]

[ "<s>", "bool", "and_operands_ok", "(", "machine_mode", "mode", ",", "rtx", "op1", ",", "rtx", "op2", ")", "{", "if", "(", "memory_operand", "(", "op1", ",", "mode", ")", ")", "{", "if", "(", "TARGET_MIPS16", ")", "{", "struct", "mips_address_info", "addr", ";", "if", "(", "!", "mips_classify_address", "(", "&", "addr", ",", "op1", ",", "mode", ",", "false", ")", ")", "return", "false", ";", "}", "return", "and_load_operand", "(", "op2", ",", "mode", ")", ";", "}", "else", "return", "and_reg_operand", "(", "op2", ",", "mode", ")", ";", "}", "</s>" ]

[ "Return", "true", "iff", "OP1", "and", "OP2", "are", "valid", "operands", "together", "for", "the", "*", "and", "<", "MODE", ">", "3", "and", "*", "and", "<", "MODE", ">", "3_mips16", "patterns", ".", "For", "the", "cases", "to", "consider", ",", "see", "the", "table", "in", "the", "comment", "before", "the", "pattern", "." ]

[ "mips" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"R600 Control Flow Finalizer Pass\"", ";", "}", "</s>" ]

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

[ "R600", "\"R600 Control Flow Finalizer Pass\"" ]

[]

[ "<s>", "static", "bool", "is_store_insn1", "(", "rtx", "pat", ")", "{", "if", "(", "!", "pat", "||", "pat", "==", "NULL_RTX", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", ")", "return", "is_mem_ref", "(", "SET_DEST", "(", "pat", ")", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "pat", ",", "0", ")", ";", "i", "++", ")", "if", "(", "is_store_insn1", "(", "XVECEXP", "(", "pat", ",", "0", ",", "i", ")", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Determine", "if", "PAT", "is", "a", "PATTERN", "of", "a", "store", "insn", "." ]

[ "rs6000", "0", "0", "0" ]

[]

[ "<s>", "static", "bool", "nds32_rtx_costs", "(", "rtx", "x", ",", "int", "code", ",", "int", "outer_code", ",", "int", "opno", ",", "int", "*", "total", ",", "bool", "speed", ")", "{", "return", "nds32_rtx_costs_impl", "(", "x", ",", "code", ",", "outer_code", ",", "opno", ",", "total", ",", "speed", ")", ";", "}", "</s>" ]

[ "This", "target", "hook", "describes", "the", "relative", "costs", "of", "RTL", "expressions", ".", "Return", "'true", "'", "when", "all", "subexpressions", "of", "x", "have", "been", "processed", ".", "Return", "'false", "'", "to", "sum", "the", "costs", "of", "sub-rtx", ",", "plus", "cost", "of", "this", "operation", ".", "Refer", "to", "gcc/rtlanal.cc", "for", "more", "information", "." ]

[ "nds32" ]

[]

[ "<s>", "static", "bool", "legitimate_offset_address_p", "(", "machine_mode", "mode", ",", "rtx", "x", ",", "bool", "index", ",", "bool", "strict", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "!=", "PLUS", ")", "return", "false", ";", "if", "(", "!", "RTX_OK_FOR_BASE_P", "(", "XEXP", "(", "x", ",", "0", ")", ",", "(", "strict", ")", ")", ")", "return", "false", ";", "if", "(", "(", "(", "index", "&&", "RTX_OK_FOR_INDEX_P", "(", "XEXP", "(", "x", ",", "1", ")", ",", "(", "strict", ")", ")", "&&", "GET_MODE_SIZE", "(", "(", "mode", ")", ")", "<=", "4", ")", "||", "RTX_OK_FOR_OFFSET_P", "(", "mode", ",", "XEXP", "(", "x", ",", "1", ")", ")", ")", ")", "return", "true", ";", "if", "(", "!", "flag_pic", "&&", "(", "GET_CODE", "(", "XEXP", "(", "x", ",", "1", ")", ")", "==", "SYMBOL_REF", ")", "&&", "(", "GET_MODE_SIZE", "(", "mode", ")", "<=", "4", ")", "&&", "(", "!", "SYMBOL_REF_SMALL_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Check", "for", "constructions", "like", "REG", "+", "OFFS", ",", "where", "OFFS", "can", "be", "a", "register", ",", "an", "immediate", "or", "an", "long", "immediate", "." ]

[ "arc", "0", "1", "4", "1", "1", "4", "1" ]

[]

[ "<s>", "static", "tree", "rs6000_builtin_mask_for_load", "(", "void", ")", "{", "if", "(", "TARGET_ALTIVEC", ")", "return", "altivec_builtin_mask_for_load", ";", "else", "return", "0", ";", "}", "</s>" ]

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

[ "rs6000", "0" ]

[]

[ "<s>", "static", "int", "ix86_memory_move_cost", "(", "machine_mode", "mode", ",", "reg_class_t", "regclass", ",", "bool", "in", ")", "{", "return", "inline_memory_move_cost", "(", "mode", ",", "(", "enum", "reg_class", ")", "regclass", ",", "in", "?", "1", ":", "0", ")", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "moving", "data", "of", "mode", "M", "between", "a", "register", "and", "memory", ".", "A", "value", "of", "2", "is", "the", "default", ";", "this", "cost", "is", "relative", "to", "those", "in", "`", "REGISTER_MOVE_COST", "'", ".", "If", "moving", "between", "registers", "and", "memory", "is", "more", "expensive", "than", "between", "two", "registers", ",", "you", "should", "define", "this", "macro", "to", "express", "the", "relative", "cost", ".", "Model", "also", "increased", "moving", "costs", "of", "QImode", "registers", "in", "non", "Q_REGS", "classes", "." ]

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

[]

[ "<s>", "static", "reg_class_t", "m32c_preferred_reload_class", "(", "rtx", "x", ",", "reg_class_t", "rclass", ")", "{", "reg_class_t", "newclass", "=", "rclass", ";", "fprintf", "(", "stderr", ",", "\"\\npreferred_reload_class for %s is \"", ",", "class_names", "[", "rclass", "]", ")", ";", "if", "(", "rclass", "==", "NO_REGS", ")", "rclass", "=", "GET_MODE", "(", "x", ")", "==", "QImode", "?", "HL_REGS", ":", "R03_REGS", ";", "if", "(", "reg_classes_intersect_p", "(", "rclass", ",", "CR_REGS", ")", ")", "{", "switch", "(", "GET_MODE", "(", "x", ")", ")", "{", "case", "E_QImode", ":", "newclass", "=", "HL_REGS", ";", "break", ";", "default", ":", "break", ";", "}", "}", "else", "if", "(", "newclass", "==", "QI_REGS", "&&", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ">", "2", ")", "newclass", "=", "SI_REGS", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "GET_MODE", "(", "x", ")", ")", ">", "4", "&&", "!", "reg_class_subset_p", "(", "R03_REGS", ",", "rclass", ")", ")", "newclass", "=", "DI_REGS", ";", "rclass", "=", "reduce_class", "(", "rclass", ",", "newclass", ",", "rclass", ")", ";", "if", "(", "GET_MODE", "(", "x", ")", "==", "QImode", ")", "rclass", "=", "reduce_class", "(", "rclass", ",", "HL_REGS", ",", "rclass", ")", ";", "fprintf", "(", "stderr", ",", "\"%s\\n\"", ",", "class_names", "[", "rclass", "]", ")", ";", "debug_rtx", "(", "x", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", "&&", "GET_CODE", "(", "XEXP", "(", "x", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ")", ")", "==", "PLUS", ")", "fprintf", "(", "stderr", ",", "\"Glorm!\\n\"", ")", ";", "return", "rclass", ";", "}", "</s>" ]

[ "Implements", "PREFERRED_RELOAD_CLASS", ".", "In", "general", ",", "prefer", "general", "registers", "of", "the", "appropriate", "size", "." ]

[ "m32c", "\"\\npreferred_reload_class for %s is \"", "2", "4", "\"%s\\n\"", "0", "0", "0", "\"Glorm!\\n\"" ]

[]

[ "<s>", "MipsTargetLowering", "::", "ConstraintType", "MipsTargetLowering", "::", "getConstraintType", "(", "const", "std", "::", "string", "&", "Constraint", ")", "const", "{", "if", "(", "Constraint", ".", "size", "(", ")", "==", "1", ")", "{", "switch", "(", "Constraint", "[", "0", "]", ")", "{", "default", ":", "break", ";", "case", "'d'", ":", "case", "'y'", ":", "case", "'f'", ":", "case", "'c'", ":", "case", "'l'", ":", "case", "'x'", ":", "return", "C_RegisterClass", ";", "case", "'R'", ":", "return", "C_Memory", ";", "}", "}", "if", "(", "Constraint", "==", "\"ZC\"", ")", "return", "C_Memory", ";", "return", "TargetLowering", "::", "getConstraintType", "(", "Constraint", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "1", "0", "\"ZC\"" ]

[]

[ "<s>", "void", "WebAssemblyInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "auto", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "Register", "::", "isVirtualRegister", "(", "DestReg", ")", "?", "MRI", ".", "getRegClass", "(", "DestReg", ")", ":", "MRI", ".", "getTargetRegisterInfo", "(", ")", "->", "getMinimalPhysRegClass", "(", "DestReg", ")", ";", "unsigned", "CopyOpcode", ";", "if", "(", "RC", "==", "&", "WebAssembly", "::", "I32RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_I32", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "I64RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_I64", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "F32RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_F32", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "F64RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_F64", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "V128RegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_V128", ";", "else", "if", "(", "RC", "==", "&", "WebAssembly", "::", "EXNREFRegClass", ")", "CopyOpcode", "=", "WebAssembly", "::", "COPY_EXNREF", ";", "else", "llvm_unreachable", "(", "\"Unexpected register class\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "CopyOpcode", ")", ",", "DestReg", ")", ".", "addReg", "(", "SrcReg", ",", "KillSrc", "?", "RegState", "::", "Kill", ":", "0", ")", ";", "}", "</s>" ]

[ "}", "Branch", "Analysis", "&", "Modification" ]

[ "WebAssembly", "WebAssembly", "WebAssembly::I32RegClass", "WebAssembly::COPY_I32", "WebAssembly::I64RegClass", "WebAssembly::COPY_I64", "WebAssembly::F32RegClass", "WebAssembly::COPY_F32", "WebAssembly::F64RegClass", "WebAssembly::COPY_F64", "WebAssembly::V128RegClass", "WebAssembly::COPY_V128", "WebAssembly::EXNREFRegClass", "WebAssembly::COPY_EXNREF", "\"Unexpected register class\"", "0" ]

[]

[ "<s>", "unsigned", "DLXInstrInfo", "::", "isLoadFromStackSlotPostFE", "(", "const", "MachineInstr", "&", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "return", "1", ";", "}", "</s>" ]

[ "isLoadFromStackSlotPostFE", "-", "Check", "for", "post-frame", "ptr", "elimination", "stack", "locations", "as", "well", "." ]

[ "DLX", "DLX", "1" ]

[]

[ "<s>", "static", "void", "emit_save_or_restore_global_fp_regs", "(", "rtx", "base", ",", "int", "offset", ",", "sorr_act_t", "action", ")", "{", "if", "(", "offset", "<", "-", "4096", "||", "offset", "+", "sparc_n_global_fp_regs", "*", "4", ">", "4095", ")", "{", "base", "=", "emit_adjust_base_to_offset", "(", "base", ",", "offset", ")", ";", "offset", "=", "0", ";", "}", "offset", "=", "emit_save_or_restore_regs", "(", "0", ",", "8", ",", "base", ",", "offset", ",", "0", ",", "save_global_or_fp_reg_p", ",", "action", ",", "SORR_NONE", ")", ";", "emit_save_or_restore_regs", "(", "32", ",", "TARGET_V9", "?", "96", ":", "64", ",", "base", ",", "offset", ",", "0", ",", "save_global_or_fp_reg_p", ",", "action", ",", "SORR_NONE", ")", ";", "}", "</s>" ]

[ "Emit", "code", "to", "save/restore", "call-saved", "global", "and", "FP", "registers", "." ]

[ "sparc", "4096", "4", "4095", "0", "0", "8", "0", "32", "96", "64", "0" ]

[]

[ "<s>", "static", "bool", "iq2000_pass_by_reference", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", "ATTRIBUTE_UNUSED", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "size", ";", "if", "(", "cum", "&&", "targetm", ".", "calls", ".", "must_pass_in_stack", "(", "mode", ",", "type", ")", ")", "{", "CUMULATIVE_ARGS", "temp", ";", "temp", "=", "*", "cum", ";", "if", "(", "iq2000_function_arg", "(", "pack_cumulative_args", "(", "&", "temp", ")", ",", "mode", ",", "type", ",", "named", ")", "!=", "0", ")", "return", "1", ";", "}", "if", "(", "type", "==", "NULL_TREE", "||", "mode", "==", "DImode", "||", "mode", "==", "DFmode", ")", "return", "0", ";", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "return", "size", "==", "-", "1", "||", "size", ">", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Return", "true", "when", "an", "argument", "must", "be", "passed", "by", "reference", "." ]

[ "iq2000", "0", "1", "0", "1" ]

[]

[ "<s>", "void", "AArch64RegisterInfo", "::", "resolveFrameIndex", "(", "MachineInstr", "&", "MI", ",", "unsigned", "BaseReg", ",", "int64_t", "Offset", ")", "const", "{", "int", "Off", "=", "Offset", ";", "unsigned", "i", "=", "0", ";", "while", "(", "!", "MI", ".", "getOperand", "(", "i", ")", ".", "isFI", "(", ")", ")", "{", "++", "i", ";", "assert", "(", "i", "<", "MI", ".", "getNumOperands", "(", ")", "&&", "\"Instr doesn't have FrameIndex operand!\"", ")", ";", "}", "const", "MachineFunction", "*", "MF", "=", "MI", ".", "getParent", "(", ")", "->", "getParent", "(", ")", ";", "const", "AArch64InstrInfo", "*", "TII", "=", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "bool", "Done", "=", "rewriteAArch64FrameIndex", "(", "MI", ",", "i", ",", "BaseReg", ",", "Off", ",", "TII", ")", ";", "assert", "(", "Done", "&&", "\"Unable to resolve frame index!\"", ")", ";", "(", "void", ")", "Done", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "0", "\"Instr doesn't have FrameIndex operand!\"", "AArch64", "AArch64", "AArch64", "\"Unable to resolve frame index!\"" ]

[]

[ "<s>", "unsigned", "int", "R600InstrInfo", "::", "getInstrLatency", "(", "const", "InstrItineraryData", "*", "ItinData", ",", "const", "MachineInstr", "*", "MI", ",", "unsigned", "*", "PredCost", ")", "const", "{", "if", "(", "PredCost", ")", "*", "PredCost", "=", "2", ";", "return", "2", ";", "}", "</s>" ]

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

[ "AMDGPU", "R600", "2", "2" ]

[]

[ "<s>", "static", "void", "nvptx_file_start", "(", "void", ")", "{", "fputs", "(", "\"// BEGIN PREAMBLE\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.version\\t3.1\\n\"", ",", "asm_out_file", ")", ";", "fputs", "(", "\"\\t.target\\tsm_30\\n\"", ",", "asm_out_file", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.address_size %d\\n\"", ",", "GET_MODE_BITSIZE", "(", "Pmode", ")", ")", ";", "fputs", "(", "\"// END PREAMBLE\\n\"", ",", "asm_out_file", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_FILE_START", ".", "Write", "the", "kinds", "of", "things", "ptxas", "expects", "at", "the", "start", "of", "a", "file", "." ]

[ "nvptx", "\"// BEGIN PREAMBLE\\n\"", "\"\\t.version\\t3.1\\n\"", "\"\\t.target\\tsm_30\\n\"", "\"\\t.address_size %d\\n\"", "\"// END PREAMBLE\\n\"" ]

[]

[ "<s>", "static", "void", "expand_set_or_cpymem_via_rep", "(", "rtx", "destmem", ",", "rtx", "srcmem", ",", "rtx", "destptr", ",", "rtx", "srcptr", ",", "rtx", "value", ",", "rtx", "orig_value", ",", "rtx", "count", ",", "machine_mode", "mode", ",", "bool", "issetmem", ")", "{", "rtx", "destexp", ";", "rtx", "srcexp", ";", "rtx", "countreg", ";", "HOST_WIDE_INT", "rounded_count", ";", "if", "(", "mode", "==", "QImode", "&&", "CONST_INT_P", "(", "count", ")", "&&", "!", "(", "INTVAL", "(", "count", ")", "&", "3", ")", "&&", "!", "TARGET_PREFER_KNOWN_REP_MOVSB_STOSB", "&&", "(", "!", "issetmem", "||", "orig_value", "==", "const0_rtx", ")", ")", "mode", "=", "SImode", ";", "if", "(", "destptr", "!=", "XEXP", "(", "destmem", ",", "0", ")", "||", "GET_MODE", "(", "destmem", ")", "!=", "BLKmode", ")", "destmem", "=", "adjust_automodify_address_nv", "(", "destmem", ",", "BLKmode", ",", "destptr", ",", "0", ")", ";", "countreg", "=", "ix86_zero_extend_to_Pmode", "(", "scale_counter", "(", "count", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", ";", "if", "(", "mode", "!=", "QImode", ")", "{", "destexp", "=", "gen_rtx_ASHIFT", "(", "Pmode", ",", "countreg", ",", "GEN_INT", "(", "exact_log2", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", ")", ";", "destexp", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "destexp", ",", "destptr", ")", ";", "}", "else", "destexp", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "destptr", ",", "countreg", ")", ";", "if", "(", "(", "!", "issetmem", "||", "orig_value", "==", "const0_rtx", ")", "&&", "CONST_INT_P", "(", "count", ")", ")", "{", "rounded_count", "=", "ROUND_DOWN", "(", "INTVAL", "(", "count", ")", ",", "(", "HOST_WIDE_INT", ")", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "destmem", "=", "shallow_copy_rtx", "(", "destmem", ")", ";", "set_mem_size", "(", "destmem", ",", "rounded_count", ")", ";", "}", "else", "if", "(", "MEM_SIZE_KNOWN_P", "(", "destmem", ")", ")", "clear_mem_size", "(", "destmem", ")", ";", "if", "(", "issetmem", ")", "{", "value", "=", "force_reg", "(", "mode", ",", "gen_lowpart", "(", "mode", ",", "value", ")", ")", ";", "emit_insn", "(", "gen_rep_stos", "(", "destptr", ",", "countreg", ",", "destmem", ",", "value", ",", "destexp", ")", ")", ";", "}", "else", "{", "if", "(", "srcptr", "!=", "XEXP", "(", "srcmem", ",", "0", ")", "||", "GET_MODE", "(", "srcmem", ")", "!=", "BLKmode", ")", "srcmem", "=", "adjust_automodify_address_nv", "(", "srcmem", ",", "BLKmode", ",", "srcptr", ",", "0", ")", ";", "if", "(", "mode", "!=", "QImode", ")", "{", "srcexp", "=", "gen_rtx_ASHIFT", "(", "Pmode", ",", "countreg", ",", "GEN_INT", "(", "exact_log2", "(", "GET_MODE_SIZE", "(", "mode", ")", ")", ")", ")", ";", "srcexp", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "srcexp", ",", "srcptr", ")", ";", "}", "else", "srcexp", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "srcptr", ",", "countreg", ")", ";", "if", "(", "CONST_INT_P", "(", "count", ")", ")", "{", "rounded_count", "=", "ROUND_DOWN", "(", "INTVAL", "(", "count", ")", ",", "(", "HOST_WIDE_INT", ")", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "srcmem", "=", "shallow_copy_rtx", "(", "srcmem", ")", ";", "set_mem_size", "(", "srcmem", ",", "rounded_count", ")", ";", "}", "else", "{", "if", "(", "MEM_SIZE_KNOWN_P", "(", "srcmem", ")", ")", "clear_mem_size", "(", "srcmem", ")", ";", "}", "emit_insn", "(", "gen_rep_mov", "(", "destptr", ",", "destmem", ",", "srcptr", ",", "srcmem", ",", "countreg", ",", "destexp", ",", "srcexp", ")", ")", ";", "}", "}", "</s>" ]

[ "Output", "``", "rep", ";", "mov", "''", "or", "``", "rep", ";", "stos", "''", "instruction", "depending", "on", "ISSETMEM", "argument", ".", "When", "ISSETMEM", "is", "true", ",", "arguments", "SRCMEM", "and", "SRCPTR", "are", "ignored", ".", "When", "ISSETMEM", "is", "false", ",", "arguments", "VALUE", "and", "ORIG_VALUE", "are", "ignored", ".", "For", "setmem", "case", ",", "VALUE", "is", "a", "promoted", "to", "a", "wider", "size", "ORIG_VALUE", ".", "ORIG_VALUE", "is", "the", "original", "value", "passed", "to", "memset", "to", "fill", "the", "memory", "with", ".", "Other", "arguments", "have", "same", "meaning", "as", "for", "previous", "function", "." ]

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

[]

[ "<s>", "bool", "RISCVAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "{", "bool", "HasStdExtC", "=", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureStdExtC", "]", ";", "unsigned", "MinNopLen", "=", "HasStdExtC", "?", "2", ":", "4", ";", "if", "(", "(", "Count", "%", "MinNopLen", ")", "!=", "0", ")", "return", "false", ";", "for", "(", ";", "Count", ">=", "4", ";", "Count", "-=", "4", ")", "OS", ".", "write", "(", "\"\\x13\\0\\0\\0\"", ",", "4", ")", ";", "if", "(", "Count", "&&", "HasStdExtC", ")", "OS", ".", "write", "(", "\"\\x01\\0\"", ",", "2", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Write", "an", "(", "optimal", ")", "nop", "sequence", "of", "Count", "bytes", "to", "the", "given", "output", "." ]

[ "RI5CY", "RISCV", "RISCV::FeatureStdExtC", "2", "4", "0", "4", "4", "\"\\x13\\0\\0\\0\"", "4", "\"\\x01\\0\"", "2" ]

[]

[ "<s>", "static", "int", "tilepro_compare_multipliers", "(", "const", "void", "*", "key", ",", "const", "void", "*", "t", ")", "{", "return", "*", "(", "const", "int", "*", ")", "key", "-", "(", "(", "const", "struct", "tilepro_multiply_insn_seq", "*", ")", "t", ")", "->", "multiplier", ";", "}", "</s>" ]

[ "bsearch", "helper", "function", "." ]

[ "tilepro" ]

[]

[ "<s>", "unsigned", "R600InstrInfo", "::", "isLegalUpTo", "(", "const", "std", "::", "vector", "<", "std", "::", "vector", "<", "std", "::", "pair", "<", "int", ",", "unsigned", ">>", ">", "&", "IGSrcs", ",", "const", "std", "::", "vector", "<", "R600InstrInfo", "::", "BankSwizzle", ">", "&", "Swz", ",", "const", "std", "::", "vector", "<", "std", "::", "pair", "<", "int", ",", "unsigned", ">>", "&", "TransSrcs", ",", "R600InstrInfo", "::", "BankSwizzle", "TransSwz", ")", "const", "{", "int", "Vector", "[", "4", "]", "[", "3", "]", ";", "memset", "(", "Vector", ",", "-", "1", ",", "sizeof", "(", "Vector", ")", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "IGSrcs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "i", "++", ")", "{", "const", "std", "::", "vector", "<", "std", "::", "pair", "<", "int", ",", "unsigned", ">>", "&", "Srcs", "=", "Swizzle", "(", "IGSrcs", "[", "i", "]", ",", "Swz", "[", "i", "]", ")", ";", "for", "(", "unsigned", "j", "=", "0", ";", "j", "<", "3", ";", "j", "++", ")", "{", "const", "std", "::", "pair", "<", "int", ",", "unsigned", ">", "&", "Src", "=", "Srcs", "[", "j", "]", ";", "if", "(", "Src", ".", "first", "<", "0", "||", "Src", ".", "first", "==", "255", ")", "continue", ";", "if", "(", "Src", ".", "first", "==", "GET_REG_INDEX", "(", "RI", ".", "getEncodingValue", "(", "R600", "::", "OQAP", ")", ")", ")", "{", "if", "(", "Swz", "[", "i", "]", "!=", "R600InstrInfo", "::", "ALU_VEC_012_SCL_210", "&&", "Swz", "[", "i", "]", "!=", "R600InstrInfo", "::", "ALU_VEC_021_SCL_122", ")", "{", "return", "false", ";", "}", "continue", ";", "}", "if", "(", "Vector", "[", "Src", ".", "second", "]", "[", "j", "]", "<", "0", ")", "Vector", "[", "Src", ".", "second", "]", "[", "j", "]", "=", "Src", ".", "first", ";", "if", "(", "Vector", "[", "Src", ".", "second", "]", "[", "j", "]", "!=", "Src", ".", "first", ")", "return", "i", ";", "}", "}", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "TransSrcs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "const", "std", "::", "pair", "<", "int", ",", "unsigned", ">", "&", "Src", "=", "TransSrcs", "[", "i", "]", ";", "unsigned", "Cycle", "=", "getTransSwizzle", "(", "TransSwz", ",", "i", ")", ";", "if", "(", "Src", ".", "first", "<", "0", ")", "continue", ";", "if", "(", "Src", ".", "first", "==", "255", ")", "continue", ";", "if", "(", "Vector", "[", "Src", ".", "second", "]", "[", "Cycle", "]", "<", "0", ")", "Vector", "[", "Src", ".", "second", "]", "[", "Cycle", "]", "=", "Src", ".", "first", ";", "if", "(", "Vector", "[", "Src", ".", "second", "]", "[", "Cycle", "]", "!=", "Src", ".", "first", ")", "return", "IGSrcs", ".", "size", "(", ")", "-", "1", ";", "}", "return", "IGSrcs", ".", "size", "(", ")", ";", "}", "</s>" ]

[ "returns", "how", "many", "MIs", "(", "whose", "inputs", "are", "represented", "by", "IGSrcs", ")", "can", "be", "packed", "in", "the", "same", "Instruction", "Group", "while", "meeting", "read", "port", "limitations", "given", "a", "Swz", "swizzle", "sequence", "." ]

[ "AMDGPU", "R600", "R600", "R600", "4", "3", "1", "0", "0", "3", "0", "255", "R600::OQAP", "R600", "R600", "0", "0", "0", "255", "0", "1" ]

[]

[ "<s>", "void", "Thumb2InstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "if", "(", "RC", "==", "ARM", "::", "GPRRegisterClass", "||", "RC", "==", "ARM", "::", "tGPRRegisterClass", "||", "RC", "==", "ARM", "::", "tcGPRRegisterClass", "||", "RC", "==", "ARM", "::", "rGPRRegisterClass", ")", "{", "DebugLoc", "DL", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "(", "PseudoSourceValue", "::", "getFixedStack", "(", "FI", ")", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ")", ";", "AddDefaultPred", "(", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "ARM", "::", "t2LDRi12", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ")", ";", "return", ";", "}", "ARMBaseInstrInfo", "::", "loadRegFromStackSlot", "(", "MBB", ",", "I", ",", "DestReg", ",", "FI", ",", "RC", ",", "TRI", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM::GPRRegisterClass", "ARM::tGPRRegisterClass", "ARM::tcGPRRegisterClass", "ARM::rGPRRegisterClass", "ARM::t2LDRi12", "0", "ARM" ]

[]

[ "<s>", "void", "alpha_output_filename", "(", "FILE", "*", "stream", ",", "const", "char", "*", "name", ")", "{", "static", "int", "first_time", "=", "TRUE", ";", "if", "(", "first_time", ")", "{", "first_time", "=", "FALSE", ";", "++", "num_source_filenames", ";", "current_function_file", "=", "name", ";", "fprintf", "(", "stream", ",", "\"\\t.file\\t%d \"", ",", "num_source_filenames", ")", ";", "output_quoted_string", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\"\\n\"", ")", ";", "}", "else", "if", "(", "name", "!=", "current_function_file", "&&", "strcmp", "(", "name", ",", "current_function_file", ")", "!=", "0", ")", "{", "++", "num_source_filenames", ";", "current_function_file", "=", "name", ";", "fprintf", "(", "stream", ",", "\"\\t.file\\t%d \"", ",", "num_source_filenames", ")", ";", "output_quoted_string", "(", "stream", ",", "name", ")", ";", "fprintf", "(", "stream", ",", "\"\\n\"", ")", ";", "}", "}", "</s>" ]

[ "Emit", "a", "new", "filename", "to", "a", "stream", "." ]

[ "alpha", "\"\\t.file\\t%d \"", "\"\\n\"", "0", "\"\\t.file\\t%d \"", "\"\\n\"" ]

[]

[ "<s>", "bool", "AMDGPUCFGPerform", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "func", ")", "{", "return", "CFGStructurizer", "<", "AMDGPUCFGStructurizer", ">", "(", ")", ".", "run", "(", "func", ",", "*", "this", ",", "getTargetRegisterInfo", "(", ")", ")", ";", "}", "</s>" ]

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

[ "R600" ]

[]

[ "<s>", "void", "flushPendingInstructions", "(", "MCStreamer", "&", "Out", ")", "override", "{", "if", "(", "!", "inImplicitITBlock", "(", ")", ")", "{", "assert", "(", "PendingConditionalInsts", ".", "size", "(", ")", "==", "0", ")", ";", "return", ";", "}", "MCInst", "ITInst", ";", "ITInst", ".", "setOpcode", "(", "ARM", "::", "t2IT", ")", ";", "ITInst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "ITState", ".", "Cond", ")", ")", ";", "ITInst", ".", "addOperand", "(", "MCOperand", "::", "createImm", "(", "ITState", ".", "Mask", ")", ")", ";", "Out", ".", "EmitInstruction", "(", "ITInst", ",", "getSTI", "(", ")", ")", ";", "assert", "(", "PendingConditionalInsts", ".", "size", "(", ")", "<=", "4", ")", ";", "for", "(", "const", "MCInst", "&", "Inst", ":", "PendingConditionalInsts", ")", "{", "Out", ".", "EmitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "}", "PendingConditionalInsts", ".", "clear", "(", ")", ";", "ITState", ".", "Mask", "=", "0", ";", "ITState", ".", "CurPosition", "=", "~", "0U", ";", "}", "</s>" ]

[ "Ensure", "that", "all", "previously", "parsed", "instructions", "have", "been", "emitted", "to", "the", "output", "streamer", ",", "if", "the", "target", "does", "not", "emit", "them", "immediately", "." ]

[ "ARM", "0", "ARM::t2IT", "4", "0", "0U" ]

[]

[ "<s>", "const", "char", "*", "TeeRISCTargetLowering", "::", "getTargetNodeName", "(", "unsigned", "Opcode", ")", "const", "{", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "0", ";", "case", "TeeRISC_ISD", "::", "RET", ":", "return", "\"TeeRISC_ISD::RET\"", ";", "}", "}", "</s>" ]

[ "getTargetNodeName", "-", "This", "method", "returns", "the", "name", "of", "a", "target", "specific" ]

[ "TeeRISC", "TeeRISC", "0", "TeeRISC_ISD::RET", "\"TeeRISC_ISD::RET\"" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"Z80 DAG->DAG Instruction Selection\"", ";", "}", "</s>" ]

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

[ "Z80", "\"Z80 DAG->DAG Instruction Selection\"" ]

[]