Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "const", "TPCSubtarget", "*", "TPCTargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "std", "::", "string", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetCPU", ";", "std", "::", "string", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ".", "str", "(", ")", ":", "TargetFS", ";", "return", "createSubtarget", "(", "CPU", ",", "FS", ")", ";", "}", "</s>" ]

[ "Virtual", "method", "implemented", "by", "subclasses", "that", "returns", "a", "reference", "to", "that", "target", "'s", "TargetSubtargetInfo-derived", "member", "variable", "." ]

[ "TPC", "TPC", "TPC", "\"target-cpu\"", "\"target-features\"" ]

[]

[ "<s>", "void", "MBlazeFrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "MBlazeInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "MBlazeInstrInfo", "*", ">", "(", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "MBlazeFunctionInfo", "*", "MBlazeFI", "=", "MF", ".", "getInfo", "<", "MBlazeFunctionInfo", ">", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "DebugLoc", "DL", "=", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ";", "CallingConv", "::", "ID", "CallConv", "=", "MF", ".", "getFunction", "(", ")", "->", "getCallingConv", "(", ")", ";", "bool", "requiresRA", "=", "CallConv", "==", "CallingConv", "::", "MBLAZE_INTR", ";", "determineFrameLayout", "(", "MF", ")", ";", "unsigned", "StackSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", "&&", "!", "MFI", "->", "adjustsStack", "(", ")", "&&", "!", "requiresRA", ")", "return", ";", "int", "FPOffset", "=", "MBlazeFI", "->", "getFPStackOffset", "(", ")", ";", "int", "RAOffset", "=", "MBlazeFI", "->", "getRAStackOffset", "(", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MBlaze", "::", "ADDIK", ")", ",", "MBlaze", "::", "R1", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addImm", "(", "-", "StackSize", ")", ";", "if", "(", "MFI", "->", "adjustsStack", "(", ")", "||", "requiresRA", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MBlaze", "::", "SWI", ")", ")", ".", "addReg", "(", "MBlaze", "::", "R15", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addImm", "(", "RAOffset", ")", ";", "}", "if", "(", "hasFP", "(", "MF", ")", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MBlaze", "::", "SWI", ")", ")", ".", "addReg", "(", "MBlaze", "::", "R19", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addImm", "(", "FPOffset", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "DL", ",", "TII", ".", "get", "(", "MBlaze", "::", "ADD", ")", ",", "MBlaze", "::", "R19", ")", ".", "addReg", "(", "MBlaze", "::", "R1", ")", ".", "addReg", "(", "MBlaze", "::", "R0", ")", ";", "}", "}", "</s>" ]

[ "emitProlog/emitEpilog", "-", "These", "methods", "insert", "prolog", "and", "epilog", "code", "into", "the", "function", "." ]

[ "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "MBlaze", "0", "MBlaze", "MBlaze", "MBlaze::ADDIK", "MBlaze::R1", "MBlaze::R1", "MBlaze::SWI", "MBlaze::R15", "MBlaze::R1", "MBlaze::SWI", "MBlaze::R19", "MBlaze::R1", "MBlaze::ADD", "MBlaze::R19", "MBlaze::R1", "MBlaze::R0" ]

[]

[ "<s>", "static", "unsigned", "char", "riscv_class_max_nregs", "(", "reg_class_t", "rclass", ",", "machine_mode", "mode", ")", "{", "if", "(", "reg_class_subset_p", "(", "rclass", ",", "FP_REGS", ")", ")", "return", "riscv_hard_regno_nregs", "(", "FP_REG_FIRST", ",", "mode", ")", ";", "if", "(", "reg_class_subset_p", "(", "rclass", ",", "GR_REGS", ")", ")", "return", "riscv_hard_regno_nregs", "(", "GP_REG_FIRST", ",", "mode", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Implement", "CLASS_MAX_NREGS", "." ]

[ "riscv", "0" ]

[]

[ "<s>", "std", "::", "pair", "<", "const", "TargetRegisterClass", "*", ",", "uint8_t", ">", "ARMTargetLowering", "::", "findRepresentativeClass", "(", "MVT", "VT", ")", "const", "{", "const", "TargetRegisterClass", "*", "RRC", "=", "nullptr", ";", "uint8_t", "Cost", "=", "1", ";", "switch", "(", "VT", ".", "SimpleTy", ")", "{", "default", ":", "return", "TargetLowering", "::", "findRepresentativeClass", "(", "VT", ")", ";", "case", "MVT", "::", "f32", ":", "case", "MVT", "::", "f64", ":", "case", "MVT", "::", "v8i8", ":", "case", "MVT", "::", "v4i16", ":", "case", "MVT", "::", "v2i32", ":", "case", "MVT", "::", "v1i64", ":", "case", "MVT", "::", "v2f32", ":", "RRC", "=", "&", "ARM", "::", "DPRRegClass", ";", "if", "(", "Subtarget", "->", "useNEONForSinglePrecisionFP", "(", ")", ")", "Cost", "=", "2", ";", "break", ";", "case", "MVT", "::", "v16i8", ":", "case", "MVT", "::", "v8i16", ":", "case", "MVT", "::", "v4i32", ":", "case", "MVT", "::", "v2i64", ":", "case", "MVT", "::", "v4f32", ":", "case", "MVT", "::", "v2f64", ":", "RRC", "=", "&", "ARM", "::", "DPRRegClass", ";", "Cost", "=", "2", ";", "break", ";", "case", "MVT", "::", "v4i64", ":", "RRC", "=", "&", "ARM", "::", "DPRRegClass", ";", "Cost", "=", "4", ";", "break", ";", "case", "MVT", "::", "v8i64", ":", "RRC", "=", "&", "ARM", "::", "DPRRegClass", ";", "Cost", "=", "8", ";", "break", ";", "}", "return", "std", "::", "make_pair", "(", "RRC", ",", "Cost", ")", ";", "}", "</s>" ]

[ "Return", "the", "largest", "legal", "super-reg", "register", "class", "of", "the", "register", "class", "for", "the", "specified", "type", "and", "its", "associated", "``", "cost", "''", "." ]

[ "ARM", "ARM", "1", "MVT::f32", "MVT::f64", "MVT::v8i8", "MVT::v4i16", "MVT::v2i32", "MVT::v1i64", "MVT::v2f32", "ARM::DPRRegClass", "2", "MVT::v16i8", "MVT::v8i16", "MVT::v4i32", "MVT::v2i64", "MVT::v4f32", "MVT::v2f64", "ARM::DPRRegClass", "2", "MVT::v4i64", "ARM::DPRRegClass", "4", "MVT::v8i64", "ARM::DPRRegClass", "8" ]

[]

[ "<s>", "bool", "HexagonInstrInfo", "::", "PredicateInstruction", "(", "MachineInstr", "&", "MI", ",", "ArrayRef", "<", "MachineOperand", ">", "Cond", ")", "const", "{", "if", "(", "Cond", ".", "empty", "(", ")", "||", "isNewValueJump", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", "||", "isEndLoopN", "(", "Cond", "[", "0", "]", ".", "getImm", "(", ")", ")", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nCannot predicate:\"", ";", "MI", ".", "dump", "(", ")", ";", ")", ";", "return", "false", ";", "}", "int", "Opc", "=", "MI", ".", "getOpcode", "(", ")", ";", "assert", "(", "isPredicable", "(", "MI", ")", "&&", "\"Expected predicable instruction\"", ")", ";", "bool", "invertJump", "=", "predOpcodeHasNot", "(", "Cond", ")", ";", "MachineBasicBlock", "&", "B", "=", "*", "MI", ".", "getParent", "(", ")", ";", "DebugLoc", "DL", "=", "MI", ".", "getDebugLoc", "(", ")", ";", "unsigned", "PredOpc", "=", "getCondOpcode", "(", "Opc", ",", "invertJump", ")", ";", "MachineInstrBuilder", "T", "=", "BuildMI", "(", "B", ",", "MI", ",", "DL", ",", "get", "(", "PredOpc", ")", ")", ";", "unsigned", "NOp", "=", "0", ",", "NumOps", "=", "MI", ".", "getNumOperands", "(", ")", ";", "while", "(", "NOp", "<", "NumOps", ")", "{", "MachineOperand", "&", "Op", "=", "MI", ".", "getOperand", "(", "NOp", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", "||", "!", "Op", ".", "isDef", "(", ")", "||", "Op", ".", "isImplicit", "(", ")", ")", "break", ";", "T", ".", "add", "(", "Op", ")", ";", "NOp", "++", ";", "}", "unsigned", "PredReg", ",", "PredRegPos", ",", "PredRegFlags", ";", "bool", "GotPredReg", "=", "getPredReg", "(", "Cond", ",", "PredReg", ",", "PredRegPos", ",", "PredRegFlags", ")", ";", "(", "void", ")", "GotPredReg", ";", "assert", "(", "GotPredReg", ")", ";", "T", ".", "addReg", "(", "PredReg", ",", "PredRegFlags", ")", ";", "while", "(", "NOp", "<", "NumOps", ")", "T", ".", "add", "(", "MI", ".", "getOperand", "(", "NOp", "++", ")", ")", ";", "MI", ".", "setDesc", "(", "get", "(", "PredOpc", ")", ")", ";", "while", "(", "unsigned", "n", "=", "MI", ".", "getNumOperands", "(", ")", ")", "MI", ".", "RemoveOperand", "(", "n", "-", "1", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "n", "=", "T", "->", "getNumOperands", "(", ")", ";", "i", "<", "n", ";", "++", "i", ")", "MI", ".", "addOperand", "(", "T", "->", "getOperand", "(", "i", ")", ")", ";", "MachineBasicBlock", "::", "instr_iterator", "TI", "=", "T", "->", "getIterator", "(", ")", ";", "B", ".", "erase", "(", "TI", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "B", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "MRI", ".", "clearKillFlags", "(", "PredReg", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Convert", "the", "instruction", "into", "a", "predicated", "instruction", "." ]

[ "Hexagon", "Hexagon", "0", "0", "\"\\nCannot predicate:\"", "\"Expected predicable instruction\"", "0", "1", "0" ]

[]

[ "<s>", "static", "bool", "cr16_legitimate_address_p", "(", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ",", "rtx", "addr", ",", "bool", "strict", ")", "{", "enum", "cr16_addrtype", "addrtype", ";", "struct", "cr16_address", "address", ";", "if", "(", "TARGET_DEBUG_ADDR", ")", "{", "fprintf", "(", "stderr", ",", "\"\\n======\\nTARGET_LEGITIMATE_ADDRESS_P, mode = %s, strict = %d\"", ",", "GET_MODE_NAME", "(", "mode", ")", ",", "strict", ")", ";", "debug_rtx", "(", "addr", ")", ";", "}", "addrtype", "=", "cr16_decompose_address", "(", "addr", ",", "&", "address", ",", "(", "TARGET_DEBUG_ADDR", "?", "1", ":", "0", ")", ",", "FALSE", ")", ";", "if", "(", "TARGET_DEBUG_ADDR", ")", "{", "const", "char", "*", "typestr", ";", "switch", "(", "addrtype", ")", "{", "case", "CR16_INVALID", ":", "typestr", "=", "\"invalid\"", ";", "break", ";", "case", "CR16_ABSOLUTE", ":", "typestr", "=", "\"absolute\"", ";", "break", ";", "case", "CR16_REG_REL", ":", "typestr", "=", "\"register relative\"", ";", "break", ";", "case", "CR16_REGP_REL", ":", "typestr", "=", "\"register pair relative\"", ";", "break", ";", "case", "CR16_INDEX_REGP_REL", ":", "typestr", "=", "\"index + register pair relative\"", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "fprintf", "(", "stderr", ",", "\"\\ncr16 address type: %s\\n\"", ",", "typestr", ")", ";", "}", "if", "(", "addrtype", "==", "CR16_INVALID", ")", "return", "FALSE", ";", "if", "(", "strict", ")", "{", "if", "(", "address", ".", "base", "&&", "!", "REGNO_MODE_OK_FOR_BASE_P", "(", "REGNO", "(", "address", ".", "base", ")", ",", "mode", ")", ")", "{", "if", "(", "TARGET_DEBUG_ADDR", ")", "fprintf", "(", "stderr", ",", "\"base register not strict\\n\"", ")", ";", "return", "FALSE", ";", "}", "if", "(", "address", ".", "index", "&&", "!", "REGNO_OK_FOR_INDEX_P", "(", "REGNO", "(", "address", ".", "index", ")", ")", ")", "{", "if", "(", "TARGET_DEBUG_ADDR", ")", "fprintf", "(", "stderr", ",", "\"index register not strict\\n\"", ")", ";", "return", "FALSE", ";", "}", "}", "if", "(", "flag_pic", ")", "{", "if", "(", "addrtype", "==", "CR16_REG_REL", "||", "addrtype", "==", "CR16_REGP_REL", ")", "return", "TRUE", ";", "else", "return", "FALSE", ";", "}", "return", "TRUE", ";", "}", "</s>" ]

[ "Implementation", "of", "TARGET_LEGITIMATE_ADDRESS_P", "." ]

[ "cr16", "\"\\n======\\nTARGET_LEGITIMATE_ADDRESS_P, mode = %s, strict = %d\"", "1", "0", "\"invalid\"", "\"absolute\"", "\"register relative\"", "\"register pair relative\"", "\"index + register pair relative\"", "\"\\ncr16 address type: %s\\n\"", "\"base register not strict\\n\"", "\"index register not strict\\n\"" ]

[]

[ "<s>", "std", "::", "pair", "<", "int64_t", ",", "int64_t", ">", "SIInstrInfo", "::", "splitFlatOffset", "(", "int64_t", "COffsetVal", ",", "unsigned", "AddrSpace", ",", "bool", "IsSigned", ")", "const", "{", "int64_t", "RemainderOffset", "=", "COffsetVal", ";", "int64_t", "ImmField", "=", "0", ";", "const", "unsigned", "NumBits", "=", "AMDGPU", "::", "getNumFlatOffsetBits", "(", "ST", ",", "IsSigned", ")", ";", "if", "(", "IsSigned", ")", "{", "int64_t", "D", "=", "1LL", "<<", "(", "NumBits", "-", "1", ")", ";", "RemainderOffset", "=", "(", "COffsetVal", "/", "D", ")", "*", "D", ";", "ImmField", "=", "COffsetVal", "-", "RemainderOffset", ";", "}", "else", "if", "(", "COffsetVal", ">=", "0", ")", "{", "ImmField", "=", "COffsetVal", "&", "maskTrailingOnes", "<", "uint64_t", ">", "(", "NumBits", ")", ";", "RemainderOffset", "=", "COffsetVal", "-", "ImmField", ";", "}", "assert", "(", "isLegalFLATOffset", "(", "ImmField", ",", "AddrSpace", ",", "IsSigned", ")", ")", ";", "assert", "(", "RemainderOffset", "+", "ImmField", "==", "COffsetVal", ")", ";", "return", "{", "ImmField", ",", "RemainderOffset", "}", ";", "}", "</s>" ]

[ "Split", "COffsetVal", "into", "{", "immediate", "offset", "field", ",", "remainder", "offset", "}", "values", "." ]

[ "AMDGPU", "SI", "0", "AMDGPU::getNumFlatOffsetBits", "1LL", "1", "0" ]

[]

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

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

[ "PowerPC" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "Register", "&", "SrcReg", ",", "Register", "&", "SrcReg2", ",", "int", "&", "CmpMask", ",", "int", "&", "CmpValue", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "CMP64ri32", ":", "case", "X86", "::", "CMP64ri8", ":", "case", "X86", "::", "CMP32ri", ":", "case", "X86", "::", "CMP32ri8", ":", "case", "X86", "::", "CMP16ri", ":", "case", "X86", "::", "CMP16ri8", ":", "case", "X86", "::", "CMP8ri", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", ")", "{", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "}", "else", "{", "CmpMask", "=", "CmpValue", "=", "0", ";", "}", "return", "true", ";", "case", "X86", "::", "SUB64rm", ":", "case", "X86", "::", "SUB32rm", ":", "case", "X86", "::", "SUB16rm", ":", "case", "X86", "::", "SUB8rm", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "X86", "::", "SUB64rr", ":", "case", "X86", "::", "SUB32rr", ":", "case", "X86", "::", "SUB16rr", ":", "case", "X86", "::", "SUB8rr", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "X86", "::", "SUB64ri32", ":", "case", "X86", "::", "SUB64ri8", ":", "case", "X86", "::", "SUB32ri", ":", "case", "X86", "::", "SUB32ri8", ":", "case", "X86", "::", "SUB16ri", ":", "case", "X86", "::", "SUB16ri8", ":", "case", "X86", "::", "SUB8ri", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "if", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "{", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "}", "else", "{", "CmpMask", "=", "CmpValue", "=", "0", ";", "}", "return", "true", ";", "case", "X86", "::", "CMP64rr", ":", "case", "X86", "::", "CMP32rr", ":", "case", "X86", "::", "CMP16rr", ":", "case", "X86", "::", "CMP8rr", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "X86", "::", "TEST8rr", ":", "case", "X86", "::", "TEST16rr", ":", "case", "X86", "::", "TEST32rr", ":", "case", "X86", "::", "TEST64rr", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "!=", "SrcReg", ")", "return", "false", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeCompare", "-", "For", "a", "comparison", "instruction", ",", "return", "the", "source", "registers", "in", "SrcReg", "and", "SrcReg2", "if", "having", "two", "register", "operands", ",", "and", "the", "value", "it", "compares", "against", "in", "CmpValue", "." ]

[ "X86", "X86", "X86::CMP64ri32", "X86::CMP64ri8", "X86::CMP32ri", "X86::CMP32ri8", "X86::CMP16ri", "X86::CMP16ri8", "X86::CMP8ri", "0", "0", "1", "0", "1", "0", "X86::SUB64rm", "X86::SUB32rm", "X86::SUB16rm", "X86::SUB8rm", "1", "0", "0", "0", "X86::SUB64rr", "X86::SUB32rr", "X86::SUB16rr", "X86::SUB8rr", "1", "2", "0", "0", "X86::SUB64ri32", "X86::SUB64ri8", "X86::SUB32ri", "X86::SUB32ri8", "X86::SUB16ri", "X86::SUB16ri8", "X86::SUB8ri", "1", "0", "2", "0", "2", "0", "X86::CMP64rr", "X86::CMP32rr", "X86::CMP16rr", "X86::CMP8rr", "0", "1", "0", "0", "X86::TEST8rr", "X86::TEST16rr", "X86::TEST32rr", "X86::TEST64rr", "0", "1", "0", "0", "0" ]

[]

[ "<s>", "static", "unsigned", "int", "h8300_classify_operand", "(", "rtx", "op", ",", "int", "size", ",", "enum", "h8300_operand_class", "*", "class", ")", "{", "enum", "h8300_operand_class", "dummy", ";", "if", "(", "class", "==", "0", ")", "class", "=", "&", "dummy", ";", "if", "(", "CONSTANT_P", "(", "op", ")", ")", "{", "*", "class", "=", "H8OP_IMMEDIATE", ";", "if", "(", "size", "==", "1", ")", "return", "0", ";", "if", "(", "TARGET_H8300SX", "&&", "size", "==", "4", "&&", "GET_CODE", "(", "op", ")", "==", "CONST_INT", "&&", "IN_RANGE", "(", "INTVAL", "(", "op", ")", ",", "0", ",", "0xffff", ")", ")", "return", "2", ";", "return", "size", ";", "}", "else", "if", "(", "GET_CODE", "(", "op", ")", "==", "MEM", ")", "{", "op", "=", "XEXP", "(", "op", ",", "0", ")", ";", "if", "(", "CONSTANT_P", "(", "op", ")", ")", "{", "*", "class", "=", "H8OP_MEM_ABSOLUTE", ";", "return", "h8300_constant_length", "(", "op", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "op", ")", "==", "PLUS", "&&", "CONSTANT_P", "(", "XEXP", "(", "op", ",", "1", ")", ")", ")", "{", "*", "class", "=", "H8OP_MEM_COMPLEX", ";", "return", "h8300_displacement_length", "(", "op", ",", "size", ")", ";", "}", "else", "if", "(", "GET_RTX_CLASS", "(", "GET_CODE", "(", "op", ")", ")", "==", "RTX_AUTOINC", ")", "{", "*", "class", "=", "H8OP_MEM_COMPLEX", ";", "return", "0", ";", "}", "else", "if", "(", "register_operand", "(", "op", ",", "VOIDmode", ")", ")", "{", "*", "class", "=", "H8OP_MEM_BASE", ";", "return", "0", ";", "}", "}", "gcc_assert", "(", "register_operand", "(", "op", ",", "VOIDmode", ")", ")", ";", "*", "class", "=", "H8OP_REGISTER", ";", "return", "0", ";", "}", "</s>" ]

[ "Store", "the", "class", "of", "operand", "OP", "in", "*", "CLASS", "and", "return", "the", "length", "of", "any", "extra", "operand", "fields", ".", "SIZE", "is", "the", "number", "of", "bytes", "in", "OP", ".", "CLASS", "can", "be", "null", "if", "only", "the", "length", "is", "needed", "." ]

[ "h8300", "0", "1", "0", "4", "0", "0xffff", "2", "0", "1", "0", "0", "0" ]

[]

[ "<s>", "Register", "SparcTargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "LLT", "VT", ",", "const", "MachineFunction", "&", "MF", ")", "const", "{", "Register", "Reg", "=", "StringSwitch", "<", "Register", ">", "(", "RegName", ")", ".", "Case", "(", "\"i0\"", ",", "SP", "::", "I0", ")", ".", "Case", "(", "\"i1\"", ",", "SP", "::", "I1", ")", ".", "Case", "(", "\"i2\"", ",", "SP", "::", "I2", ")", ".", "Case", "(", "\"i3\"", ",", "SP", "::", "I3", ")", ".", "Case", "(", "\"i4\"", ",", "SP", "::", "I4", ")", ".", "Case", "(", "\"i5\"", ",", "SP", "::", "I5", ")", ".", "Case", "(", "\"i6\"", ",", "SP", "::", "I6", ")", ".", "Case", "(", "\"i7\"", ",", "SP", "::", "I7", ")", ".", "Case", "(", "\"o0\"", ",", "SP", "::", "O0", ")", ".", "Case", "(", "\"o1\"", ",", "SP", "::", "O1", ")", ".", "Case", "(", "\"o2\"", ",", "SP", "::", "O2", ")", ".", "Case", "(", "\"o3\"", ",", "SP", "::", "O3", ")", ".", "Case", "(", "\"o4\"", ",", "SP", "::", "O4", ")", ".", "Case", "(", "\"o5\"", ",", "SP", "::", "O5", ")", ".", "Case", "(", "\"o6\"", ",", "SP", "::", "O6", ")", ".", "Case", "(", "\"o7\"", ",", "SP", "::", "O7", ")", ".", "Case", "(", "\"l0\"", ",", "SP", "::", "L0", ")", ".", "Case", "(", "\"l1\"", ",", "SP", "::", "L1", ")", ".", "Case", "(", "\"l2\"", ",", "SP", "::", "L2", ")", ".", "Case", "(", "\"l3\"", ",", "SP", "::", "L3", ")", ".", "Case", "(", "\"l4\"", ",", "SP", "::", "L4", ")", ".", "Case", "(", "\"l5\"", ",", "SP", "::", "L5", ")", ".", "Case", "(", "\"l6\"", ",", "SP", "::", "L6", ")", ".", "Case", "(", "\"l7\"", ",", "SP", "::", "L7", ")", ".", "Case", "(", "\"g0\"", ",", "SP", "::", "G0", ")", ".", "Case", "(", "\"g1\"", ",", "SP", "::", "G1", ")", ".", "Case", "(", "\"g2\"", ",", "SP", "::", "G2", ")", ".", "Case", "(", "\"g3\"", ",", "SP", "::", "G3", ")", ".", "Case", "(", "\"g4\"", ",", "SP", "::", "G4", ")", ".", "Case", "(", "\"g5\"", ",", "SP", "::", "G5", ")", ".", "Case", "(", "\"g6\"", ",", "SP", "::", "G6", ")", ".", "Case", "(", "\"g7\"", ",", "SP", "::", "G7", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "\"Invalid register name global variable\"", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "\"i0\"", "SP::I0", "\"i1\"", "SP::I1", "\"i2\"", "SP::I2", "\"i3\"", "SP::I3", "\"i4\"", "SP::I4", "\"i5\"", "SP::I5", "\"i6\"", "SP::I6", "\"i7\"", "SP::I7", "\"o0\"", "SP::O0", "\"o1\"", "SP::O1", "\"o2\"", "SP::O2", "\"o3\"", "SP::O3", "\"o4\"", "SP::O4", "\"o5\"", "SP::O5", "\"o6\"", "SP::O6", "\"o7\"", "SP::O7", "\"l0\"", "SP::L0", "\"l1\"", "SP::L1", "\"l2\"", "SP::L2", "\"l3\"", "SP::L3", "\"l4\"", "SP::L4", "\"l5\"", "SP::L5", "\"l6\"", "SP::L6", "\"l7\"", "SP::L7", "\"g0\"", "SP::G0", "\"g1\"", "SP::G1", "\"g2\"", "SP::G2", "\"g3\"", "SP::G3", "\"g4\"", "SP::G4", "\"g5\"", "SP::G5", "\"g6\"", "SP::G6", "\"g7\"", "SP::G7", "0", "\"Invalid register name global variable\"" ]

[]

[ "<s>", "static", "int", "supersparc_adjust_cost", "(", "rtx_insn", "*", "insn", ",", "rtx", "link", ",", "rtx_insn", "*", "dep_insn", ",", "int", "cost", ")", "{", "enum", "attr_type", "insn_type", ";", "if", "(", "!", "recog_memoized", "(", "insn", ")", ")", "return", "0", ";", "insn_type", "=", "get_attr_type", "(", "insn", ")", ";", "if", "(", "REG_NOTE_KIND", "(", "link", ")", "==", "0", ")", "{", "if", "(", "insn_type", "==", "TYPE_LOAD", "||", "insn_type", "==", "TYPE_FPLOAD", ")", "return", "cost", "+", "3", ";", "if", "(", "insn_type", "==", "TYPE_STORE", "||", "insn_type", "==", "TYPE_FPSTORE", ")", "{", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "rtx", "dep_pat", "=", "PATTERN", "(", "dep_insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "!=", "SET", "||", "GET_CODE", "(", "dep_pat", ")", "!=", "SET", ")", "return", "cost", ";", "if", "(", "rtx_equal_p", "(", "SET_DEST", "(", "dep_pat", ")", ",", "SET_SRC", "(", "pat", ")", ")", ")", "return", "cost", ";", "return", "cost", "+", "3", ";", "}", "if", "(", "insn_type", "==", "TYPE_SHIFT", ")", "return", "cost", "+", "3", ";", "}", "else", "{", "if", "(", "insn_type", "==", "TYPE_IALU", "||", "insn_type", "==", "TYPE_SHIFT", ")", "return", "0", ";", "}", "return", "cost", ";", "}", "</s>" ]

[ "Adjust", "the", "cost", "of", "a", "scheduling", "dependency", ".", "Return", "the", "new", "cost", "of", "a", "dependency", "LINK", "or", "INSN", "on", "DEP_INSN", ".", "COST", "is", "the", "current", "cost", "." ]

[ "sparc", "0", "0", "3", "3", "3", "0" ]

[]

[ "<s>", "void", "VideocoreInstPrinter", "::", "printInst", "(", "const", "MCInst", "*", "MI", ",", "raw_ostream", "&", "OS", ",", "StringRef", "Annot", ")", "{", "printInstruction", "(", "MI", ",", "OS", ")", ";", "printAnnotation", "(", "OS", ",", "Annot", ")", ";", "}", "</s>" ]

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

[ "Videocore", "Videocore" ]

[]

[ "<s>", "XCoreSubtarget", "::", "XCoreSubtarget", "(", "const", "Triple", "&", "TT", ",", "const", "std", "::", "string", "&", "CPU", ",", "const", "std", "::", "string", "&", "FS", ",", "const", "TargetMachine", "&", "TM", ")", ":", "XCoreGenSubtargetInfo", "(", "TT", ",", "CPU", ",", "CPU", ",", "FS", ")", ",", "InstrInfo", "(", ")", ",", "FrameLowering", "(", "*", "this", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", ",", "TSInfo", "(", ")", "{", "}", "</s>" ]

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

[ "XCore", "XCore", "XCore", "XCore" ]

[]

[ "<s>", "void", "AMDGPUMCInstLower", "::", "lower", "(", "const", "MachineInstr", "*", "MI", ",", "MCInst", "&", "OutMI", ")", "const", "{", "OutMI", ".", "setOpcode", "(", "MI", "->", "getOpcode", "(", ")", ")", ";", "for", "(", "const", "MachineOperand", "&", "MO", ":", "MI", "->", "explicit_operands", "(", ")", ")", "{", "MCOperand", "MCOp", ";", "switch", "(", "MO", ".", "getType", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"unknown operand type\"", ")", ";", "case", "MachineOperand", "::", "MO_FPImmediate", ":", "{", "const", "APFloat", "&", "FloatValue", "=", "MO", ".", "getFPImm", "(", ")", "->", "getValueAPF", "(", ")", ";", "assert", "(", "&", "FloatValue", ".", "getSemantics", "(", ")", "==", "&", "APFloat", "::", "IEEEsingle", "&&", "\"Only floating point immediates are supported at the moment.\"", ")", ";", "MCOp", "=", "MCOperand", "::", "CreateFPImm", "(", "FloatValue", ".", "convertToFloat", "(", ")", ")", ";", "break", ";", "}", "case", "MachineOperand", "::", "MO_Immediate", ":", "MCOp", "=", "MCOperand", "::", "CreateImm", "(", "MO", ".", "getImm", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_Register", ":", "MCOp", "=", "MCOperand", "::", "CreateReg", "(", "MO", ".", "getReg", "(", ")", ")", ";", "break", ";", "case", "MachineOperand", "::", "MO_MachineBasicBlock", ":", "MCOp", "=", "MCOperand", "::", "CreateExpr", "(", "MCSymbolRefExpr", "::", "Create", "(", "MO", ".", "getMBB", "(", ")", "->", "getSymbol", "(", ")", ",", "Ctx", ")", ")", ";", "}", "OutMI", ".", "addOperand", "(", "MCOp", ")", ";", "}", "}", "</s>" ]

[ "The", "instruction", "is", "lowered", "." ]

[ "R600", "\"unknown operand type\"", "\"Only floating point immediates are supported at the moment.\"" ]

[]

[ "<s>", "virtual", "bool", "isProfitableToDupForIfCvt", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "NumCycles", ",", "const", "BranchProbability", "&", "Probability", ")", "const", "{", "const", "MCInstrDesc", "&", "MCID", "=", "prior", "(", "MBB", ".", "end", "(", ")", ")", "->", "getDesc", "(", ")", ";", "if", "(", "MCID", ".", "isReturn", "(", ")", "||", "MCID", ".", "isCall", "(", ")", ")", "return", "false", ";", "return", "NumCycles", "<=", "4", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "'s", "profitable", "for", "if-converter", "to", "duplicate", "instructions", "of", "specified", "accumulated", "instruction", "latencies", "in", "the", "specified", "MBB", "to", "enable", "if-conversion", "." ]

[ "Patmos", "4" ]

[]

[ "<s>", "unsigned", "ARMBaseInstrInfo", "::", "isLoadFromStackSlot", "(", "const", "MachineInstr", "*", "MI", ",", "int", "&", "FrameIndex", ")", "const", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ARM", "::", "LDRrs", ":", "case", "ARM", "::", "t2LDRs", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", "==", "0", "&&", "MI", "->", "getOperand", "(", "3", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "LDRi12", ":", "case", "ARM", "::", "t2LDRi12", ":", "case", "ARM", "::", "tLDRspi", ":", "case", "ARM", "::", "VLDRD", ":", "case", "ARM", "::", "VLDRS", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", "&&", "MI", "->", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VLD1q64", ":", "case", "ARM", "::", "VLD1d64TPseudo", ":", "case", "ARM", "::", "VLD1d64QPseudo", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "0", ")", "{", "FrameIndex", "=", "MI", "->", "getOperand", "(", "1", ")", ".", "getIndex", "(", ")", ";", "return", "MI", "->", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "}", "break", ";", "case", "ARM", "::", "VLDMQIA", ":", "if", "(", "MI", "->", "getOperand", "(", "1", ")", ".", "isFI", "(", ")", "&&", "MI", "->", "getOperand", "(", "0", ")", ".", "getSubReg", "(", ")", "==", "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", "." ]

[ "ARM", "ARM", "ARM::LDRrs", "ARM::t2LDRs", "1", "2", "3", "2", "0", "3", "0", "1", "0", "ARM::LDRi12", "ARM::t2LDRi12", "ARM::tLDRspi", "ARM::VLDRD", "ARM::VLDRS", "1", "2", "2", "0", "1", "0", "ARM::VLD1q64", "ARM::VLD1d64TPseudo", "ARM::VLD1d64QPseudo", "1", "0", "0", "1", "0", "ARM::VLDMQIA", "1", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "bool", "isImm", "(", "int64_t", "MinValue", ",", "int64_t", "MaxValue", ")", "const", "{", "return", "Kind", "==", "KindImm", "&&", "inRange", "(", "Imm", ",", "MinValue", ",", "MaxValue", ")", ";", "}", "</s>" ]

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

[ "Videocore" ]

[]

[ "<s>", "static", "const", "char", "*", "mips_sync_insn2_template", "(", "enum", "attr_sync_insn2", "type", ")", "{", "switch", "(", "type", ")", "{", "case", "SYNC_INSN2_NOP", ":", "gcc_unreachable", "(", ")", ";", "case", "SYNC_INSN2_AND", ":", "return", "\"and\\t%0,%1,%z2\"", ";", "case", "SYNC_INSN2_XOR", ":", "return", "\"xor\\t%0,%1,%z2\"", ";", "case", "SYNC_INSN2_NOT", ":", "return", "\"nor\\t%0,%1,%.\"", ";", "}", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "asm", "template", "associated", "with", "sync_insn2", "value", "TYPE", "." ]

[ "mips", "\"and\\t%0,%1,%z2\"", "\"xor\\t%0,%1,%z2\"", "\"nor\\t%0,%1,%.\"" ]

[]

[ "<s>", "unsigned", "assignCustomValue", "(", "const", "ARMCallLowering", "::", "ArgInfo", "&", "Arg", ",", "ArrayRef", "<", "CCValAssign", ">", "VAs", ")", "override", "{", "CCValAssign", "VA", "=", "VAs", "[", "0", "]", ";", "assert", "(", "VA", ".", "needsCustom", "(", ")", "&&", "\"Value doesn't need custom handling\"", ")", ";", "assert", "(", "VA", ".", "getValVT", "(", ")", "==", "MVT", "::", "f64", "&&", "\"Unsupported type\"", ")", ";", "CCValAssign", "NextVA", "=", "VAs", "[", "1", "]", ";", "assert", "(", "NextVA", ".", "needsCustom", "(", ")", "&&", "\"Value doesn't need custom handling\"", ")", ";", "assert", "(", "NextVA", ".", "getValVT", "(", ")", "==", "MVT", "::", "f64", "&&", "\"Unsupported type\"", ")", ";", "assert", "(", "VA", ".", "getValNo", "(", ")", "==", "NextVA", ".", "getValNo", "(", ")", "&&", "\"Values belong to different arguments\"", ")", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Value should be in reg\"", ")", ";", "assert", "(", "NextVA", ".", "isRegLoc", "(", ")", "&&", "\"Value should be in reg\"", ")", ";", "unsigned", "NewRegs", "[", "]", "=", "{", "MRI", ".", "createGenericVirtualRegister", "(", "LLT", "::", "scalar", "(", "32", ")", ")", ",", "MRI", ".", "createGenericVirtualRegister", "(", "LLT", "::", "scalar", "(", "32", ")", ")", "}", ";", "assignValueToReg", "(", "NewRegs", "[", "0", "]", ",", "VA", ".", "getLocReg", "(", ")", ",", "VA", ")", ";", "assignValueToReg", "(", "NewRegs", "[", "1", "]", ",", "NextVA", ".", "getLocReg", "(", ")", ",", "NextVA", ")", ";", "bool", "IsLittle", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ".", "isLittle", "(", ")", ";", "if", "(", "!", "IsLittle", ")", "std", "::", "swap", "(", "NewRegs", "[", "0", "]", ",", "NewRegs", "[", "1", "]", ")", ";", "MIRBuilder", ".", "buildMerge", "(", "Arg", ".", "Reg", ",", "NewRegs", ")", ";", "return", "1", ";", "}", "</s>" ]

[ "Handle", "custom", "values", ",", "which", "may", "be", "passed", "into", "one", "or", "more", "of", "VAs", "." ]

[ "ARM", "ARM", "0", "\"Value doesn't need custom handling\"", "MVT::f64", "\"Unsupported type\"", "1", "\"Value doesn't need custom handling\"", "MVT::f64", "\"Unsupported type\"", "\"Values belong to different arguments\"", "\"Value should be in reg\"", "\"Value should be in reg\"", "32", "32", "0", "1", "ARM", "0", "1", "1" ]

[]

[ "<s>", "void", "GCNSubtarget", "::", "adjustSchedDependency", "(", "SUnit", "*", "Def", ",", "int", "DefOpIdx", ",", "SUnit", "*", "Use", ",", "int", "UseOpIdx", ",", "SDep", "&", "Dep", ")", "const", "{", "if", "(", "Dep", ".", "getKind", "(", ")", "!=", "SDep", "::", "Kind", "::", "Data", "||", "!", "Dep", ".", "getReg", "(", ")", "||", "!", "Def", "->", "isInstr", "(", ")", "||", "!", "Use", "->", "isInstr", "(", ")", ")", "return", ";", "MachineInstr", "*", "DefI", "=", "Def", "->", "getInstr", "(", ")", ";", "MachineInstr", "*", "UseI", "=", "Use", "->", "getInstr", "(", ")", ";", "if", "(", "DefI", "->", "isBundle", "(", ")", ")", "{", "const", "SIRegisterInfo", "*", "TRI", "=", "getRegisterInfo", "(", ")", ";", "auto", "Reg", "=", "Dep", ".", "getReg", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "I", "(", "DefI", "->", "getIterator", "(", ")", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "(", "DefI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ")", ";", "unsigned", "Lat", "=", "0", ";", "for", "(", "++", "I", ";", "I", "!=", "E", "&&", "I", "->", "isBundledWithPred", "(", ")", ";", "++", "I", ")", "{", "if", "(", "I", "->", "modifiesRegister", "(", "Reg", ",", "TRI", ")", ")", "Lat", "=", "InstrInfo", ".", "getInstrLatency", "(", "getInstrItineraryData", "(", ")", ",", "*", "I", ")", ";", "else", "if", "(", "Lat", ")", "--", "Lat", ";", "}", "Dep", ".", "setLatency", "(", "Lat", ")", ";", "}", "else", "if", "(", "UseI", "->", "isBundle", "(", ")", ")", "{", "const", "SIRegisterInfo", "*", "TRI", "=", "getRegisterInfo", "(", ")", ";", "auto", "Reg", "=", "Dep", ".", "getReg", "(", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "I", "(", "UseI", "->", "getIterator", "(", ")", ")", ";", "MachineBasicBlock", "::", "const_instr_iterator", "E", "(", "UseI", "->", "getParent", "(", ")", "->", "instr_end", "(", ")", ")", ";", "unsigned", "Lat", "=", "InstrInfo", ".", "getInstrLatency", "(", "getInstrItineraryData", "(", ")", ",", "*", "DefI", ")", ";", "for", "(", "++", "I", ";", "I", "!=", "E", "&&", "I", "->", "isBundledWithPred", "(", ")", "&&", "Lat", ";", "++", "I", ")", "{", "if", "(", "I", "->", "readsRegister", "(", "Reg", ",", "TRI", ")", ")", "break", ";", "--", "Lat", ";", "}", "Dep", ".", "setLatency", "(", "Lat", ")", ";", "}", "}", "</s>" ]

[ "Perform", "target", "specific", "adjustments", "to", "the", "latency", "of", "a", "schedule", "dependency", "." ]

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

[]

[ "<s>", "void", "MipsPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "addPass", "(", "createMipsOptimizePICCallPass", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "void", "PPCAIXAsmPrinter", "::", "emitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "switch", "(", "MI", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "PPC", "::", "BL8", ":", "case", "PPC", "::", "BL", ":", "case", "PPC", "::", "BL8_NOP", ":", "case", "PPC", "::", "BL_NOP", ":", "{", "const", "MachineOperand", "&", "MO", "=", "MI", "->", "getOperand", "(", "0", ")", ";", "if", "(", "MO", ".", "isSymbol", "(", ")", ")", "{", "MCSymbolXCOFF", "*", "S", "=", "cast", "<", "MCSymbolXCOFF", ">", "(", "OutContext", ".", "getOrCreateSymbol", "(", "MO", ".", "getSymbolName", "(", ")", ")", ")", ";", "if", "(", "!", "S", "->", "hasRepresentedCsectSet", "(", ")", ")", "{", "MCSectionXCOFF", "*", "Sec", "=", "OutContext", ".", "getXCOFFSection", "(", "S", "->", "getName", "(", ")", ",", "XCOFF", "::", "XMC_PR", ",", "XCOFF", "::", "XTY_ER", ",", "XCOFF", "::", "C_EXT", ",", "SectionKind", "::", "getMetadata", "(", ")", ")", ";", "S", "->", "setRepresentedCsect", "(", "Sec", ")", ";", "}", "ExtSymSDNodeSymbols", ".", "insert", "(", "S", ")", ";", "}", "}", "break", ";", "case", "PPC", "::", "BL_TLS", ":", "case", "PPC", "::", "BL8_TLS", ":", "case", "PPC", "::", "BL8_TLS_", ":", "case", "PPC", "::", "BL8_NOP_TLS", ":", "report_fatal_error", "(", "\"TLS call not yet implemented\"", ")", ";", "case", "PPC", "::", "TAILB", ":", "case", "PPC", "::", "TAILB8", ":", "case", "PPC", "::", "TAILBA", ":", "case", "PPC", "::", "TAILBA8", ":", "case", "PPC", "::", "TAILBCTR", ":", "case", "PPC", "::", "TAILBCTR8", ":", "if", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "isSymbol", "(", ")", ")", "report_fatal_error", "(", "\"Tail call for extern symbol not yet supported.\"", ")", ";", "break", ";", "}", "return", "PPCAsmPrinter", "::", "emitInstruction", "(", "MI", ")", ";", "}", "</s>" ]

[ "Targets", "should", "implement", "this", "to", "emit", "instructions", "." ]

[ "PowerPC", "PPC", "PPC::BL8", "PPC::BL", "PPC::BL8_NOP", "PPC::BL_NOP", "0", "PPC::BL_TLS", "PPC::BL8_TLS", "PPC::BL8_TLS_", "PPC::BL8_NOP_TLS", "\"TLS call not yet implemented\"", "PPC::TAILB", "PPC::TAILB8", "PPC::TAILBA", "PPC::TAILBA8", "PPC::TAILBCTR", "PPC::TAILBCTR8", "0", "\"Tail call for extern symbol not yet supported.\"", "PPC" ]

[]

[ "<s>", "void", "PPCFrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "const", "PPCInstrInfo", "&", "TII", "=", "*", "static_cast", "<", "const", "PPCInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "if", "(", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "GuaranteedTailCallOpt", "&&", "I", "->", "getOpcode", "(", ")", "==", "PPC", "::", "ADJCALLSTACKUP", ")", "{", "if", "(", "int", "CalleeAmt", "=", "I", "->", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ")", "{", "bool", "is64Bit", "=", "Subtarget", ".", "isPPC64", "(", ")", ";", "CalleeAmt", "*=", "-", "1", ";", "unsigned", "StackReg", "=", "is64Bit", "?", "PPC", "::", "X1", ":", "PPC", "::", "R1", ";", "unsigned", "TmpReg", "=", "is64Bit", "?", "PPC", "::", "X0", ":", "PPC", "::", "R0", ";", "unsigned", "ADDIInstr", "=", "is64Bit", "?", "PPC", "::", "ADDI8", ":", "PPC", "::", "ADDI", ";", "unsigned", "ADDInstr", "=", "is64Bit", "?", "PPC", "::", "ADD8", ":", "PPC", "::", "ADD4", ";", "unsigned", "LISInstr", "=", "is64Bit", "?", "PPC", "::", "LIS8", ":", "PPC", "::", "LIS", ";", "unsigned", "ORIInstr", "=", "is64Bit", "?", "PPC", "::", "ORI8", ":", "PPC", "::", "ORI", ";", "MachineInstr", "*", "MI", "=", "I", ";", "DebugLoc", "dl", "=", "MI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "isInt", "<", "16", ">", "(", "CalleeAmt", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "TII", ".", "get", "(", "ADDIInstr", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "CalleeAmt", ")", ";", "}", "else", "{", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "I", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "LISInstr", ")", ",", "TmpReg", ")", ".", "addImm", "(", "CalleeAmt", ">>", "16", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ORIInstr", ")", ",", "TmpReg", ")", ".", "addReg", "(", "TmpReg", ",", "RegState", "::", "Kill", ")", ".", "addImm", "(", "CalleeAmt", "&", "0xFFFF", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ADDInstr", ")", ",", "StackReg", ")", ".", "addReg", "(", "StackReg", ",", "RegState", "::", "Kill", ")", ".", "addReg", "(", "TmpReg", ")", ";", "}", "}", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

[ "This", "method", "is", "called", "during", "prolog/epilog", "code", "insertion", "to", "eliminate", "call", "frame", "setup", "and", "destroy", "pseudo", "instructions", "(", "but", "only", "if", "the", "Target", "is", "using", "them", ")", "." ]

[ "PowerPC", "PPC", "PPC", "PPC", "PPC::ADJCALLSTACKUP", "1", "PPC", "1", "PPC::X1", "PPC::R1", "PPC::X0", "PPC::R0", "PPC::ADDI8", "PPC::ADDI", "PPC::ADD8", "PPC::ADD4", "PPC::LIS8", "PPC::LIS", "PPC::ORI8", "PPC::ORI", "16", "16", "0xFFFF" ]

[]

[ "<s>", "bool", "MipsSEFrameLowering", "::", "hasReservedCallFrame", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "isInt", "<", "16", ">", "(", "MFI", ".", "getMaxCallFrameSize", "(", ")", "+", "getStackAlignment", "(", ")", ")", "&&", "!", "MFI", ".", "hasVarSizedObjects", "(", ")", ";", "}", "</s>" ]

[ "hasReservedCallFrame", "-", "Under", "normal", "circumstances", ",", "when", "a", "frame", "pointer", "is", "not", "required", ",", "we", "reserve", "argument", "space", "for", "call", "sites", "in", "the", "function", "immediately", "on", "entry", "to", "the", "current", "function", "." ]

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

[]

[ "<s>", "void", "arm_reset_previous_fndecl", "(", "void", ")", "{", "arm_previous_fndecl", "=", "NULL_TREE", ";", "}", "</s>" ]

[ "Invalidate", "arm_previous_fndecl", "." ]

[ "arm" ]

[]

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

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

[ "AArch64", "\"AArch64PostLegalizerCombiner\"" ]

[]

[ "<s>", "static", "bool", "mem_ok_for_ldd_std", "(", "rtx", "mem", ",", "rtx", "*", "base", ",", "rtx", "*", "offset", ")", "{", "rtx", "addr", ";", "gcc_assert", "(", "base", "!=", "NULL", "&&", "offset", "!=", "NULL", ")", ";", "if", "(", "side_effects_p", "(", "mem", ")", ")", "return", "false", ";", "if", "(", "GET_CODE", "(", "mem", ")", "==", "SUBREG", ")", "return", "false", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "*", "offset", "=", "const0_rtx", ";", "addr", "=", "XEXP", "(", "mem", ",", "0", ")", ";", "if", "(", "!", "arc_legitimate_address_p", "(", "DImode", ",", "addr", ",", "reload_in_progress", "||", "reload_completed", ")", ")", "return", "false", ";", "if", "(", "REG_P", "(", "addr", ")", ")", "{", "*", "base", "=", "addr", ";", "return", "true", ";", "}", "else", "if", "(", "GET_CODE", "(", "addr", ")", "==", "PLUS", "||", "GET_CODE", "(", "addr", ")", "==", "MINUS", ")", "{", "*", "base", "=", "XEXP", "(", "addr", ",", "0", ")", ";", "*", "offset", "=", "XEXP", "(", "addr", ",", "1", ")", ";", "return", "(", "REG_P", "(", "*", "base", ")", "&&", "CONST_INT_P", "(", "*", "offset", ")", ")", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Helper", "for", "gen_operands_ldd_std", ".", "Returns", "true", "iff", "the", "memory", "operand", "MEM", "'s", "address", "contains", "an", "immediate", "offset", "from", "the", "base", "register", "and", "has", "no", "side", "effects", ",", "in", "which", "case", "it", "sets", "BASE", "and", "OFFSET", "accordingly", "." ]

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

[]

[ "<s>", "bool", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "override", "{", "return", "false", ";", "}", "</s>" ]

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

[ "HSAIL" ]

[]

[ "<s>", "rtx", "mmix_return_addr_rtx", "(", "int", "count", ",", "rtx", "frame", "ATTRIBUTE_UNUSED", ")", "{", "return", "count", "==", "0", "?", "(", "MMIX_CFUN_NEEDS_SAVED_EH_RETURN_ADDRESS", "?", "validize_mem", "(", "gen_rtx_MEM", "(", "Pmode", ",", "plus_constant", "(", "Pmode", ",", "frame_pointer_rtx", ",", "-", "16", ")", ")", ")", ":", "get_hard_reg_initial_val", "(", "Pmode", ",", "MMIX_INCOMING_RETURN_ADDRESS_REGNUM", ")", ")", ":", "NULL_RTX", ";", "}", "</s>" ]

[ "RETURN_ADDR_RTX", "." ]

[ "mmix", "0", "16" ]

[]

[ "<s>", "static", "bool", "moxie_pass_by_reference", "(", "cumulative_args_t", ",", "const", "function_arg_info", "&", "arg", ")", "{", "if", "(", "arg", ".", "aggregate_type_p", "(", ")", ")", "return", "true", ";", "unsigned", "HOST_WIDE_INT", "size", "=", "arg", ".", "type_size_in_bytes", "(", ")", ";", "return", "size", ">", "4", "*", "6", ";", "}", "</s>" ]

[ "Return", "non-zero", "if", "the", "function", "argument", "described", "by", "TYPE", "is", "to", "be", "passed", "by", "reference", "." ]

[ "moxie", "4", "6" ]

[]

[ "<s>", "const", "InstrItineraryData", "&", "getInstrItineraryData", "(", ")", "const", "{", "return", "InstrItins", ";", "}", "</s>" ]

[ "getInstrItineraryData", "-", "Returns", "instruction", "itinerary", "data", "for", "the", "target", "or", "specific", "subtarget", "." ]

[ "Mips" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"R600 Emit Clause Markers Pass\"", ";", "}", "</s>" ]

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

[ "R600", "\"R600 Emit Clause Markers Pass\"" ]

[]

[ "<s>", "bool", "TVMTargetLowering", "::", "allowsMisalignedMemoryAccesses", "(", "EVT", ",", "unsigned", ",", "unsigned", ",", "bool", "*", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "allows", "unaligned", "memory", "accesses", "of", "the", "specified", "type", "." ]

[ "TVM", "TVM" ]

[]

[ "<s>", "void", "print_operand_address", "(", "FILE", "*", "file", ",", "rtx", "addr", ")", "{", "visium_output_address", "(", "file", ",", "QImode", ",", "addr", ")", ";", "}", "</s>" ]

[ "Print", "the", "operand", "address", "represented", "by", "the", "rtx", "addr" ]

[ "visium" ]

[]

[ "<s>", "void", "fma_forest", "::", "merge_forest", "(", "fma_forest", "*", "other_forest", ")", "{", "std", "::", "list", "<", "fma_root_node", "*", ">", "*", "other_roots", ";", "std", "::", "list", "<", "fma_root_node", "*", ">", "::", "iterator", "other_root_iter", ";", "if", "(", "this", "==", "other_forest", ")", "return", ";", "other_roots", "=", "other_forest", "->", "m_roots", ";", "for", "(", "other_root_iter", "=", "other_roots", "->", "begin", "(", ")", ";", "other_root_iter", "!=", "other_roots", "->", "end", "(", ")", ";", "other_root_iter", "++", ")", "(", "*", "other_root_iter", ")", "->", "set_forest", "(", "this", ")", ";", "this", "->", "m_globals", "->", "remove_forest", "(", "other_forest", ")", ";", "this", "->", "m_roots", "->", "splice", "(", "this", "->", "m_roots", "->", "begin", "(", ")", ",", "*", "other_roots", ")", ";", "delete", "other_forest", ";", "this", "->", "m_nb_nodes", "+=", "other_forest", "->", "m_nb_nodes", ";", "}", "</s>" ]

[ "Merge", "REF_FOREST", "and", "OTHER_FOREST", "together", ",", "making", "REF_FOREST", "the", "canonical", "fma_forest", "object", "to", "represent", "both", "." ]

[ "aarch64" ]

[]

[ "<s>", "bool", "AArch64AddressTypePromotion", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "skipFunction", "(", "F", ")", ")", "return", "false", ";", "if", "(", "!", "EnableAddressTypePromotion", "||", "F", ".", "isDeclaration", "(", ")", ")", "return", "false", ";", "Func", "=", "&", "F", ";", "ConsideredSExtType", "=", "Type", "::", "getInt64Ty", "(", "Func", "->", "getContext", "(", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"*** \"", "<<", "getPassName", "(", ")", "<<", "\": \"", "<<", "Func", "->", "getName", "(", ")", "<<", "'\\n'", ")", ";", "Instructions", "SExtInsts", ";", "analyzeSExtension", "(", "SExtInsts", ")", ";", "return", "propagateSignExtension", "(", "SExtInsts", ")", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "\"*** \"", "\": \"" ]

[]

[ "<s>", "bool", "AArch64LoadStoreOpt", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "Fn", ")", "{", "if", "(", "skipFunction", "(", "*", "Fn", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "Subtarget", "=", "&", "static_cast", "<", "const", "AArch64Subtarget", "&", ">", "(", "Fn", ".", "getSubtarget", "(", ")", ")", ";", "TII", "=", "static_cast", "<", "const", "AArch64InstrInfo", "*", ">", "(", "Subtarget", "->", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "Subtarget", "->", "getRegisterInfo", "(", ")", ";", "AA", "=", "&", "getAnalysis", "<", "AAResultsWrapperPass", ">", "(", ")", ".", "getAAResults", "(", ")", ";", "ModifiedRegs", ".", "resize", "(", "TRI", "->", "getNumRegs", "(", ")", ")", ";", "UsedRegs", ".", "resize", "(", "TRI", "->", "getNumRegs", "(", ")", ")", ";", "bool", "Modified", "=", "false", ";", "bool", "enableNarrowZeroStOpt", "=", "!", "Subtarget", "->", "requiresStrictAlign", "(", ")", ";", "for", "(", "auto", "&", "MBB", ":", "Fn", ")", "Modified", "|=", "optimizeBlock", "(", "MBB", ",", "enableNarrowZeroStOpt", ")", ";", "return", "Modified", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "bool", "loongarch_split_move_insn_p", "(", "rtx", "dest", ",", "rtx", "src", ")", "{", "return", "loongarch_split_move_p", "(", "dest", ",", "src", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "a", "move", "from", "SRC", "to", "DEST", "in", "INSN", "should", "be", "split", "." ]

[ "loongarch" ]

[]

[ "<s>", "static", "void", "sparc_init_builtins", "(", "void", ")", "{", "if", "(", "TARGET_VIS", ")", "sparc_vis_init_builtins", "(", ")", ";", "}", "</s>" ]

[ "Implement", "the", "TARGET_INIT_BUILTINS", "target", "hook", ".", "Create", "builtin", "functions", "for", "special", "SPARC", "instructions", "." ]

[ "sparc" ]

[]

[ "<s>", "static", "bool", "save_local_or_in_reg_p", "(", "unsigned", "int", "regno", ",", "int", "leaf_function", ")", "{", "if", "(", "!", "call_used_regs", "[", "regno", "]", "&&", "df_regs_ever_live_p", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "regno", "==", "HARD_FRAME_POINTER_REGNUM", "&&", "frame_pointer_needed", ")", "return", "true", ";", "if", "(", "regno", "==", "RETURN_ADDR_REGNUM", "&&", "return_addr_reg_needed_p", "(", "leaf_function", ")", ")", "return", "true", ";", "if", "(", "regno", "==", "GLOBAL_OFFSET_TABLE_REGNUM", "&&", "got_register_rtx", ")", "return", "true", ";", "if", "(", "crtl", "->", "accesses_prior_frames", "&&", "(", "regno", "==", "HARD_FRAME_POINTER_REGNUM", "||", "regno", "==", "RETURN_ADDR_REGNUM", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "whether", "REGNO", ",", "a", "local", "or", "in", "register", ",", "must", "be", "saved/restored", "." ]

[ "sparc" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "getTgtMemIntrinsic", "(", "IntrinsicInfo", "&", "Info", ",", "const", "CallInst", "&", "I", ",", "MachineFunction", "&", "MF", ",", "unsigned", "Intrinsic", ")", "const", "{", "const", "IntrinsicData", "*", "IntrData", "=", "getIntrinsicWithChain", "(", "Intrinsic", ")", ";", "if", "(", "!", "IntrData", ")", "return", "false", ";", "Info", ".", "opc", "=", "ISD", "::", "INTRINSIC_W_CHAIN", ";", "Info", ".", "flags", "=", "MachineMemOperand", "::", "MONone", ";", "Info", ".", "offset", "=", "0", ";", "switch", "(", "IntrData", "->", "Type", ")", "{", "case", "EXPAND_FROM_MEM", ":", "{", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "I", ".", "getType", "(", ")", ")", ";", "Info", ".", "align", "=", "1", ";", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOLoad", ";", "break", ";", "}", "case", "COMPRESS_TO_MEM", ":", "{", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVT", "(", "I", ".", "getArgOperand", "(", "1", ")", "->", "getType", "(", ")", ")", ";", "Info", ".", "align", "=", "1", ";", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOStore", ";", "break", ";", "}", "case", "TRUNCATE_TO_MEM_VI8", ":", "case", "TRUNCATE_TO_MEM_VI16", ":", "case", "TRUNCATE_TO_MEM_VI32", ":", "{", "Info", ".", "ptrVal", "=", "I", ".", "getArgOperand", "(", "0", ")", ";", "MVT", "VT", "=", "MVT", "::", "getVT", "(", "I", ".", "getArgOperand", "(", "1", ")", "->", "getType", "(", ")", ")", ";", "MVT", "ScalarVT", "=", "MVT", "::", "INVALID_SIMPLE_VALUE_TYPE", ";", "if", "(", "IntrData", "->", "Type", "==", "TRUNCATE_TO_MEM_VI8", ")", "ScalarVT", "=", "MVT", "::", "i8", ";", "else", "if", "(", "IntrData", "->", "Type", "==", "TRUNCATE_TO_MEM_VI16", ")", "ScalarVT", "=", "MVT", "::", "i16", ";", "else", "if", "(", "IntrData", "->", "Type", "==", "TRUNCATE_TO_MEM_VI32", ")", "ScalarVT", "=", "MVT", "::", "i32", ";", "Info", ".", "memVT", "=", "MVT", "::", "getVectorVT", "(", "ScalarVT", ",", "VT", ".", "getVectorNumElements", "(", ")", ")", ";", "Info", ".", "align", "=", "1", ";", "Info", ".", "flags", "|=", "MachineMemOperand", "::", "MOStore", ";", "break", ";", "}", "default", ":", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "X86", "ISD::INTRINSIC_W_CHAIN", "0", "0", "MVT::getVT", "1", "0", "MVT::getVT", "1", "1", "0", "MVT::getVT", "1", "MVT::INVALID_SIMPLE_VALUE_TYPE", "MVT::i8", "MVT::i16", "MVT::i32", "MVT::getVectorVT", "1" ]

[]

[ "<s>", "void", "MipsOutgoingValueHandler", "::", "assignValueToAddress", "(", "Register", "ValVReg", ",", "const", "CCValAssign", "&", "VA", ")", "{", "MachineMemOperand", "*", "MMO", ";", "Register", "Addr", "=", "getStackAddress", "(", "VA", ",", "MMO", ")", ";", "Register", "ExtReg", "=", "extendRegister", "(", "ValVReg", ",", "VA", ")", ";", "MIRBuilder", ".", "buildStore", "(", "ExtReg", ",", "Addr", ",", "*", "MMO", ")", ";", "}", "</s>" ]

[ "An", "overload", "which", "takes", "an", "ArgInfo", "if", "additional", "information", "about", "the", "arg", "is", "needed", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "DecodeStatus", "RISCVDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "OS", ",", "raw_ostream", "&", "CS", ")", "const", "{", "uint32_t", "Insn", ";", "DecodeStatus", "Result", ";", "if", "(", "(", "Bytes", "[", "0", "]", "&", "0x3", ")", "==", "0x3", ")", "{", "Insn", "=", "support", "::", "endian", "::", "read32le", "(", "Bytes", ".", "data", "(", ")", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying RISCV32 table :\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable32", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "Size", "=", "4", ";", "}", "else", "{", "Insn", "=", "support", "::", "endian", "::", "read16le", "(", "Bytes", ".", "data", "(", ")", ")", ";", "if", "(", "!", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "Feature64Bit", "]", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying RISCV32Only_16 table (16-bit Instruction):\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTableRISCV32Only_16", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "if", "(", "Result", "!=", "MCDisassembler", "::", "Fail", ")", "{", "Size", "=", "2", ";", "return", "Result", ";", "}", "}", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Trying RISCV_C table (16-bit Instruction):\\n\"", ")", ";", "Result", "=", "decodeInstruction", "(", "DecoderTable16", ",", "MI", ",", "Insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "Size", "=", "2", ";", "}", "return", "Result", ";", "}", "</s>" ]

[ "Returns", "the", "disassembly", "of", "a", "single", "instruction", "." ]

[ "RISCV", "RISCV", "0", "0x3", "0x3", "support::endian", "\"Trying RISCV32 table :\\n\"", "4", "support::endian", "RISCV::Feature64Bit", "\"Trying RISCV32Only_16 table (16-bit Instruction):\\n\"", "RISCV", "2", "\"Trying RISCV_C table (16-bit Instruction):\\n\"", "2" ]

[]

[ "<s>", "bool", "X86InstrInfo", "::", "analyzeCompare", "(", "const", "MachineInstr", "&", "MI", ",", "unsigned", "&", "SrcReg", ",", "unsigned", "&", "SrcReg2", ",", "int", "&", "CmpMask", ",", "int", "&", "CmpValue", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "X86", "::", "CMP64ri32", ":", "case", "X86", "::", "CMP64ri8", ":", "case", "X86", "::", "CMP32ri", ":", "case", "X86", "::", "CMP32ri8", ":", "case", "X86", "::", "CMP16ri", ":", "case", "X86", "::", "CMP16ri8", ":", "case", "X86", "::", "CMP8ri", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", ")", "{", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getImm", "(", ")", ";", "}", "else", "{", "CmpMask", "=", "CmpValue", "=", "0", ";", "}", "return", "true", ";", "case", "X86", "::", "SUB64rm", ":", "case", "X86", "::", "SUB32rm", ":", "case", "X86", "::", "SUB16rm", ":", "case", "X86", "::", "SUB8rm", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "X86", "::", "SUB64rr", ":", "case", "X86", "::", "SUB32rr", ":", "case", "X86", "::", "SUB16rr", ":", "case", "X86", "::", "SUB8rr", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "X86", "::", "SUB64ri32", ":", "case", "X86", "::", "SUB64ri8", ":", "case", "X86", "::", "SUB32ri", ":", "case", "X86", "::", "SUB32ri8", ":", "case", "X86", "::", "SUB16ri", ":", "case", "X86", "::", "SUB16ri8", ":", "case", "X86", "::", "SUB8ri", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "0", ";", "if", "(", "MI", ".", "getOperand", "(", "2", ")", ".", "isImm", "(", ")", ")", "{", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "MI", ".", "getOperand", "(", "2", ")", ".", "getImm", "(", ")", ";", "}", "else", "{", "CmpMask", "=", "CmpValue", "=", "0", ";", "}", "return", "true", ";", "case", "X86", "::", "CMP64rr", ":", "case", "X86", "::", "CMP32rr", ":", "case", "X86", "::", "CMP16rr", ":", "case", "X86", "::", "CMP8rr", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "SrcReg2", "=", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "CmpMask", "=", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "case", "X86", "::", "TEST8rr", ":", "case", "X86", "::", "TEST16rr", ":", "case", "X86", "::", "TEST32rr", ":", "case", "X86", "::", "TEST64rr", ":", "SrcReg", "=", "MI", ".", "getOperand", "(", "0", ")", ".", "getReg", "(", ")", ";", "if", "(", "MI", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", "!=", "SrcReg", ")", "return", "false", ";", "SrcReg2", "=", "0", ";", "CmpMask", "=", "~", "0", ";", "CmpValue", "=", "0", ";", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "analyzeCompare", "-", "For", "a", "comparison", "instruction", ",", "return", "the", "source", "registers", "in", "SrcReg", "and", "SrcReg2", "if", "having", "two", "register", "operands", ",", "and", "the", "value", "it", "compares", "against", "in", "CmpValue", "." ]

[ "X86", "X86", "X86::CMP64ri32", "X86::CMP64ri8", "X86::CMP32ri", "X86::CMP32ri8", "X86::CMP16ri", "X86::CMP16ri8", "X86::CMP8ri", "0", "0", "1", "0", "1", "0", "X86::SUB64rm", "X86::SUB32rm", "X86::SUB16rm", "X86::SUB8rm", "1", "0", "0", "0", "X86::SUB64rr", "X86::SUB32rr", "X86::SUB16rr", "X86::SUB8rr", "1", "2", "0", "0", "X86::SUB64ri32", "X86::SUB64ri8", "X86::SUB32ri", "X86::SUB32ri8", "X86::SUB16ri", "X86::SUB16ri8", "X86::SUB8ri", "1", "0", "2", "0", "2", "0", "X86::CMP64rr", "X86::CMP32rr", "X86::CMP16rr", "X86::CMP8rr", "0", "1", "0", "0", "X86::TEST8rr", "X86::TEST16rr", "X86::TEST32rr", "X86::TEST64rr", "0", "1", "0", "0", "0" ]

[]

[ "<s>", "int", "SIInstrInfo", "::", "pseudoToMCOpcode", "(", "int", "Opcode", ")", "const", "{", "SIEncodingFamily", "Gen", "=", "subtargetEncodingFamily", "(", "ST", ")", ";", "if", "(", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "renamedInGFX9", ")", "!=", "0", "&&", "ST", ".", "getGeneration", "(", ")", "==", "AMDGPUSubtarget", "::", "GFX9", ")", "Gen", "=", "SIEncodingFamily", "::", "GFX9", ";", "if", "(", "ST", ".", "hasUnpackedD16VMem", "(", ")", "&&", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "D16Buf", ")", ")", "Gen", "=", "SIEncodingFamily", "::", "GFX80", ";", "if", "(", "get", "(", "Opcode", ")", ".", "TSFlags", "&", "SIInstrFlags", "::", "SDWA", ")", "{", "switch", "(", "ST", ".", "getGeneration", "(", ")", ")", "{", "default", ":", "Gen", "=", "SIEncodingFamily", "::", "SDWA", ";", "break", ";", "case", "AMDGPUSubtarget", "::", "GFX9", ":", "Gen", "=", "SIEncodingFamily", "::", "SDWA9", ";", "break", ";", "case", "AMDGPUSubtarget", "::", "GFX10", ":", "Gen", "=", "SIEncodingFamily", "::", "SDWA10", ";", "break", ";", "}", "}", "int", "MCOp", "=", "AMDGPU", "::", "getMCOpcode", "(", "Opcode", ",", "Gen", ")", ";", "if", "(", "MCOp", "==", "-", "1", ")", "return", "Opcode", ";", "if", "(", "MCOp", "==", "(", "uint16_t", ")", "-", "1", ")", "return", "-", "1", ";", "return", "MCOp", ";", "}", "</s>" ]

[ "Return", "a", "target-specific", "opcode", "if", "Opcode", "is", "a", "pseudo", "instruction", "." ]

[ "AMDGPU", "SI", "SI", "SIInstrFlags::renamedInGFX9", "0", "AMDGPU", "SIEncodingFamily::GFX9", "SIInstrFlags::D16Buf", "SIEncodingFamily::GFX80", "SIInstrFlags::SDWA", "SIEncodingFamily::SDWA", "AMDGPU", "SIEncodingFamily::SDWA9", "AMDGPU", "SIEncodingFamily::SDWA10", "AMDGPU::getMCOpcode", "1", "1", "1" ]

[]

[ "<s>", "const", "char", "*", "output_addsi3", "(", "rtx", "*", "operands", ")", "{", "if", "(", "!", "operands_match_p", "(", "operands", "[", "0", "]", ",", "operands", "[", "1", "]", ")", ")", "{", "if", "(", "!", "ADDRESS_REG_P", "(", "operands", "[", "1", "]", ")", ")", "{", "rtx", "tmp", "=", "operands", "[", "1", "]", ";", "operands", "[", "1", "]", "=", "operands", "[", "2", "]", ";", "operands", "[", "2", "]", "=", "tmp", ";", "}", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", "&&", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "-", "32768", "||", "INTVAL", "(", "operands", "[", "2", "]", ")", ">", "32767", ")", ")", "return", "\"move%.l %2,%0\\n\\tadd%.l %1,%0\"", ";", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "REG", ")", "return", "MOTOROLA", "?", "\"lea (%1,%2.l),%0\"", ":", "\"lea %1@(0,%2:l),%0\"", ";", "return", "MOTOROLA", "?", "\"lea (%c2,%1),%0\"", ":", "\"lea %1@(%c2),%0\"", ";", "}", "if", "(", "GET_CODE", "(", "operands", "[", "2", "]", ")", "==", "CONST_INT", ")", "{", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ">", "0", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", "<=", "8", ")", "return", "\"addq%.l %2,%0\"", ";", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "0", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", ">=", "-", "8", ")", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "-", "INTVAL", "(", "operands", "[", "2", "]", ")", ")", ";", "return", "\"subq%.l %2,%0\"", ";", "}", "if", "(", "TARGET_CPU32", "&&", "REG_P", "(", "operands", "[", "0", "]", ")", ")", "{", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", ">", "8", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", "<=", "16", ")", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "-", "8", ")", ";", "return", "\"addq%.l #8,%0\\n\\taddq%.l %2,%0\"", ";", "}", "if", "(", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "-", "8", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", ">=", "-", "16", ")", "{", "operands", "[", "2", "]", "=", "GEN_INT", "(", "-", "INTVAL", "(", "operands", "[", "2", "]", ")", "-", "8", ")", ";", "return", "\"subq%.l #8,%0\\n\\tsubq%.l %2,%0\"", ";", "}", "}", "if", "(", "ADDRESS_REG_P", "(", "operands", "[", "0", "]", ")", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", ">=", "-", "0x8000", "&&", "INTVAL", "(", "operands", "[", "2", "]", ")", "<", "0x8000", ")", "{", "if", "(", "TARGET_68040", ")", "return", "\"add%.w %2,%0\"", ";", "else", "return", "MOTOROLA", "?", "\"lea (%c2,%0),%0\"", ":", "\"lea %0@(%c2),%0\"", ";", "}", "}", "return", "\"add%.l %2,%0\"", ";", "}", "</s>" ]

[ "Output", "assembler", "code", "to", "perform", "a", "32", "bit", "3", "operand", "add", "." ]

[ "m68k", "0", "1", "1", "1", "1", "2", "2", "2", "2", "32768", "2", "32767", "\"move%.l %2,%0\\n\\tadd%.l %1,%0\"", "2", "\"lea (%1,%2.l),%0\"", "\"lea %1@(0,%2:l),%0\"", "\"lea (%c2,%1),%0\"", "\"lea %1@(%c2),%0\"", "2", "2", "0", "2", "8", "\"addq%.l %2,%0\"", "2", "0", "2", "8", "2", "2", "\"subq%.l %2,%0\"", "0", "2", "8", "2", "16", "2", "2", "8", "\"addq%.l #8,%0\\n\\taddq%.l %2,%0\"", "2", "8", "2", "16", "2", "2", "8", "\"subq%.l #8,%0\\n\\tsubq%.l %2,%0\"", "0", "2", "0x8000", "2", "0x8000", "\"add%.w %2,%0\"", "\"lea (%c2,%0),%0\"", "\"lea %0@(%c2),%0\"", "\"add%.l %2,%0\"" ]

[]

[ "<s>", "static", "void", "rs6000_xcoff_file_end", "(", "void", ")", "{", "text_section", "(", ")", ";", "fputs", "(", "\"_section_.text:\\n\"", ",", "asm_out_file", ")", ";", "data_section", "(", ")", ";", "fputs", "(", "TARGET_32BIT", "?", "\"\\t.long _section_.text\\n\"", ":", "\"\\t.llong _section_.text\\n\"", ",", "asm_out_file", ")", ";", "}", "</s>" ]

[ "Output", "at", "end", "of", "assembler", "file", ".", "On", "the", "RS/6000", ",", "referencing", "data", "should", "automatically", "pull", "in", "text", "." ]

[ "rs6000", "\"_section_.text:\\n\"", "\"\\t.long _section_.text\\n\"", "\"\\t.llong _section_.text\\n\"" ]

[]

[ "<s>", "TargetLowering", "::", "ConstraintWeight", "SystemZTargetLowering", "::", "getSingleConstraintMatchWeight", "(", "AsmOperandInfo", "&", "info", ",", "const", "char", "*", "constraint", ")", "const", "{", "ConstraintWeight", "weight", "=", "CW_Invalid", ";", "Value", "*", "CallOperandVal", "=", "info", ".", "CallOperandVal", ";", "if", "(", "!", "CallOperandVal", ")", "return", "CW_Default", ";", "Type", "*", "type", "=", "CallOperandVal", "->", "getType", "(", ")", ";", "switch", "(", "*", "constraint", ")", "{", "default", ":", "weight", "=", "TargetLowering", "::", "getSingleConstraintMatchWeight", "(", "info", ",", "constraint", ")", ";", "break", ";", "case", "'a'", ":", "case", "'d'", ":", "case", "'h'", ":", "case", "'r'", ":", "if", "(", "CallOperandVal", "->", "getType", "(", ")", "->", "isIntegerTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'f'", ":", "if", "(", "type", "->", "isFloatingPointTy", "(", ")", ")", "weight", "=", "CW_Register", ";", "break", ";", "case", "'I'", ":", "if", "(", "auto", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "if", "(", "isUInt", "<", "8", ">", "(", "C", "->", "getZExtValue", "(", ")", ")", ")", "weight", "=", "CW_Constant", ";", "break", ";", "case", "'J'", ":", "if", "(", "auto", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "if", "(", "isUInt", "<", "12", ">", "(", "C", "->", "getZExtValue", "(", ")", ")", ")", "weight", "=", "CW_Constant", ";", "break", ";", "case", "'K'", ":", "if", "(", "auto", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "if", "(", "isInt", "<", "16", ">", "(", "C", "->", "getSExtValue", "(", ")", ")", ")", "weight", "=", "CW_Constant", ";", "break", ";", "case", "'L'", ":", "if", "(", "auto", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "if", "(", "isInt", "<", "20", ">", "(", "C", "->", "getSExtValue", "(", ")", ")", ")", "weight", "=", "CW_Constant", ";", "break", ";", "case", "'M'", ":", "if", "(", "auto", "*", "C", "=", "dyn_cast", "<", "ConstantInt", ">", "(", "CallOperandVal", ")", ")", "if", "(", "C", "->", "getZExtValue", "(", ")", "==", "0x7fffffff", ")", "weight", "=", "CW_Constant", ";", "break", ";", "}", "return", "weight", ";", "}", "</s>" ]

[ "Examine", "constraint", "string", "and", "operand", "type", "and", "determine", "a", "weight", "value", "." ]

[ "SystemZ", "SystemZ", "8", "12", "16", "20", "0x7fffffff" ]

[]

[ "<s>", "void", "X86IntelInstPrinter", "::", "printPCRelImm", "(", "const", "MCInst", "*", "MI", ",", "unsigned", "OpNo", ",", "raw_ostream", "&", "O", ")", "{", "const", "MCOperand", "&", "Op", "=", "MI", "->", "getOperand", "(", "OpNo", ")", ";", "if", "(", "Op", ".", "isImm", "(", ")", ")", "O", "<<", "Op", ".", "getImm", "(", ")", ";", "else", "{", "assert", "(", "Op", ".", "isExpr", "(", ")", "&&", "\"unknown pcrel immediate operand\"", ")", ";", "const", "MCConstantExpr", "*", "BranchTarget", "=", "dyn_cast", "<", "MCConstantExpr", ">", "(", "Op", ".", "getExpr", "(", ")", ")", ";", "int64_t", "Address", ";", "if", "(", "BranchTarget", "&&", "BranchTarget", "->", "EvaluateAsAbsolute", "(", "Address", ")", ")", "{", "O", "<<", "\"0x\"", ";", "O", ".", "write_hex", "(", "Address", ")", ";", "}", "else", "{", "O", "<<", "*", "Op", ".", "getExpr", "(", ")", ";", "}", "}", "}", "</s>" ]

[ "value", "(", "e.g", "." ]

[ "X86", "X86", "\"unknown pcrel immediate operand\"", "\"0x\"" ]

[]

[ "<s>", "static", "rtx_insn", "*", "nds32_md_asm_adjust", "(", "vec", "<", "rtx", ">", "&", "outputs", "ATTRIBUTE_UNUSED", ",", "vec", "<", "rtx", ">", "&", "inputs", "ATTRIBUTE_UNUSED", ",", "vec", "<", "machine_mode", ">", "&", "input_modes", "ATTRIBUTE_UNUSED", ",", "vec", "<", "const", "char", "*", ">", "&", "constraints", "ATTRIBUTE_UNUSED", ",", "vec", "<", "rtx", ">", "&", "clobbers", ",", "HARD_REG_SET", "&", "clobbered_regs", ")", "{", "if", "(", "!", "flag_inline_asm_r15", ")", "{", "clobbers", ".", "safe_push", "(", "gen_rtx_REG", "(", "SImode", ",", "TA_REGNUM", ")", ")", ";", "SET_HARD_REG_BIT", "(", "clobbered_regs", ",", "TA_REGNUM", ")", ";", "}", "return", "NULL", ";", "}", "</s>" ]

[ "Miscellaneous", "Parameters", "." ]

[ "nds32" ]

[]

[ "<s>", "bool", "X86AsmPrinter", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "Subtarget", "=", "&", "MF", ".", "getSubtarget", "<", "X86Subtarget", ">", "(", ")", ";", "SMShadowTracker", ".", "startFunction", "(", "MF", ")", ";", "SetupMachineFunction", "(", "MF", ")", ";", "if", "(", "Subtarget", "->", "isTargetCOFF", "(", ")", ")", "{", "bool", "Intrn", "=", "MF", ".", "getFunction", "(", ")", "->", "hasInternalLinkage", "(", ")", ";", "OutStreamer", "->", "BeginCOFFSymbolDef", "(", "CurrentFnSym", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolStorageClass", "(", "Intrn", "?", "COFF", "::", "IMAGE_SYM_CLASS_STATIC", ":", "COFF", "::", "IMAGE_SYM_CLASS_EXTERNAL", ")", ";", "OutStreamer", "->", "EmitCOFFSymbolType", "(", "COFF", "::", "IMAGE_SYM_DTYPE_FUNCTION", "<<", "COFF", "::", "SCT_COMPLEX_TYPE_SHIFT", ")", ";", "OutStreamer", "->", "EndCOFFSymbolDef", "(", ")", ";", "}", "EmitFunctionBody", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "RISCVInstrInfo", "::", "isFunctionSafeToOutlineFrom", "(", "MachineFunction", "&", "MF", ",", "bool", "OutlineFromLinkOnceODRs", ")", "const", "{", "const", "Function", "&", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "!", "OutlineFromLinkOnceODRs", "&&", "F", ".", "hasLinkOnceODRLinkage", "(", ")", ")", "return", "false", ";", "if", "(", "F", ".", "hasSection", "(", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "function", "can", "safely", "be", "outlined", "from", "." ]

[ "RISCV", "RISCV" ]

[]

[ "<s>", "TargetPassConfig", "*", "Cpu0TargetMachine", "::", "createPassConfig", "(", "PassManagerBase", "&", "PM", ")", "{", "return", "new", "Cpu0PassConfig", "(", "this", ",", "PM", ")", ";", "}", "</s>" ]

[ "Create", "a", "pass", "configuration", "object", "to", "be", "used", "by", "addPassToEmitX", "methods", "for", "generating", "a", "pipeline", "of", "CodeGen", "passes", "." ]

[ "Cpu0", "Cpu0", "Cpu0" ]

[]

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

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

[ "Sparc", "Sparc", "Sparc" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "const", "SDLoc", "&", "DL", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "return", "DAG", ".", "getNode", "(", "AMDGPUISD", "::", "ENDPGM", ",", "DL", ",", "MVT", "::", "Other", ",", "Chain", ")", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "ISD::OutputArg", "AMDGPUISD::ENDPGM", "MVT::Other" ]

[]

[ "<s>", "void", "output_dbcc_and_branch", "(", "rtx", "*", "operands", ")", "{", "switch", "(", "GET_CODE", "(", "operands", "[", "3", "]", ")", ")", "{", "case", "EQ", ":", "output_asm_insn", "(", "\"dbeq %0,%l1\\n\\tjeq %l2\"", ",", "operands", ")", ";", "break", ";", "case", "NE", ":", "output_asm_insn", "(", "\"dbne %0,%l1\\n\\tjne %l2\"", ",", "operands", ")", ";", "break", ";", "case", "GT", ":", "output_asm_insn", "(", "\"dbgt %0,%l1\\n\\tjgt %l2\"", ",", "operands", ")", ";", "break", ";", "case", "GTU", ":", "output_asm_insn", "(", "\"dbhi %0,%l1\\n\\tjhi %l2\"", ",", "operands", ")", ";", "break", ";", "case", "LT", ":", "output_asm_insn", "(", "\"dblt %0,%l1\\n\\tjlt %l2\"", ",", "operands", ")", ";", "break", ";", "case", "LTU", ":", "output_asm_insn", "(", "\"dbcs %0,%l1\\n\\tjcs %l2\"", ",", "operands", ")", ";", "break", ";", "case", "GE", ":", "output_asm_insn", "(", "\"dbge %0,%l1\\n\\tjge %l2\"", ",", "operands", ")", ";", "break", ";", "case", "GEU", ":", "output_asm_insn", "(", "\"dbcc %0,%l1\\n\\tjcc %l2\"", ",", "operands", ")", ";", "break", ";", "case", "LE", ":", "output_asm_insn", "(", "\"dble %0,%l1\\n\\tjle %l2\"", ",", "operands", ")", ";", "break", ";", "case", "LEU", ":", "output_asm_insn", "(", "\"dbls %0,%l1\\n\\tjls %l2\"", ",", "operands", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "switch", "(", "GET_MODE", "(", "operands", "[", "0", "]", ")", ")", "{", "case", "E_SImode", ":", "output_asm_insn", "(", "\"clr%.w %0\\n\\tsubq%.l #1,%0\\n\\tjpl %l1\"", ",", "operands", ")", ";", "break", ";", "case", "E_HImode", ":", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "Output", "a", "dbCC", ";", "jCC", "sequence", ".", "Note", "we", "do", "not", "handle", "the", "floating", "point", "version", "of", "this", "sequence", "(", "Fdbcc", ")", ".", "We", "also", "do", "not", "handle", "alternative", "conditions", "when", "CC_NO_OVERFLOW", "is", "set", ".", "It", "is", "assumed", "that", "valid_dbcc_comparison_p", "and", "flags_in_68881", "will", "kick", "those", "out", "before", "we", "get", "here", "." ]

[ "m68k", "3", "\"dbeq %0,%l1\\n\\tjeq %l2\"", "\"dbne %0,%l1\\n\\tjne %l2\"", "\"dbgt %0,%l1\\n\\tjgt %l2\"", "\"dbhi %0,%l1\\n\\tjhi %l2\"", "\"dblt %0,%l1\\n\\tjlt %l2\"", "\"dbcs %0,%l1\\n\\tjcs %l2\"", "\"dbge %0,%l1\\n\\tjge %l2\"", "\"dbcc %0,%l1\\n\\tjcc %l2\"", "\"dble %0,%l1\\n\\tjle %l2\"", "\"dbls %0,%l1\\n\\tjls %l2\"", "0", "\"clr%.w %0\\n\\tsubq%.l #1,%0\\n\\tjpl %l1\"" ]

[]

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

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

[ "BPF", "BPF" ]

[]

[ "<s>", "rtx", "swap_endian_selector_for_mode", "(", "machine_mode", "mode", ")", "{", "unsigned", "int", "swap1", "[", "16", "]", "=", "{", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", ",", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "1", ",", "0", "}", ";", "unsigned", "int", "swap2", "[", "16", "]", "=", "{", "7", ",", "6", ",", "5", ",", "4", ",", "3", ",", "2", ",", "1", ",", "0", ",", "15", ",", "14", ",", "13", ",", "12", ",", "11", ",", "10", ",", "9", ",", "8", "}", ";", "unsigned", "int", "swap4", "[", "16", "]", "=", "{", "3", ",", "2", ",", "1", ",", "0", ",", "7", ",", "6", ",", "5", ",", "4", ",", "11", ",", "10", ",", "9", ",", "8", ",", "15", ",", "14", ",", "13", ",", "12", "}", ";", "unsigned", "int", "swap8", "[", "16", "]", "=", "{", "1", ",", "0", ",", "3", ",", "2", ",", "5", ",", "4", ",", "7", ",", "6", ",", "9", ",", "8", ",", "11", ",", "10", ",", "13", ",", "12", ",", "15", ",", "14", "}", ";", "unsigned", "int", "*", "swaparray", ",", "i", ";", "rtx", "perm", "[", "16", "]", ";", "switch", "(", "mode", ")", "{", "case", "E_V1TImode", ":", "swaparray", "=", "swap1", ";", "break", ";", "case", "E_V2DFmode", ":", "case", "E_V2DImode", ":", "swaparray", "=", "swap2", ";", "break", ";", "case", "E_V4SFmode", ":", "case", "E_V4SImode", ":", "swaparray", "=", "swap4", ";", "break", ";", "case", "E_V8HImode", ":", "swaparray", "=", "swap8", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "for", "(", "i", "=", "0", ";", "i", "<", "16", ";", "++", "i", ")", "perm", "[", "i", "]", "=", "GEN_INT", "(", "swaparray", "[", "i", "]", ")", ";", "return", "force_reg", "(", "V16QImode", ",", "gen_rtx_CONST_VECTOR", "(", "V16QImode", ",", "gen_rtvec_v", "(", "16", ",", "perm", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "the", "permutation", "index", "for", "the", "swapping", "on", "the", "given", "vector", "mode", ".", "Note", "that", "the", "permutation", "index", "is", "correspondingly", "generated", "by", "endianness", ",", "it", "should", "be", "used", "by", "direct", "vector", "permutation", "." ]

[ "rs6000", "16", "15", "14", "13", "12", "11", "10", "9", "8", "7", "6", "5", "4", "3", "2", "1", "0", "16", "7", "6", "5", "4", "3", "2", "1", "0", "15", "14", "13", "12", "11", "10", "9", "8", "16", "3", "2", "1", "0", "7", "6", "5", "4", "11", "10", "9", "8", "15", "14", "13", "12", "16", "1", "0", "3", "2", "5", "4", "7", "6", "9", "8", "11", "10", "13", "12", "15", "14", "16", "0", "16", "16" ]

[]

[ "<s>", "bool", "Error", "(", "SMLoc", "L", ",", "const", "Twine", "&", "Msg", ",", "SMRange", "Range", "=", "None", ",", "bool", "MatchingInlineAsm", "=", "false", ")", "{", "MCAsmParser", "&", "Parser", "=", "getParser", "(", ")", ";", "if", "(", "MatchingInlineAsm", ")", "{", "if", "(", "!", "getLexer", "(", ")", ".", "isAtStartOfStatement", "(", ")", ")", "Parser", ".", "eatToEndOfStatement", "(", ")", ";", "return", "false", ";", "}", "return", "Parser", ".", "Error", "(", "L", ",", "Msg", ",", "Range", ")", ";", "}", "</s>" ]

[ "Return", "an", "error", "at", "the", "location", "L", ",", "with", "the", "message", "Msg", "." ]

[ "X86" ]

[]

[ "<s>", "static", "rtx", "riscv_emit_set", "(", "rtx", "target", ",", "rtx", "src", ")", "{", "emit_insn", "(", "gen_rtx_SET", "(", "target", ",", "src", ")", ")", ";", "return", "target", ";", "}", "</s>" ]

[ "Emit", "an", "instruction", "of", "the", "form", "(", "set", "TARGET", "SRC", ")", "." ]

[ "riscv" ]

[]

[ "<s>", "StringRef", "getPassName", "(", ")", "const", "override", "{", "return", "\"PULP Hardware Loop Fixup\"", ";", "}", "</s>" ]

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

[ "RI5CY", "\"PULP Hardware Loop Fixup\"" ]

[]

[ "<s>", "ScheduleHazardRecognizer", "::", "HazardType", "PPCHazardRecognizer970", "::", "getHazardType", "(", "SUnit", "*", "SU", ",", "int", "Stalls", ")", "{", "assert", "(", "Stalls", "==", "0", "&&", "\"PPC hazards don't support scoreboard lookahead\"", ")", ";", "MachineInstr", "*", "MI", "=", "SU", "->", "getInstr", "(", ")", ";", "if", "(", "MI", "->", "isDebugValue", "(", ")", ")", "return", "NoHazard", ";", "unsigned", "Opcode", "=", "MI", "->", "getOpcode", "(", ")", ";", "bool", "isFirst", ",", "isSingle", ",", "isCracked", ",", "isLoad", ",", "isStore", ";", "PPCII", "::", "PPC970_Unit", "InstrType", "=", "GetInstrType", "(", "Opcode", ",", "isFirst", ",", "isSingle", ",", "isCracked", ",", "isLoad", ",", "isStore", ")", ";", "if", "(", "InstrType", "==", "PPCII", "::", "PPC970_Pseudo", ")", "return", "NoHazard", ";", "if", "(", "NumIssued", "!=", "0", "&&", "(", "isFirst", "||", "isSingle", ")", ")", "return", "Hazard", ";", "if", "(", "isCracked", "&&", "NumIssued", ">", "2", ")", "return", "Hazard", ";", "switch", "(", "InstrType", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown instruction type!\"", ")", ";", "case", "PPCII", "::", "PPC970_FXU", ":", "case", "PPCII", "::", "PPC970_LSU", ":", "case", "PPCII", "::", "PPC970_FPU", ":", "case", "PPCII", "::", "PPC970_VALU", ":", "case", "PPCII", "::", "PPC970_VPERM", ":", "if", "(", "NumIssued", "==", "4", ")", "return", "Hazard", ";", "break", ";", "case", "PPCII", "::", "PPC970_CRU", ":", "if", "(", "NumIssued", ">=", "2", ")", "return", "Hazard", ";", "break", ";", "case", "PPCII", "::", "PPC970_BRU", ":", "break", ";", "}", "if", "(", "HasCTRSet", "&&", "Opcode", "==", "PPC", "::", "BCTRL", ")", "return", "NoopHazard", ";", "if", "(", "isLoad", "&&", "NumStores", "&&", "!", "MI", "->", "memoperands_empty", "(", ")", ")", "{", "MachineMemOperand", "*", "MO", "=", "*", "MI", "->", "memoperands_begin", "(", ")", ";", "if", "(", "isLoadOfStoredAddress", "(", "MO", "->", "getSize", "(", ")", ",", "MO", "->", "getOffset", "(", ")", ",", "MO", "->", "getValue", "(", ")", ")", ")", "return", "NoopHazard", ";", "}", "return", "NoHazard", ";", "}", "</s>" ]

[ "getHazardType", "-", "Return", "the", "hazard", "type", "of", "emitting", "this", "node", "." ]

[ "PowerPC", "PPC", "0", "\"PPC hazards don't support scoreboard lookahead\"", "PPCII::PPC970_Unit", "PPCII::PPC970_Pseudo", "0", "2", "\"Unknown instruction type!\"", "PPCII::PPC970_FXU", "PPCII::PPC970_LSU", "PPCII::PPC970_FPU", "PPCII::PPC970_VALU", "PPCII::PPC970_VPERM", "4", "PPCII::PPC970_CRU", "2", "PPCII::PPC970_BRU", "PPC::BCTRL" ]

[]

[ "<s>", "MachinePointerInfo", "MipsFunctionInfo", "::", "callPtrInfo", "(", "MachineFunction", "&", "MF", ",", "const", "GlobalValue", "*", "GV", ")", "{", "return", "MachinePointerInfo", "(", "MF", ".", "getPSVManager", "(", ")", ".", "getGlobalValueCallEntry", "(", "GV", ")", ")", ";", "}", "</s>" ]

[ "Create", "a", "MachinePointerInfo", "that", "has", "a", "GlobalValuePseudoSourceValue", "object", "representing", "a", "GOT", "entry", "for", "a", "global", "function", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "bool", "AArch64PassConfig", "::", "addLegalizeMachineIR", "(", ")", "{", "addPass", "(", "new", "Legalizer", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "a", "legalize", "pass", ",", "which", "converts", "the", "instruction", "sequence", "into", "one", "that", "can", "be", "selected", "by", "the", "target", "." ]

[ "AArch64", "AArch64" ]

[]

[ "<s>", "static", "inline", "rtx", "s390_expand_mask_and_shift", "(", "rtx", "val", ",", "machine_mode", "mode", ",", "rtx", "count", ")", "{", "val", "=", "expand_simple_binop", "(", "SImode", ",", "AND", ",", "val", ",", "GEN_INT", "(", "GET_MODE_MASK", "(", "mode", ")", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "return", "expand_simple_binop", "(", "SImode", ",", "ASHIFT", ",", "val", ",", "count", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "}", "</s>" ]

[ "A", "subroutine", "of", "s390_expand_cs_hqi", "and", "s390_expand_atomic", "which", "returns", "a", "register", "that", "holds", "VAL", "of", "mode", "MODE", "shifted", "by", "COUNT", "bits", "." ]

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

[]

[ "<s>", "static", "void", "Query", "(", "const", "MachineInstr", "&", "MI", ",", "AliasAnalysis", "&", "AA", ",", "bool", "&", "Read", ",", "bool", "&", "Write", ",", "bool", "&", "Effects", ",", "bool", "&", "StackPointer", ")", "{", "assert", "(", "!", "MI", ".", "isTerminator", "(", ")", ")", ";", "if", "(", "MI", ".", "isDebugInstr", "(", ")", "||", "MI", ".", "isPosition", "(", ")", ")", "return", ";", "if", "(", "MI", ".", "mayLoad", "(", ")", "&&", "!", "MI", ".", "isDereferenceableInvariantLoad", "(", "&", "AA", ")", ")", "Read", "=", "true", ";", "if", "(", "MI", ".", "mayStore", "(", ")", ")", "{", "Write", "=", "true", ";", "}", "else", "if", "(", "MI", ".", "hasOrderedMemoryRef", "(", ")", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "DIV_S_I32", ":", "case", "WebAssembly", "::", "DIV_S_I64", ":", "case", "WebAssembly", "::", "REM_S_I32", ":", "case", "WebAssembly", "::", "REM_S_I64", ":", "case", "WebAssembly", "::", "DIV_U_I32", ":", "case", "WebAssembly", "::", "DIV_U_I64", ":", "case", "WebAssembly", "::", "REM_U_I32", ":", "case", "WebAssembly", "::", "REM_U_I64", ":", "case", "WebAssembly", "::", "I32_TRUNC_S_F32", ":", "case", "WebAssembly", "::", "I64_TRUNC_S_F32", ":", "case", "WebAssembly", "::", "I32_TRUNC_S_F64", ":", "case", "WebAssembly", "::", "I64_TRUNC_S_F64", ":", "case", "WebAssembly", "::", "I32_TRUNC_U_F32", ":", "case", "WebAssembly", "::", "I64_TRUNC_U_F32", ":", "case", "WebAssembly", "::", "I32_TRUNC_U_F64", ":", "case", "WebAssembly", "::", "I64_TRUNC_U_F64", ":", "break", ";", "default", ":", "if", "(", "!", "MI", ".", "isCall", "(", ")", ")", "{", "Write", "=", "true", ";", "Effects", "=", "true", ";", "}", "break", ";", "}", "}", "if", "(", "MI", ".", "hasUnmodeledSideEffects", "(", ")", ")", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "case", "WebAssembly", "::", "DIV_S_I32", ":", "case", "WebAssembly", "::", "DIV_S_I64", ":", "case", "WebAssembly", "::", "REM_S_I32", ":", "case", "WebAssembly", "::", "REM_S_I64", ":", "case", "WebAssembly", "::", "DIV_U_I32", ":", "case", "WebAssembly", "::", "DIV_U_I64", ":", "case", "WebAssembly", "::", "REM_U_I32", ":", "case", "WebAssembly", "::", "REM_U_I64", ":", "case", "WebAssembly", "::", "I32_TRUNC_S_F32", ":", "case", "WebAssembly", "::", "I64_TRUNC_S_F32", ":", "case", "WebAssembly", "::", "I32_TRUNC_S_F64", ":", "case", "WebAssembly", "::", "I64_TRUNC_S_F64", ":", "case", "WebAssembly", "::", "I32_TRUNC_U_F32", ":", "case", "WebAssembly", "::", "I64_TRUNC_U_F32", ":", "case", "WebAssembly", "::", "I32_TRUNC_U_F64", ":", "case", "WebAssembly", "::", "I64_TRUNC_U_F64", ":", "break", ";", "default", ":", "Effects", "=", "true", ";", "break", ";", "}", "}", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "WebAssembly", "::", "GLOBAL_SET_I32", "&&", "strcmp", "(", "MI", ".", "getOperand", "(", "0", ")", ".", "getSymbolName", "(", ")", ",", "\"__stack_pointer\"", ")", "==", "0", ")", "StackPointer", "=", "true", ";", "if", "(", "MI", ".", "isCall", "(", ")", ")", "{", "unsigned", "CalleeOpNo", "=", "WebAssembly", "::", "getCalleeOpNo", "(", "MI", ")", ";", "QueryCallee", "(", "MI", ",", "CalleeOpNo", ",", "Read", ",", "Write", ",", "Effects", ",", "StackPointer", ")", ";", "}", "}", "</s>" ]

[ "Query", "Liveness", "at", "Idx", "." ]

[ "WebAssembly", "WebAssembly::DIV_S_I32", "WebAssembly::DIV_S_I64", "WebAssembly::REM_S_I32", "WebAssembly::REM_S_I64", "WebAssembly::DIV_U_I32", "WebAssembly::DIV_U_I64", "WebAssembly::REM_U_I32", "WebAssembly::REM_U_I64", "WebAssembly::I32_TRUNC_S_F32", "WebAssembly::I64_TRUNC_S_F32", "WebAssembly::I32_TRUNC_S_F64", "WebAssembly::I64_TRUNC_S_F64", "WebAssembly::I32_TRUNC_U_F32", "WebAssembly::I64_TRUNC_U_F32", "WebAssembly::I32_TRUNC_U_F64", "WebAssembly::I64_TRUNC_U_F64", "WebAssembly::DIV_S_I32", "WebAssembly::DIV_S_I64", "WebAssembly::REM_S_I32", "WebAssembly::REM_S_I64", "WebAssembly::DIV_U_I32", "WebAssembly::DIV_U_I64", "WebAssembly::REM_U_I32", "WebAssembly::REM_U_I64", "WebAssembly::I32_TRUNC_S_F32", "WebAssembly::I64_TRUNC_S_F32", "WebAssembly::I32_TRUNC_S_F64", "WebAssembly::I64_TRUNC_S_F64", "WebAssembly::I32_TRUNC_U_F32", "WebAssembly::I64_TRUNC_U_F32", "WebAssembly::I32_TRUNC_U_F64", "WebAssembly::I64_TRUNC_U_F64", "WebAssembly::GLOBAL_SET_I32", "0", "\"__stack_pointer\"", "0", "WebAssembly::getCalleeOpNo" ]

[]

[ "<s>", "SDNode", "*", "M680x0DAGToDAGISel", "::", "getGlobalBaseReg", "(", ")", "{", "unsigned", "GlobalBaseReg", "=", "getInstrInfo", "(", ")", "->", "getGlobalBaseReg", "(", "MF", ")", ";", "auto", "&", "DL", "=", "MF", "->", "getDataLayout", "(", ")", ";", "return", "CurDAG", "->", "getRegister", "(", "GlobalBaseReg", ",", "TLI", "->", "getPointerTy", "(", "DL", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

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

[ "M680x0", "M680x0" ]

[]

[ "<s>", "const", "HexagonLDBackend", "&", "getTarget", "(", ")", "const", "{", "return", "m_Target", ";", "}", "</s>" ]

[ "getTarget", "-", "Return", "the", "target", "machine", "this", "machine", "code", "is", "compiled", "with" ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "static", "int", "try_constant_tricks", "(", "HOST_WIDE_INT", "value", ",", "HOST_WIDE_INT", "*", "x", ",", "HOST_WIDE_INT", "*", "y", ")", "{", "HOST_WIDE_INT", "i", ";", "unsigned", "HOST_WIDE_INT", "bit", ",", "shf", ",", "rot", ";", "if", "(", "const_ok_for_mcore", "(", "value", ")", ")", "return", "1", ";", "if", "(", "!", "TARGET_HARDLIT", ")", "return", "0", ";", "if", "(", "const_ok_for_mcore", "(", "~", "value", ")", ")", "{", "*", "x", "=", "~", "value", ";", "return", "2", ";", "}", "for", "(", "i", "=", "1", ";", "i", "<=", "32", ";", "i", "++", ")", "{", "if", "(", "const_ok_for_mcore", "(", "value", "-", "i", ")", ")", "{", "*", "x", "=", "value", "-", "i", ";", "*", "y", "=", "i", ";", "return", "3", ";", "}", "if", "(", "const_ok_for_mcore", "(", "value", "+", "i", ")", ")", "{", "*", "x", "=", "value", "+", "i", ";", "*", "y", "=", "i", ";", "return", "4", ";", "}", "}", "bit", "=", "0x80000000ULL", ";", "for", "(", "i", "=", "0", ";", "i", "<=", "31", ";", "i", "++", ")", "{", "if", "(", "const_ok_for_mcore", "(", "i", "-", "value", ")", ")", "{", "*", "x", "=", "i", "-", "value", ";", "*", "y", "=", "i", ";", "return", "5", ";", "}", "if", "(", "const_ok_for_mcore", "(", "value", "&", "~", "bit", ")", ")", "{", "*", "y", "=", "bit", ";", "*", "x", "=", "value", "&", "~", "bit", ";", "return", "6", ";", "}", "if", "(", "const_ok_for_mcore", "(", "value", "|", "bit", ")", ")", "{", "*", "y", "=", "~", "bit", ";", "*", "x", "=", "value", "|", "bit", ";", "return", "7", ";", "}", "bit", ">>=", "1", ";", "}", "shf", "=", "value", ";", "rot", "=", "value", ";", "for", "(", "i", "=", "1", ";", "i", "<", "31", ";", "i", "++", ")", "{", "int", "c", ";", "c", "=", "rot", "<<", "31", ";", "rot", ">>=", "1", ";", "rot", "&=", "0x7FFFFFFF", ";", "rot", "|=", "c", ";", "if", "(", "const_ok_for_mcore", "(", "rot", ")", ")", "{", "*", "y", "=", "i", ";", "*", "x", "=", "rot", ";", "return", "8", ";", "}", "if", "(", "shf", "&", "1", ")", "shf", "=", "0", ";", "shf", ">>=", "1", ";", "if", "(", "shf", "!=", "0", "&&", "const_ok_for_mcore", "(", "shf", ")", ")", "{", "*", "y", "=", "i", ";", "*", "x", "=", "shf", ";", "return", "9", ";", "}", "}", "if", "(", "(", "value", "%", "3", ")", "==", "0", "&&", "const_ok_for_mcore", "(", "value", "/", "3", ")", ")", "{", "*", "x", "=", "value", "/", "3", ";", "return", "10", ";", "}", "if", "(", "(", "value", "%", "5", ")", "==", "0", "&&", "const_ok_for_mcore", "(", "value", "/", "5", ")", ")", "{", "*", "x", "=", "value", "/", "5", ";", "return", "11", ";", "}", "return", "0", ";", "}", "</s>" ]

[ "Try", "tricks", "to", "load", "a", "constant", "inline", "and", "return", "the", "trick", "number", "if", "success", "(", "0", "is", "non-inlinable", ")", ".", "0", ":", "not", "inlinable", "1", ":", "single", "instruction", "(", "do", "the", "usual", "thing", ")", "2", ":", "single", "insn", "followed", "by", "a", "'not", "'", "3", ":", "single", "insn", "followed", "by", "a", "subi", "4", ":", "single", "insn", "followed", "by", "an", "addi", "5", ":", "single", "insn", "followed", "by", "rsubi", "6", ":", "single", "insn", "followed", "by", "bseti", "7", ":", "single", "insn", "followed", "by", "bclri", "8", ":", "single", "insn", "followed", "by", "rotli", "9", ":", "single", "insn", "followed", "by", "lsli", "10", ":", "single", "insn", "followed", "by", "ixh", "11", ":", "single", "insn", "followed", "by", "ixw", "." ]

[ "mcore", "1", "0", "2", "1", "32", "3", "4", "0x80000000ULL", "0", "31", "5", "6", "7", "1", "1", "31", "31", "1", "0x7FFFFFFF", "8", "1", "0", "1", "0", "9", "3", "0", "3", "3", "10", "5", "0", "5", "5", "11", "0" ]

[]

[ "<s>", "const", "BitTracker", "::", "RegisterCell", "&", "lookup", "(", "unsigned", "VR", ")", "{", "unsigned", "RInd", "=", "TargetRegisterInfo", "::", "virtReg2Index", "(", "VR", ")", ";", "if", "(", "RInd", ">=", "CVect", ".", "size", "(", ")", ")", "CVect", ".", "resize", "(", "std", "::", "max", "(", "RInd", "+", "16", ",", "32U", ")", ",", "0", ")", ";", "const", "BitTracker", "::", "RegisterCell", "*", "CP", "=", "CVect", "[", "RInd", "]", ";", "if", "(", "CP", "==", "0", ")", "CP", "=", "CVect", "[", "RInd", "]", "=", "&", "BT", ".", "lookup", "(", "VR", ")", ";", "return", "*", "CP", ";", "}", "</s>" ]

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

[ "Hexagon", "16", "32U", "0", "0" ]

[]

[ "<s>", "bool", "CSKYConstantIslands", "::", "isBBInRange", "(", "MachineInstr", "*", "MI", ",", "MachineBasicBlock", "*", "DestBB", ",", "unsigned", "MaxDisp", ")", "{", "unsigned", "BrOffset", "=", "getOffsetOf", "(", "MI", ")", ";", "unsigned", "DestOffset", "=", "BBInfo", "[", "DestBB", "->", "getNumber", "(", ")", "]", ".", "Offset", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Branch of destination \"", "<<", "printMBBReference", "(", "*", "DestBB", ")", "<<", "\" from \"", "<<", "printMBBReference", "(", "*", "MI", "->", "getParent", "(", ")", ")", "<<", "\" max delta=\"", "<<", "MaxDisp", "<<", "\" from \"", "<<", "getOffsetOf", "(", "MI", ")", "<<", "\" to \"", "<<", "DestOffset", "<<", "\" offset \"", "<<", "int", "(", "DestOffset", "-", "BrOffset", ")", "<<", "\"\\t\"", "<<", "*", "MI", ")", ";", "if", "(", "BrOffset", "<=", "DestOffset", ")", "{", "if", "(", "DestOffset", "-", "BrOffset", "<=", "MaxDisp", ")", "return", "true", ";", "}", "else", "{", "if", "(", "BrOffset", "-", "DestOffset", "<=", "MaxDisp", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "isBBInRange", "-", "Returns", "true", "if", "the", "distance", "between", "specific", "MI", "and", "specific", "BB", "can", "fit", "in", "MI", "'s", "displacement", "field", "." ]

[ "CSKY", "CSKY", "\"Branch of destination \"", "\" from \"", "\" max delta=\"", "\" from \"", "\" to \"", "\" offset \"", "\"\\t\"" ]

[]

[ "<s>", "static", "inline", "int", "desc_is_active", "(", "unsigned", "char", "qp", ",", "unw_word", "t", ",", "struct", "unw_state_record", "*", "sr", ")", "{", "if", "(", "sr", "->", "when_target", "<=", "sr", "->", "region_start", "+", "MIN", "(", "(", "int", ")", "t", ",", "sr", "->", "region_len", "-", "1", ")", ")", "return", "0", ";", "if", "(", "qp", ">", "0", ")", "{", "if", "(", "(", "sr", "->", "pr_val", "&", "(", "1UL", "<<", "qp", ")", ")", "==", "0", ")", "return", "0", ";", "sr", "->", "pr_mask", "|=", "(", "1UL", "<<", "qp", ")", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "General", "descriptors", "." ]

[ "ia64", "1", "0", "0", "1UL", "0", "0", "1UL", "1" ]

[]

[ "<s>", "static", "void", "ATTRIBUTE_UNUSED", "i386_output_dwarf_dtprel", "(", "FILE", "*", "file", ",", "int", "size", ",", "rtx", "x", ")", "{", "fputs", "(", "ASM_LONG", ",", "file", ")", ";", "output_addr_const", "(", "file", ",", "x", ")", ";", "fputs", "(", "\"@dtpoff\"", ",", "file", ")", ";", "switch", "(", "size", ")", "{", "case", "4", ":", "break", ";", "case", "8", ":", "fputs", "(", "\", 0\"", ",", "file", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

[ "This", "is", "called", "from", "dwarf2out.cc", "via", "TARGET_ASM_OUTPUT_DWARF_DTPREL", ".", "We", "need", "to", "emit", "DTP-relative", "relocations", "." ]

[ "i386", "\"@dtpoff\"", "4", "8", "\", 0\"" ]

[]

[ "<s>", "virtual", "void", "registerRoots", "(", ")", "{", "}", "</s>" ]

[ "Notify", "this", "strategy", "that", "all", "roots", "have", "been", "released", "(", "including", "those", "that", "depend", "on", "EntrySU", "or", "ExitSU", ")", "." ]

[ "Patmos" ]

[]

[ "<s>", "static", "void", "mips_file_start", "(", "void", ")", "{", "default_file_start", "(", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.section .mdebug.%s\\n\\t.previous\\n\"", ",", "mips_mdebug_abi_name", "(", ")", ")", ";", "if", "(", "mips_abi", "==", "ABI_EABI", "||", "mips_abi", "==", "ABI_O64", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.section .gcc_compiled_long%d\\n\"", "\"\\t.previous\\n\"", ",", "TARGET_LONG64", "?", "64", ":", "32", ")", ";", "if", "(", "HAVE_AS_NAN", "||", "mips_nan", "!=", "MIPS_IEEE_754_DEFAULT", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.nan\\t%s\\n\"", ",", "mips_nan", "==", "MIPS_IEEE_754_2008", "?", "\"2008\"", ":", "\"legacy\"", ")", ";", "if", "(", "TARGET_NO_FLOAT", ")", "fputs", "(", "\"\\t.gnu_attribute 4, 0\\n\"", ",", "asm_out_file", ")", ";", ";", "else", "if", "(", "!", "TARGET_HARD_FLOAT_ABI", ")", "fputs", "(", "\"\\t.module\\tsoftfloat\\n\"", ",", "asm_out_file", ")", ";", "else", "if", "(", "!", "TARGET_DOUBLE_FLOAT", ")", "fputs", "(", "\"\\t.module\\tsinglefloat\\n\"", ",", "asm_out_file", ")", ";", "else", "if", "(", "TARGET_FLOATXX", ")", "fputs", "(", "\"\\t.module\\tfp=xx\\n\"", ",", "asm_out_file", ")", ";", "else", "if", "(", "TARGET_FLOAT64", ")", "fputs", "(", "\"\\t.module\\tfp=64\\n\"", ",", "asm_out_file", ")", ";", "else", "fputs", "(", "\"\\t.module\\tfp=32\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "TARGET_ODD_SPREG", ")", "fputs", "(", "\"\\t.module\\toddspreg\\n\"", ",", "asm_out_file", ")", ";", "else", "fputs", "(", "\"\\t.module\\tnooddspreg\\n\"", ",", "asm_out_file", ")", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.module\\tarch=%s\\n\"", ",", "mips_arch_info", "->", "name", ")", ";", "if", "(", "TARGET_DSPR2", ")", "fputs", "(", "\"\\t.module\\tdspr2\\n\"", ",", "asm_out_file", ")", ";", "else", "if", "(", "TARGET_DSP", ")", "fputs", "(", "\"\\t.module\\tdsp\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "TARGET_EVA", ")", "fputs", "(", "\"\\t.module\\teva\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "TARGET_MCU", ")", "fputs", "(", "\"\\t.module\\tmcu\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "TARGET_MDMX", ")", "fputs", "(", "\"\\t.module\\tmdmx\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "TARGET_MIPS3D", ")", "fputs", "(", "\"\\t.module\\tmips3d\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "TARGET_MT", ")", "fputs", "(", "\"\\t.module\\tmt\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "TARGET_SMARTMIPS", ")", "fputs", "(", "\"\\t.module\\tsmartmips\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "TARGET_VIRT", ")", "fputs", "(", "\"\\t.module\\tvirt\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "TARGET_MSA", ")", "fputs", "(", "\"\\t.module\\tmsa\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "TARGET_XPA", ")", "fputs", "(", "\"\\t.module\\txpa\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "TARGET_CRC", ")", "fputs", "(", "\"\\t.module\\tcrc\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "TARGET_GINV", ")", "fputs", "(", "\"\\t.module\\tginv\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "TARGET_LOONGSON_MMI", ")", "fputs", "(", "\"\\t.module\\tloongson-mmi\\n\"", ",", "asm_out_file", ")", ";", "if", "(", "TARGET_LOONGSON_EXT2", ")", "fputs", "(", "\"\\t.module\\tloongson-ext2\\n\"", ",", "asm_out_file", ")", ";", "else", "if", "(", "TARGET_LOONGSON_EXT", ")", "fputs", "(", "\"\\t.module\\tloongson-ext\\n\"", ",", "asm_out_file", ")", ";", "{", "int", "attr", ";", "if", "(", "TARGET_NO_FLOAT", ")", "attr", "=", "0", ";", "else", "if", "(", "!", "TARGET_HARD_FLOAT_ABI", ")", "attr", "=", "3", ";", "else", "if", "(", "!", "TARGET_DOUBLE_FLOAT", ")", "attr", "=", "2", ";", "else", "if", "(", "TARGET_FLOATXX", ")", "attr", "=", "5", ";", "else", "if", "(", "mips_abi", "==", "ABI_32", "&&", "TARGET_FLOAT64", "&&", "TARGET_ODD_SPREG", ")", "attr", "=", "6", ";", "else", "if", "(", "mips_abi", "==", "ABI_32", "&&", "TARGET_FLOAT64", ")", "attr", "=", "7", ";", "else", "attr", "=", "1", ";", "fprintf", "(", "asm_out_file", ",", "\"\\t.gnu_attribute 4, %d\\n\"", ",", "attr", ")", ";", "if", "(", "ISA_HAS_MSA", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.gnu_attribute 8, 1\\n\"", ")", ";", "}", "if", "(", "TARGET_ABICALLS", ")", "{", "fprintf", "(", "asm_out_file", ",", "\"\\t.abicalls\\n\"", ")", ";", "if", "(", "TARGET_ABICALLS_PIC0", ")", "fprintf", "(", "asm_out_file", ",", "\"\\t.option\\tpic0\\n\"", ")", ";", "}", "if", "(", "flag_verbose_asm", ")", "fprintf", "(", "asm_out_file", ",", "\"\\n%s -G value = %d, Arch = %s, ISA = %d\\n\"", ",", "ASM_COMMENT_START", ",", "mips_small_data_threshold", ",", "mips_arch_info", "->", "name", ",", "mips_isa", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_ASM_FILE_START", "." ]

[ "mips", "\"\\t.section .mdebug.%s\\n\\t.previous\\n\"", "\"\\t.section .gcc_compiled_long%d\\n\"", "\"\\t.previous\\n\"", "64", "32", "\"\\t.nan\\t%s\\n\"", "\"2008\"", "\"legacy\"", "\"\\t.gnu_attribute 4, 0\\n\"", "\"\\t.module\\tsoftfloat\\n\"", "\"\\t.module\\tsinglefloat\\n\"", "\"\\t.module\\tfp=xx\\n\"", "\"\\t.module\\tfp=64\\n\"", "\"\\t.module\\tfp=32\\n\"", "\"\\t.module\\toddspreg\\n\"", "\"\\t.module\\tnooddspreg\\n\"", "\"\\t.module\\tarch=%s\\n\"", "\"\\t.module\\tdspr2\\n\"", "\"\\t.module\\tdsp\\n\"", "\"\\t.module\\teva\\n\"", "\"\\t.module\\tmcu\\n\"", "\"\\t.module\\tmdmx\\n\"", "\"\\t.module\\tmips3d\\n\"", "\"\\t.module\\tmt\\n\"", "\"\\t.module\\tsmartmips\\n\"", "\"\\t.module\\tvirt\\n\"", "\"\\t.module\\tmsa\\n\"", "\"\\t.module\\txpa\\n\"", "\"\\t.module\\tcrc\\n\"", "\"\\t.module\\tginv\\n\"", "\"\\t.module\\tloongson-mmi\\n\"", "\"\\t.module\\tloongson-ext2\\n\"", "\"\\t.module\\tloongson-ext\\n\"", "0", "3", "2", "5", "6", "7", "1", "\"\\t.gnu_attribute 4, %d\\n\"", "\"\\t.gnu_attribute 8, 1\\n\"", "\"\\t.abicalls\\n\"", "\"\\t.option\\tpic0\\n\"", "\"\\n%s -G value = %d, Arch = %s, ISA = %d\\n\"" ]

[]

[ "<s>", "int", "c4x_hard_regno_rename_ok", "(", "unsigned", "int", "regno1", ",", "unsigned", "int", "regno2", ")", "{", "if", "(", "IS_FLOAT_CALL_SAVED_REGNO", "(", "regno1", ")", "&&", "IS_INT_CALL_SAVED_REGNO", "(", "regno2", ")", ")", "return", "0", ";", "if", "(", "IS_INT_CALL_SAVED_REGNO", "(", "regno1", ")", "&&", "IS_FLOAT_CALL_SAVED_REGNO", "(", "regno2", ")", ")", "return", "0", ";", "if", "(", "IS_EXT_REGNO", "(", "regno1", ")", "&&", "!", "IS_EXT_REGNO", "(", "regno2", ")", ")", "return", "0", ";", "if", "(", "IS_EXT_REGNO", "(", "regno2", ")", "&&", "!", "IS_EXT_REGNO", "(", "regno1", ")", ")", "return", "0", ";", "return", "1", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "REGNO1", "can", "be", "renamed", "to", "REGNO2", "." ]

[ "c4x", "0", "0", "0", "0", "1" ]

[]

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

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

[ "SHUXI", "SHUXI" ]

[]

[ "<s>", "bool", "ARMTargetLowering", "::", "functionArgumentNeedsConsecutiveRegisters", "(", "Type", "*", "Ty", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ")", "const", "{", "if", "(", "getEffectiveCallingConv", "(", "CallConv", ",", "isVarArg", ")", "!=", "CallingConv", "::", "ARM_AAPCS_VFP", ")", "return", "false", ";", "HABaseType", "Base", "=", "HA_UNKNOWN", ";", "uint64_t", "Members", "=", "0", ";", "bool", "IsHA", "=", "isHomogeneousAggregate", "(", "Ty", ",", "Base", ",", "Members", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"isHA: \"", "<<", "IsHA", "<<", "\" \"", ";", "Ty", "->", "dump", "(", ")", ")", ";", "bool", "IsIntArray", "=", "Ty", "->", "isArrayTy", "(", ")", "&&", "Ty", "->", "getArrayElementType", "(", ")", "->", "isIntegerTy", "(", ")", ";", "return", "IsHA", "||", "IsIntArray", ";", "}", "</s>" ]

[ "Returns", "true", "if", "an", "argument", "of", "type", "Ty", "needs", "to", "be", "passed", "in", "a", "contiguous", "block", "of", "registers", "in", "calling", "convention", "CallConv", "." ]

[ "ARM", "ARM", "ARM", "0", "\"isHA: \"", "\" \"" ]

[]

[ "<s>", "rtx", "aarch64_pfalse_reg", "(", "machine_mode", "mode", ")", "{", "gcc_assert", "(", "GET_MODE_CLASS", "(", "mode", ")", "==", "MODE_VECTOR_BOOL", ")", ";", "rtx", "reg", "=", "force_reg", "(", "VNx16BImode", ",", "CONST0_RTX", "(", "VNx16BImode", ")", ")", ";", "return", "gen_lowpart", "(", "mode", ",", "reg", ")", ";", "}", "</s>" ]

[ "Return", "an", "all-false", "predicate", "register", "of", "mode", "MODE", "." ]

[ "aarch64" ]

[]

[ "<s>", "void", "Cpu0AsmPrinter", "::", "emitFrameDirective", "(", ")", "{", "const", "TargetRegisterInfo", "&", "RI", "=", "*", "TM", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "stackReg", "=", "RI", ".", "getFrameRegister", "(", "*", "MF", ")", ";", "unsigned", "returnReg", "=", "RI", ".", "getRARegister", "(", ")", ";", "unsigned", "stackSize", "=", "MF", "->", "getFrameInfo", "(", ")", "->", "getStackSize", "(", ")", ";", "if", "(", "OutStreamer", ".", "hasRawTextSupport", "(", ")", ")", "OutStreamer", ".", "EmitRawText", "(", "\"\\t.frame\\t$\"", "+", "StringRef", "(", "Cpu0InstPrinter", "::", "getRegisterName", "(", "stackReg", ")", ")", ".", "lower", "(", ")", "+", "\",\"", "+", "Twine", "(", "stackSize", ")", "+", "\",$\"", "+", "StringRef", "(", "Cpu0InstPrinter", "::", "getRegisterName", "(", "returnReg", ")", ")", ".", "lower", "(", ")", ")", ";", "}", "</s>" ]

[ "Frame", "Directive", "." ]

[ "Cpu0", "Cpu0", "\"\\t.frame\\t$\"", "Cpu0", "\",\"", "\",$\"", "Cpu0" ]

[]

[ "<s>", "static", "int", "mips_set_reg_reg_piece_cost", "(", "machine_mode", "mode", ",", "unsigned", "int", "units", ")", "{", "return", "COSTS_N_INSNS", "(", "(", "GET_MODE_SIZE", "(", "mode", ")", "+", "units", "-", "1", ")", "/", "units", ")", ";", "}", "</s>" ]

[ "Return", "the", "cost", "of", "moving", "between", "two", "registers", "of", "mode", "MODE", ",", "assuming", "that", "the", "move", "will", "be", "in", "pieces", "of", "at", "most", "UNITS", "bytes", "." ]

[ "mips", "1" ]

[]

[ "<s>", "bool", "ARMAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "OperandVector", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "uint64_t", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "unsigned", "MatchResult", ";", "bool", "PendConditionalInstruction", "=", "false", ";", "SmallVector", "<", "NearMissInfo", ",", "4", ">", "NearMisses", ";", "MatchResult", "=", "MatchInstruction", "(", "Operands", ",", "Inst", ",", "NearMisses", ",", "MatchingInlineAsm", ",", "PendConditionalInstruction", ",", "Out", ")", ";", "switch", "(", "MatchResult", ")", "{", "case", "Match_Success", ":", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Parsed as: \"", ";", "Inst", ".", "dump_pretty", "(", "dbgs", "(", ")", ",", "MII", ".", "getName", "(", "Inst", ".", "getOpcode", "(", ")", ")", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "validateInstruction", "(", "Inst", ",", "Operands", ")", ")", "{", "forwardITPosition", "(", ")", ";", "return", "true", ";", "}", "{", "bool", "wasInITBlock", "=", "inITBlock", "(", ")", ";", "while", "(", "processInstruction", "(", "Inst", ",", "Operands", ",", "Out", ")", ")", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Changed to: \"", ";", "Inst", ".", "dump_pretty", "(", "dbgs", "(", ")", ",", "MII", ".", "getName", "(", "Inst", ".", "getOpcode", "(", ")", ")", ")", ";", "dbgs", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "wasInITBlock", "&&", "hasV8Ops", "(", ")", "&&", "isThumb", "(", ")", "&&", "!", "isV8EligibleForIT", "(", "&", "Inst", ")", ")", "{", "Warning", "(", "IDLoc", ",", "\"deprecated instruction in IT block\"", ")", ";", "}", "}", "forwardITPosition", "(", ")", ";", "if", "(", "Inst", ".", "getOpcode", "(", ")", "==", "ARM", "::", "ITasm", ")", "return", "false", ";", "Inst", ".", "setLoc", "(", "IDLoc", ")", ";", "if", "(", "PendConditionalInstruction", ")", "{", "PendingConditionalInsts", ".", "push_back", "(", "Inst", ")", ";", "if", "(", "isITBlockFull", "(", ")", "||", "isITBlockTerminator", "(", "Inst", ")", ")", "flushPendingInstructions", "(", "Out", ")", ";", "}", "else", "{", "Out", ".", "EmitInstruction", "(", "Inst", ",", "getSTI", "(", ")", ")", ";", "}", "return", "false", ";", "case", "Match_NearMisses", ":", "ReportNearMisses", "(", "NearMisses", ",", "IDLoc", ",", "Operands", ")", ";", "return", "true", ";", "case", "Match_MnemonicFail", ":", "{", "uint64_t", "FBS", "=", "ComputeAvailableFeatures", "(", "getSTI", "(", ")", ".", "getFeatureBits", "(", ")", ")", ";", "std", "::", "string", "Suggestion", "=", "ARMMnemonicSpellCheck", "(", "(", "(", "ARMOperand", "&", ")", "*", "Operands", "[", "0", "]", ")", ".", "getToken", "(", ")", ",", "FBS", ")", ";", "return", "Error", "(", "IDLoc", ",", "\"invalid instruction\"", "+", "Suggestion", ",", "(", "(", "ARMOperand", "&", ")", "*", "Operands", "[", "0", "]", ")", ".", "getLocRange", "(", ")", ")", ";", "}", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "4", "\"Parsed as: \"", "\"\\n\"", "\"Changed to: \"", "\"\\n\"", "\"deprecated instruction in IT block\"", "ARM::ITasm", "ARM", "ARM", "0", "\"invalid instruction\"", "ARM", "0", "\"Implement any new match types added!\"" ]

[]

[ "<s>", "bool", "X86CallLowering", "::", "lowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "&", "F", ",", "ArrayRef", "<", "ArrayRef", "<", "Register", ">>", "VRegs", ")", "const", "{", "if", "(", "F", ".", "arg_empty", "(", ")", ")", "return", "true", ";", "if", "(", "F", ".", "isVarArg", "(", ")", ")", "return", "false", ";", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "MachineRegisterInfo", "&", "MRI", "=", "MF", ".", "getRegInfo", "(", ")", ";", "auto", "DL", "=", "MF", ".", "getDataLayout", "(", ")", ";", "SmallVector", "<", "ArgInfo", ",", "8", ">", "SplitArgs", ";", "unsigned", "Idx", "=", "0", ";", "for", "(", "const", "auto", "&", "Arg", ":", "F", ".", "args", "(", ")", ")", "{", "if", "(", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "ByVal", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "InReg", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "StructRet", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "SwiftSelf", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "SwiftError", ")", "||", "Arg", ".", "hasAttribute", "(", "Attribute", "::", "Nest", ")", "||", "VRegs", "[", "Idx", "]", ".", "size", "(", ")", ">", "1", ")", "return", "false", ";", "ArgInfo", "OrigArg", "(", "VRegs", "[", "Idx", "]", ",", "Arg", ".", "getType", "(", ")", ")", ";", "setArgFlags", "(", "OrigArg", ",", "Idx", "+", "AttributeList", "::", "FirstArgIndex", ",", "DL", ",", "F", ")", ";", "if", "(", "!", "splitToValueTypes", "(", "OrigArg", ",", "SplitArgs", ",", "DL", ",", "MRI", ",", "[", "&", "]", "(", "ArrayRef", "<", "Register", ">", "Regs", ")", "{", "MIRBuilder", ".", "buildMerge", "(", "VRegs", "[", "Idx", "]", "[", "0", "]", ",", "Regs", ")", ";", "}", ")", ")", "return", "false", ";", "Idx", "++", ";", "}", "MachineBasicBlock", "&", "MBB", "=", "MIRBuilder", ".", "getMBB", "(", ")", ";", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "MIRBuilder", ".", "setInstr", "(", "*", "MBB", ".", "begin", "(", ")", ")", ";", "FormalArgHandler", "Handler", "(", "MIRBuilder", ",", "MRI", ",", "CC_X86", ")", ";", "if", "(", "!", "handleAssignments", "(", "MIRBuilder", ",", "SplitArgs", ",", "Handler", ")", ")", "return", "false", ";", "MIRBuilder", ".", "setMBB", "(", "MBB", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "This", "hook", "must", "be", "implemented", "to", "lower", "the", "incoming", "(", "formal", ")", "arguments", ",", "described", "by", "VRegs", ",", "for", "GlobalISel", "." ]

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

[]

[ "<s>", "unsigned", "WebAssemblyFastISel", "::", "signExtend", "(", "unsigned", "Reg", ",", "const", "Value", "*", "V", ",", "MVT", "::", "SimpleValueType", "From", ",", "MVT", "::", "SimpleValueType", "To", ")", "{", "if", "(", "To", "==", "MVT", "::", "i64", ")", "{", "if", "(", "From", "==", "MVT", "::", "i64", ")", "return", "copyValue", "(", "Reg", ")", ";", "Reg", "=", "signExtendToI32", "(", "Reg", ",", "V", ",", "From", ")", ";", "Register", "Result", "=", "createResultReg", "(", "&", "WebAssembly", "::", "I64RegClass", ")", ";", "BuildMI", "(", "*", "FuncInfo", ".", "MBB", ",", "FuncInfo", ".", "InsertPt", ",", "DbgLoc", ",", "TII", ".", "get", "(", "WebAssembly", "::", "I64_EXTEND_S_I32", ")", ",", "Result", ")", ".", "addReg", "(", "Reg", ")", ";", "return", "Result", ";", "}", "if", "(", "To", "==", "MVT", "::", "i32", ")", "return", "signExtendToI32", "(", "Reg", ",", "V", ",", "From", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "a", "new", "range", "in", "the", "specified", "integer", "type", ",", "which", "must", "be", "strictly", "larger", "than", "the", "current", "type", "." ]

[ "WebAssembly", "WebAssembly", "MVT::SimpleValueType", "MVT::SimpleValueType", "MVT::i64", "MVT::i64", "WebAssembly::I64RegClass", "WebAssembly::I64_EXTEND_S_I32", "MVT::i32", "0" ]

[]

[ "<s>", "void", "print", "(", "raw_ostream", "&", "OS", ")", "const", "override", "{", "auto", "RegName", "=", "[", "]", "(", "unsigned", "Reg", ")", "{", "if", "(", "Reg", ")", "return", "RISCVInstPrinter", "::", "getRegisterName", "(", "Reg", ")", ";", "else", "return", "\"noreg\"", ";", "}", ";", "switch", "(", "Kind", ")", "{", "case", "KindTy", "::", "Immediate", ":", "OS", "<<", "*", "getImm", "(", ")", ";", "break", ";", "case", "KindTy", "::", "Register", ":", "OS", "<<", "\"<register \"", "<<", "RegName", "(", "getReg", "(", ")", ")", "<<", "\">\"", ";", "break", ";", "case", "KindTy", "::", "Token", ":", "OS", "<<", "\"'\"", "<<", "getToken", "(", ")", "<<", "\"'\"", ";", "break", ";", "case", "KindTy", "::", "SystemRegister", ":", "OS", "<<", "\"<sysreg: \"", "<<", "getSysReg", "(", ")", "<<", "'>'", ";", "break", ";", "case", "KindTy", "::", "VType", ":", "OS", "<<", "\"<vtype: \"", ";", "RISCVVType", "::", "printVType", "(", "getVType", "(", ")", ",", "OS", ")", ";", "OS", "<<", "'>'", ";", "break", ";", "}", "}", "</s>" ]

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

[ "RI5CY", "RISCV", "\"noreg\"", "\"<register \"", "\">\"", "\"'\"", "\"'\"", "\"<sysreg: \"", "\"<vtype: \"", "RISCV" ]

[]

[ "<s>", "int", "mips_load_store_insns", "(", "rtx", "mem", ",", "rtx_insn", "*", "insn", ")", "{", "machine_mode", "mode", ";", "bool", "might_split_p", ";", "rtx", "set", ";", "gcc_assert", "(", "MEM_P", "(", "mem", ")", ")", ";", "mode", "=", "GET_MODE", "(", "mem", ")", ";", "might_split_p", "=", "GET_MODE_SIZE", "(", "mode", ")", ">", "UNITS_PER_WORD", ";", "if", "(", "might_split_p", ")", "{", "set", "=", "single_set", "(", "insn", ")", ";", "if", "(", "set", "&&", "!", "mips_split_move_insn_p", "(", "SET_DEST", "(", "set", ")", ",", "SET_SRC", "(", "set", ")", ",", "insn", ")", ")", "might_split_p", "=", "false", ";", "}", "return", "mips_address_insns", "(", "XEXP", "(", "mem", ",", "0", ")", ",", "mode", ",", "might_split_p", ")", ";", "}", "</s>" ]

[ "Return", "the", "number", "of", "instructions", "needed", "to", "implement", "INSN", ",", "given", "that", "it", "loads", "from", "or", "stores", "to", "MEM", ".", "Assume", "that", "BASE_INSN_LENGTH", "is", "the", "length", "of", "one", "instruction", "." ]

[ "mips", "0" ]

[]

[ "<s>", "virtual", "unsigned", "int", "execute", "(", "function", "*", "fun", ")", "{", "return", "rs6000_analyze_swaps", "(", "fun", ")", ";", "}", "</s>" ]

[ "Main", "entry", "point", "for", "this", "pass", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "rtx", "frv_frame_offset_rtx", "(", "int", "offset", ")", "{", "rtx", "offset_rtx", "=", "GEN_INT", "(", "offset", ")", ";", "if", "(", "IN_RANGE", "(", "offset", ",", "-", "2048", ",", "2047", ")", ")", "return", "offset_rtx", ";", "else", "{", "rtx", "reg_rtx", "=", "gen_rtx_REG", "(", "SImode", ",", "OFFSET_REGNO", ")", ";", "if", "(", "IN_RANGE", "(", "offset", ",", "-", "32768", ",", "32767", ")", ")", "emit_insn", "(", "gen_movsi", "(", "reg_rtx", ",", "offset_rtx", ")", ")", ";", "else", "{", "emit_insn", "(", "gen_movsi_high", "(", "reg_rtx", ",", "offset_rtx", ")", ")", ";", "emit_insn", "(", "gen_movsi_lo_sum", "(", "reg_rtx", ",", "offset_rtx", ")", ")", ";", "}", "return", "reg_rtx", ";", "}", "}", "</s>" ]

[ "Return", "an", "rtx", "with", "the", "value", "OFFSET", ",", "which", "will", "either", "be", "a", "register", "or", "a", "signed", "12-bit", "integer", ".", "It", "can", "be", "used", "as", "the", "second", "operand", "in", "an", "``", "add", "''", "instruction", ",", "or", "as", "the", "index", "in", "a", "load", "or", "store", ".", "The", "function", "returns", "a", "constant", "rtx", "if", "OFFSET", "is", "small", "enough", ",", "otherwise", "it", "loads", "the", "constant", "into", "register", "OFFSET_REGNO", "and", "returns", "that", "." ]

[ "frv", "2048", "2047", "32768", "32767" ]

[]

[ "<s>", "void", "ix86_expand_push", "(", "enum", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "rtx", "tmp", ";", "tmp", "=", "expand_simple_binop", "(", "Pmode", ",", "PLUS", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "-", "GET_MODE_SIZE", "(", "mode", ")", ")", ",", "stack_pointer_rtx", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "if", "(", "tmp", "!=", "stack_pointer_rtx", ")", "emit_move_insn", "(", "stack_pointer_rtx", ",", "tmp", ")", ";", "tmp", "=", "gen_rtx_MEM", "(", "mode", ",", "stack_pointer_rtx", ")", ";", "emit_move_insn", "(", "tmp", ",", "x", ")", ";", "}", "</s>" ]

[ "Expand", "a", "push", "in", "MODE", ".", "This", "is", "some", "mode", "for", "which", "we", "do", "not", "support", "proper", "push", "instructions", ",", "at", "least", "from", "the", "registers", "that", "we", "expect", "the", "value", "to", "live", "in", "." ]

[ "i386", "1" ]

[]

[ "<s>", "BitVector", "MMIXRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "markSuperRegs", "(", "Reserved", ",", "MMIX", "::", "r254", ")", ";", "markSuperRegs", "(", "Reserved", ",", "MMIX", "::", "r253", ")", ";", "markSuperRegs", "(", "Reserved", ",", "MMIX", "::", "r252", ")", ";", "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", "." ]

[ "MMIX", "MMIX", "MMIX::r254", "MMIX::r253", "MMIX::r252" ]

[]

[ "<s>", "void", "LanaiFrameLowering", "::", "determineFrameLayout", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "LanaiRegisterInfo", "*", "LRI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "unsigned", "FrameSize", "=", "MFI", "->", "getStackSize", "(", ")", ";", "unsigned", "StackAlign", "=", "LRI", "->", "needsStackRealignment", "(", "MF", ")", "?", "MFI", "->", "getMaxAlignment", "(", ")", ":", "getStackAlignment", "(", ")", ";", "unsigned", "MaxCallFrameSize", "=", "MFI", "->", "getMaxCallFrameSize", "(", ")", ";", "if", "(", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", "MaxCallFrameSize", "=", "alignTo", "(", "MaxCallFrameSize", ",", "StackAlign", ")", ";", "MFI", "->", "setMaxCallFrameSize", "(", "MaxCallFrameSize", ")", ";", "if", "(", "!", "(", "hasReservedCallFrame", "(", "MF", ")", "&&", "MFI", "->", "adjustsStack", "(", ")", ")", ")", "FrameSize", "+=", "MaxCallFrameSize", ";", "FrameSize", "=", "alignTo", "(", "FrameSize", ",", "StackAlign", ")", ";", "MFI", "->", "setStackSize", "(", "FrameSize", ")", ";", "}", "</s>" ]

[ "Determine", "the", "frame", "layout", "but", "do", "not", "update", "the", "machine", "function", "." ]

[ "Lanai", "Lanai", "Lanai" ]

[]

[ "<s>", "bool", "isDesirableToTransformToIntegerOp", "(", "unsigned", "Opc", ",", "EVT", "VT", ")", "const", "override", "{", "if", "(", "Opc", "!=", "ISD", "::", "LOAD", "&&", "Opc", "!=", "ISD", "::", "STORE", ")", "return", "false", ";", "if", "(", "VT", "!=", "MVT", "::", "f32", "&&", "VT", "!=", "MVT", "::", "f64", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "for", "dag", "combiner", "to", "transform", "a", "floating", "point", "op", "of", "specified", "opcode", "to", "a", "equivalent", "op", "of", "an", "integer", "type", "." ]

[ "PowerPC", "ISD::LOAD", "ISD::STORE", "MVT::f32", "MVT::f64" ]

[]

[ "<s>", "void", "Hexagon_CCState", "::", "AnalyzeCallResult", "(", "EVT", "VT", ",", "Hexagon_CCAssignFn", "Fn", ")", "{", "if", "(", "Fn", "(", "0", ",", "VT", ",", "VT", ",", "CCValAssign", "::", "Full", ",", "ISD", "::", "ArgFlagsTy", "(", ")", ",", "*", "this", ",", "-", "1", ",", "-", "1", ",", "false", ")", ")", "{", "dbgs", "(", ")", "<<", "\"Call result has unhandled type \"", "<<", "VT", ".", "getEVTString", "(", ")", "<<", "\"\\n\"", ";", "abort", "(", ")", ";", "}", "}", "</s>" ]

[ "AnalyzeCallResult", "-", "Same", "as", "above", "except", "it", "'s", "specialized", "for", "calls", "which", "produce", "a", "single", "value", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "0", "ISD::ArgFlagsTy", "1", "1", "\"Call result has unhandled type \"", "\"\\n\"" ]

[]

[ "<s>", "bool", "small_data_operand", "(", "rtx", "op", ",", "machine_mode", "mode", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "!", "TARGET_SDATA_USE", ")", "return", "0", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "SYMBOL_REF", ")", "return", "SYMBOL_REF_SMALL_P", "(", "op", ")", ";", "if", "(", "GET_CODE", "(", "op", ")", "==", "CONST", "&&", "GET_CODE", "(", "XEXP", "(", "op", ",", "0", ")", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "satisfies_constraint_J", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "1", ")", ")", ")", "return", "SYMBOL_REF_SMALL_P", "(", "XEXP", "(", "XEXP", "(", "op", ",", "0", ")", ",", "0", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "for", "an", "operand", "in", "small", "memory", "on", "V.4/eabi", "." ]

[ "m32r", "0", "0", "0", "0", "0", "1", "0", "0", "0" ]

[]

[ "<s>", "bool", "GCNPassConfig", "::", "addIRTranslator", "(", ")", "{", "addPass", "(", "new", "IRTranslator", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "This", "method", "should", "install", "an", "IR", "translator", "pass", ",", "which", "converts", "from", "LLVM", "code", "to", "machine", "instructions", "with", "possibly", "generic", "opcodes", "." ]

[ "AMDGPU" ]

[]

[ "<s>", "static", "rtx", "nvptx_function_arg", "(", "cumulative_args_t", ",", "machine_mode", "mode", ",", "const_tree", ",", "bool", "named", ")", "{", "if", "(", "mode", "==", "VOIDmode", ")", "return", "NULL_RTX", ";", "if", "(", "named", ")", "return", "gen_reg_rtx", "(", "mode", ")", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Implement", "TARGET_FUNCTION_ARG", "." ]

[ "nvptx" ]

[]

[ "<s>", "bool", "CSKYFrameLowering", "::", "hasFP", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetRegisterInfo", "*", "RegInfo", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "MF", ".", "getTarget", "(", ")", ".", "Options", ".", "DisableFramePointerElim", "(", "MF", ")", "||", "RegInfo", "->", "hasStackRealignment", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", "||", "MFI", ".", "isFrameAddressTaken", "(", ")", ";", "}", "</s>" ]

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

[ "CSKY", "CSKY" ]

[]

[ "<s>", "bool", "loongarch_global_symbol_p", "(", "const_rtx", "x", ")", "{", "if", "(", "LABEL_REF_P", "(", "x", ")", ")", "return", "false", ";", "const_tree", "decl", "=", "SYMBOL_REF_DECL", "(", "x", ")", ";", "if", "(", "!", "decl", ")", "return", "!", "SYMBOL_REF_LOCAL_P", "(", "x", ")", "||", "SYMBOL_REF_EXTERNAL_P", "(", "x", ")", ";", "return", "DECL_P", "(", "decl", ")", "&&", "(", "TREE_PUBLIC", "(", "decl", ")", "||", "DECL_WEAK", "(", "decl", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "SYMBOL_REF", "X", "is", "associated", "with", "a", "global", "symbol", "(", "in", "the", "STB_GLOBAL", "sense", ")", "." ]

[ "loongarch" ]

[]

[ "<s>", "bool", "ix86_standard_x87sse_constant_load_p", "(", "const", "rtx_insn", "*", "insn", ",", "rtx", "dst", ")", "{", "rtx", "src", "=", "find_constant_src", "(", "insn", ")", ";", "gcc_assert", "(", "REG_P", "(", "dst", ")", ")", ";", "if", "(", "src", "==", "NULL", "||", "(", "SSE_REGNO_P", "(", "REGNO", "(", "dst", ")", ")", "&&", "standard_sse_constant_p", "(", "src", ",", "GET_MODE", "(", "dst", ")", ")", "!=", "1", ")", "||", "(", "STACK_REGNO_P", "(", "REGNO", "(", "dst", ")", ")", "&&", "standard_80387_constant_p", "(", "src", ")", "<", "1", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "INSN", "can", "be", "transformed", "from", "a", "memory", "load", "to", "a", "supported", "FP", "constant", "load", "." ]

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

[]