Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "const", "unsigned", "*", "MipsRegisterInfo", "::", "getCalleeSavedRegs", "(", "const", "MachineFunction", "*", "MF", ")", "const", "{", "static", "const", "unsigned", "SingleFloatOnlyCalleeSavedRegs", "[", "]", "=", "{", "Mips", "::", "F31", ",", "Mips", "::", "F30", ",", "Mips", "::", "F29", ",", "Mips", "::", "F28", ",", "Mips", "::", "F27", ",", "Mips", "::", "F26", ",", "Mips", "::", "F25", ",", "Mips", "::", "F24", ",", "Mips", "::", "F23", ",", "Mips", "::", "F22", ",", "Mips", "::", "F21", ",", "Mips", "::", "F20", ",", "Mips", "::", "RA", ",", "Mips", "::", "FP", ",", "Mips", "::", "S7", ",", "Mips", "::", "S6", ",", "Mips", "::", "S5", ",", "Mips", "::", "S4", ",", "Mips", "::", "S3", ",", "Mips", "::", "S2", ",", "Mips", "::", "S1", ",", "Mips", "::", "S0", ",", "0", "}", ";", "static", "const", "unsigned", "Mips32CalleeSavedRegs", "[", "]", "=", "{", "Mips", "::", "D15", ",", "Mips", "::", "D14", ",", "Mips", "::", "D13", ",", "Mips", "::", "D12", ",", "Mips", "::", "D11", ",", "Mips", "::", "D10", ",", "Mips", "::", "RA", ",", "Mips", "::", "FP", ",", "Mips", "::", "S7", ",", "Mips", "::", "S6", ",", "Mips", "::", "S5", ",", "Mips", "::", "S4", ",", "Mips", "::", "S3", ",", "Mips", "::", "S2", ",", "Mips", "::", "S1", ",", "Mips", "::", "S0", ",", "0", "}", ";", "static", "const", "unsigned", "N32CalleeSavedRegs", "[", "]", "=", "{", "Mips", "::", "D31_64", ",", "Mips", "::", "D29_64", ",", "Mips", "::", "D27_64", ",", "Mips", "::", "D25_64", ",", "Mips", "::", "D23_64", ",", "Mips", "::", "D21_64", ",", "Mips", "::", "RA_64", ",", "Mips", "::", "FP_64", ",", "Mips", "::", "GP_64", ",", "Mips", "::", "S7_64", ",", "Mips", "::", "S6_64", ",", "Mips", "::", "S5_64", ",", "Mips", "::", "S4_64", ",", "Mips", "::", "S3_64", ",", "Mips", "::", "S2_64", ",", "Mips", "::", "S1_64", ",", "Mips", "::", "S0_64", ",", "0", "}", ";", "static", "const", "unsigned", "N64CalleeSavedRegs", "[", "]", "=", "{", "Mips", "::", "D31_64", ",", "Mips", "::", "D30_64", ",", "Mips", "::", "D29_64", ",", "Mips", "::", "D28_64", ",", "Mips", "::", "D27_64", ",", "Mips", "::", "D26_64", ",", "Mips", "::", "D25_64", ",", "Mips", "::", "D24_64", ",", "Mips", "::", "RA_64", ",", "Mips", "::", "FP_64", ",", "Mips", "::", "GP_64", ",", "Mips", "::", "S7_64", ",", "Mips", "::", "S6_64", ",", "Mips", "::", "S5_64", ",", "Mips", "::", "S4_64", ",", "Mips", "::", "S3_64", ",", "Mips", "::", "S2_64", ",", "Mips", "::", "S1_64", ",", "Mips", "::", "S0_64", ",", "0", "}", ";", "if", "(", "Subtarget", ".", "isSingleFloat", "(", ")", ")", "return", "SingleFloatOnlyCalleeSavedRegs", ";", "else", "if", "(", "!", "Subtarget", ".", "hasMips64", "(", ")", ")", "return", "Mips32CalleeSavedRegs", ";", "else", "if", "(", "Subtarget", ".", "isABI_N32", "(", ")", ")", "return", "N32CalleeSavedRegs", ";", "assert", "(", "Subtarget", ".", "isABI_N64", "(", ")", ")", ";", "return", "N64CalleeSavedRegs", ";", "}", "</s>" ]

[ "Code", "Generation", "virtual", "methods", "..." ]

[ "Mips", "Mips", "Mips::F31", "Mips::F30", "Mips::F29", "Mips::F28", "Mips::F27", "Mips::F26", "Mips::F25", "Mips::F24", "Mips::F23", "Mips::F22", "Mips::F21", "Mips::F20", "Mips::RA", "Mips::FP", "Mips::S7", "Mips::S6", "Mips::S5", "Mips::S4", "Mips::S3", "Mips::S2", "Mips::S1", "Mips::S0", "0", "Mips", "Mips::D15", "Mips::D14", "Mips::D13", "Mips::D12", "Mips::D11", "Mips::D10", "Mips::RA", "Mips::FP", "Mips::S7", "Mips::S6", "Mips::S5", "Mips::S4", "Mips::S3", "Mips::S2", "Mips::S1", "Mips::S0", "0", "Mips::D31_64", "Mips::D29_64", "Mips::D27_64", "Mips::D25_64", "Mips::D23_64", "Mips::D21_64", "Mips::RA_64", "Mips::FP_64", "Mips::GP_64", "Mips::S7_64", "Mips::S6_64", "Mips::S5_64", "Mips::S4_64", "Mips::S3_64", "Mips::S2_64", "Mips::S1_64", "Mips::S0_64", "0", "Mips::D31_64", "Mips::D30_64", "Mips::D29_64", "Mips::D28_64", "Mips::D27_64", "Mips::D26_64", "Mips::D25_64", "Mips::D24_64", "Mips::RA_64", "Mips::FP_64", "Mips::GP_64", "Mips::S7_64", "Mips::S6_64", "Mips::S5_64", "Mips::S4_64", "Mips::S3_64", "Mips::S2_64", "Mips::S1_64", "Mips::S0_64", "0", "Mips", "Mips" ]

[]

[ "<s>", "bool", "arm_current_function_pac_enabled_p", "(", "void", ")", "{", "return", "(", "aarch_ra_sign_scope", "==", "AARCH_FUNCTION_ALL", "||", "(", "aarch_ra_sign_scope", "==", "AARCH_FUNCTION_NON_LEAF", "&&", "!", "crtl", "->", "is_leaf", ")", ")", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "return", "address", "signing", "mechanism", "is", "enabled", "." ]

[ "arm" ]

[]

[ "<s>", "bool", "AArch64CallLowering", "::", "LowerFormalArguments", "(", "MachineIRBuilder", "&", "MIRBuilder", ",", "const", "Function", "::", "ArgumentListType", "&", "Args", ",", "const", "SmallVectorImpl", "<", "unsigned", ">", "&", "VRegs", ")", "const", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "const", "Function", "&", "F", "=", "*", "MF", ".", "getFunction", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "ArgLocs", ";", "CCState", "CCInfo", "(", "F", ".", "getCallingConv", "(", ")", ",", "F", ".", "isVarArg", "(", ")", ",", "MF", ",", "ArgLocs", ",", "F", ".", "getContext", "(", ")", ")", ";", "unsigned", "NumArgs", "=", "Args", ".", "size", "(", ")", ";", "Function", "::", "const_arg_iterator", "CurOrigArg", "=", "Args", ".", "begin", "(", ")", ";", "const", "AArch64TargetLowering", "&", "TLI", "=", "*", "getTLI", "<", "AArch64TargetLowering", ">", "(", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "NumArgs", ";", "++", "i", ",", "++", "CurOrigArg", ")", "{", "MVT", "ValVT", "=", "MVT", "::", "getVT", "(", "CurOrigArg", "->", "getType", "(", ")", ")", ";", "CCAssignFn", "*", "AssignFn", "=", "TLI", ".", "CCAssignFnForCall", "(", "F", ".", "getCallingConv", "(", ")", ",", "false", ")", ";", "bool", "Res", "=", "AssignFn", "(", "i", ",", "ValVT", ",", "ValVT", ",", "CCValAssign", "::", "Full", ",", "ISD", "::", "ArgFlagsTy", "(", ")", ",", "CCInfo", ")", ";", "assert", "(", "!", "Res", "&&", "\"Call operand has unhandled type\"", ")", ";", "(", "void", ")", "Res", ";", "}", "assert", "(", "ArgLocs", ".", "size", "(", ")", "==", "Args", ".", "size", "(", ")", "&&", "\"We have a different number of location and args?!\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ArgLocs", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "ArgLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Not yet implemented\"", ")", ";", "MIRBuilder", ".", "getMBB", "(", ")", ".", "addLiveIn", "(", "VA", ".", "getLocReg", "(", ")", ")", ";", "MIRBuilder", ".", "buildInstr", "(", "TargetOpcode", "::", "COPY", ",", "VRegs", "[", "i", "]", ",", "VA", ".", "getLocReg", "(", ")", ")", ";", "switch", "(", "VA", ".", "getLocInfo", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown loc info!\"", ")", ";", "case", "CCValAssign", "::", "Full", ":", "break", ";", "case", "CCValAssign", "::", "BCvt", ":", "break", ";", "case", "CCValAssign", "::", "AExt", ":", "case", "CCValAssign", "::", "SExt", ":", "case", "CCValAssign", "::", "ZExt", ":", "assert", "(", "0", "&&", "\"Not yet implemented\"", ")", ";", "break", ";", "}", "}", "return", "true", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64", "16", "AArch64", "AArch64", "0", "MVT::getVT", "ISD::ArgFlagsTy", "\"Call operand has unhandled type\"", "\"We have a different number of location and args?!\"", "0", "\"Not yet implemented\"", "\"Unknown loc info!\"", "0", "\"Not yet implemented\"" ]

[]

[ "<s>", "bool", "AGCAsmParser", "::", "ParseInstruction", "(", "ParseInstructionInfo", "&", "Info", ",", "StringRef", "Name", ",", "SMLoc", "NameLoc", ",", "OperandVector", "&", "Operands", ")", "{", "ParsingExtracode", "=", "ParsedExtend", ";", "ParsedExtend", "=", "false", ";", "Operands", ".", "push_back", "(", "AGCOperand", "::", "createToken", "(", "Name", ",", "NameLoc", ")", ")", ";", "if", "(", "getLexer", "(", ")", ".", "is", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "return", "false", ";", "if", "(", "parseImmediate", "(", "Operands", ")", "!=", "MatchOperand_Success", ")", "return", "Error", "(", "getLoc", "(", ")", ",", "\"unknown operand\"", ")", ";", "if", "(", "getLexer", "(", ")", ".", "isNot", "(", "AsmToken", "::", "EndOfStatement", ")", ")", "{", "SMLoc", "Loc", "=", "getLoc", "(", ")", ";", "getParser", "(", ")", ".", "eatToEndOfStatement", "(", ")", ";", "return", "Error", "(", "Loc", ",", "\"unexpected token\"", ")", ";", "}", "getParser", "(", ")", ".", "Lex", "(", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "ParseInstruction", "-", "Parse", "one", "assembly", "instruction", "." ]

[ "AGC", "AGC", "AGCOperand::createToken", "\"unknown operand\"", "\"unexpected token\"" ]

[]

[ "<s>", "Register", "getStackAddress", "(", "uint64_t", "Size", ",", "int64_t", "Offset", ",", "MachinePointerInfo", "&", "MPO", ")", "override", "{", "auto", "&", "MFI", "=", "MIRBuilder", ".", "getMF", "(", ")", ".", "getFrameInfo", "(", ")", ";", "int", "FI", "=", "MFI", ".", "CreateFixedObject", "(", "Size", ",", "Offset", ",", "true", ")", ";", "MPO", "=", "MachinePointerInfo", "::", "getFixedStack", "(", "MIRBuilder", ".", "getMF", "(", ")", ",", "FI", ")", ";", "auto", "AddrReg", "=", "MIRBuilder", ".", "buildFrameIndex", "(", "LLT", "::", "pointer", "(", "AMDGPUAS", "::", "PRIVATE_ADDRESS", ",", "32", ")", ",", "FI", ")", ";", "StackUsed", "=", "std", "::", "max", "(", "StackUsed", ",", "Size", "+", "Offset", ")", ";", "return", "AddrReg", ".", "getReg", "(", "0", ")", ";", "}", "</s>" ]

[ "Materialize", "a", "VReg", "containing", "the", "address", "of", "the", "specified", "stack-based", "object", "." ]

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

[]

[ "<s>", "void", "MipsELFStreamer", "::", "EmitInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "{", "MCELFStreamer", "::", "EmitInstruction", "(", "Inst", ",", "STI", ")", ";", "MCContext", "&", "Context", "=", "getContext", "(", ")", ";", "const", "MCRegisterInfo", "*", "MCRegInfo", "=", "Context", ".", "getRegisterInfo", "(", ")", ";", "MipsTargetELFStreamer", "*", "ELFTargetStreamer", "=", "static_cast", "<", "MipsTargetELFStreamer", "*", ">", "(", "getTargetStreamer", "(", ")", ")", ";", "for", "(", "unsigned", "OpIndex", "=", "0", ";", "OpIndex", "<", "Inst", ".", "getNumOperands", "(", ")", ";", "++", "OpIndex", ")", "{", "const", "MCOperand", "&", "Op", "=", "Inst", ".", "getOperand", "(", "OpIndex", ")", ";", "if", "(", "!", "Op", ".", "isReg", "(", ")", ")", "continue", ";", "unsigned", "Reg", "=", "Op", ".", "getReg", "(", ")", ";", "RegInfoRecord", "->", "SetPhysRegUsed", "(", "Reg", ",", "MCRegInfo", ")", ";", "}", "if", "(", "ELFTargetStreamer", "->", "isMicroMipsEnabled", "(", ")", ")", "{", "for", "(", "auto", "Label", ":", "Labels", ")", "{", "MCSymbolData", "&", "Data", "=", "getOrCreateSymbolData", "(", "Label", ")", ";", "MCELF", "::", "setOther", "(", "Data", ",", "ELF", "::", "STO_MIPS_MICROMIPS", ">>", "2", ")", ";", "}", "}", "Labels", ".", "clear", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "Mips", "Mips", "0", "Mips", "2" ]

[]

[ "<s>", "uint64_t", "PPCFrameLowering", "::", "getTOCSaveOffset", "(", ")", "const", "{", "return", "TOCSaveOffset", ";", "}", "</s>" ]

[ "getTOCSaveOffset", "-", "Return", "the", "previous", "frame", "offset", "to", "save", "the", "TOC", "register", "�", "?", "64-bit", "SVR4", "ABI", "only", "." ]

[ "PowerPC", "PPC" ]

[]

[ "<s>", "DecodeStatus", "HexagonDisassembler", "::", "getInstruction", "(", "MCInst", "&", "MI", ",", "uint64_t", "&", "Size", ",", "ArrayRef", "<", "uint8_t", ">", "Bytes", ",", "uint64_t", "Address", ",", "raw_ostream", "&", "os", ",", "raw_ostream", "&", "cs", ")", "const", "{", "Size", "=", "4", ";", "if", "(", "Bytes", ".", "size", "(", ")", "<", "4", ")", "return", "MCDisassembler", "::", "Fail", ";", "uint32_t", "insn", "=", "llvm", "::", "support", "::", "endian", "::", "read", "<", "uint32_t", ",", "llvm", "::", "support", "::", "little", ",", "llvm", "::", "support", "::", "unaligned", ">", "(", "Bytes", ".", "data", "(", ")", ")", ";", "insn", "&=", "~", "static_cast", "<", "uint32_t", ">", "(", "HexagonII", "::", "InstParseBits", "::", "INST_PARSE_MASK", ")", ";", "DecodeStatus", "Result", "=", "decodeInstruction", "(", "DecoderTable32", ",", "MI", ",", "insn", ",", "Address", ",", "this", ",", "STI", ")", ";", "HexagonMCInst", "::", "AppendImplicitOperands", "(", "MI", ")", ";", "return", "Result", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "4", "4", "support::endian", "support::little", "support::unaligned", "HexagonII::InstParseBits", "Hexagon" ]

[]

[ "<s>", "int", "PPCTTIImpl", "::", "getIntImmCostInst", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "Instruction", "*", "Inst", ")", "{", "if", "(", "DisablePPCConstHoist", ")", "return", "BaseT", "::", "getIntImmCostInst", "(", "Opcode", ",", "Idx", ",", "Imm", ",", "Ty", ",", "CostKind", ",", "Inst", ")", ";", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "~", "0U", ";", "unsigned", "ImmIdx", "=", "~", "0U", ";", "bool", "ShiftedFree", "=", "false", ",", "RunFree", "=", "false", ",", "UnsignedFree", "=", "false", ",", "ZeroFree", "=", "false", ";", "switch", "(", "Opcode", ")", "{", "default", ":", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "GetElementPtr", ":", "if", "(", "Idx", "==", "0", ")", "return", "2", "*", "TTI", "::", "TCC_Basic", ";", "return", "TTI", "::", "TCC_Free", ";", "case", "Instruction", "::", "And", ":", "RunFree", "=", "true", ";", "LLVM_FALLTHROUGH", ";", "case", "Instruction", "::", "Add", ":", "case", "Instruction", "::", "Or", ":", "case", "Instruction", "::", "Xor", ":", "ShiftedFree", "=", "true", ";", "LLVM_FALLTHROUGH", ";", "case", "Instruction", "::", "Sub", ":", "case", "Instruction", "::", "Mul", ":", "case", "Instruction", "::", "Shl", ":", "case", "Instruction", "::", "LShr", ":", "case", "Instruction", "::", "AShr", ":", "ImmIdx", "=", "1", ";", "break", ";", "case", "Instruction", "::", "ICmp", ":", "UnsignedFree", "=", "true", ";", "ImmIdx", "=", "1", ";", "LLVM_FALLTHROUGH", ";", "case", "Instruction", "::", "Select", ":", "ZeroFree", "=", "true", ";", "break", ";", "case", "Instruction", "::", "PHI", ":", "case", "Instruction", "::", "Call", ":", "case", "Instruction", "::", "Ret", ":", "case", "Instruction", "::", "Load", ":", "case", "Instruction", "::", "Store", ":", "break", ";", "}", "if", "(", "ZeroFree", "&&", "Imm", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "Idx", "==", "ImmIdx", "&&", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", ")", "{", "if", "(", "isInt", "<", "16", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "RunFree", ")", "{", "if", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "32", "&&", "(", "isShiftedMask_32", "(", "Imm", ".", "getZExtValue", "(", ")", ")", "||", "isShiftedMask_32", "(", "~", "Imm", ".", "getZExtValue", "(", ")", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "ST", "->", "isPPC64", "(", ")", "&&", "(", "isShiftedMask_64", "(", "Imm", ".", "getZExtValue", "(", ")", ")", "||", "isShiftedMask_64", "(", "~", "Imm", ".", "getZExtValue", "(", ")", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "}", "if", "(", "UnsignedFree", "&&", "isUInt", "<", "16", ">", "(", "Imm", ".", "getZExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "ShiftedFree", "&&", "(", "Imm", ".", "getZExtValue", "(", ")", "&", "0xFFFF", ")", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "}", "return", "PPCTTIImpl", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ";", "}", "</s>" ]

[ "Return", "the", "expected", "cost", "of", "materialization", "for", "the", "given", "integer", "immediate", "of", "the", "specified", "type", "for", "a", "given", "instruction", "." ]

[ "PowerPC", "PPC", "PPC", "0", "0U", "0U", "0", "2", "1", "1", "0", "64", "16", "32", "PPC", "16", "0xFFFF", "0", "PPC" ]

[]

[ "<s>", "Function", "*", "HSAILIntrinsicInfo", "::", "getDeclaration", "(", "Module", "*", "M", ",", "unsigned", "IntrID", ",", "Type", "*", "*", "Tys", ",", "unsigned", "int", "numTys", ")", "const", "{", "llvm_unreachable", "(", "\"Not implemented\"", ")", ";", "return", "nullptr", ";", "}", "</s>" ]

[ "Create", "or", "insert", "an", "LLVM", "Function", "declaration", "for", "an", "intrinsic", ",", "and", "return", "it", "." ]

[ "HSAIL", "HSAIL", "\"Not implemented\"" ]

[]

[ "<s>", "rtx", "visium_legitimize_reload_address", "(", "rtx", "x", ",", "enum", "machine_mode", "mode", ",", "int", "opnum", ",", "int", "type", ",", "int", "ind", "ATTRIBUTE_UNUSED", ")", "{", "rtx", "newrtx", ",", "tem", "=", "NULL_RTX", ";", "if", "(", "mode", "==", "BLKmode", ")", "return", "NULL_RTX", ";", "if", "(", "optimize", "&&", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "tem", "=", "simplify_binary_operation", "(", "PLUS", ",", "GET_MODE", "(", "x", ")", ",", "XEXP", "(", "x", ",", "0", ")", ",", "XEXP", "(", "x", ",", "1", ")", ")", ";", "newrtx", "=", "tem", "?", "tem", ":", "x", ";", "if", "(", "GET_CODE", "(", "newrtx", ")", "==", "PLUS", "&&", "GET_CODE", "(", "XEXP", "(", "newrtx", ",", "1", ")", ")", "==", "CONST_INT", "&&", "GET_CODE", "(", "XEXP", "(", "newrtx", ",", "0", ")", ")", "==", "REG", "&&", "BASE_REGISTER_P", "(", "REGNO", "(", "XEXP", "(", "newrtx", ",", "0", ")", ")", ")", ")", "{", "int", "offset", "=", "INTVAL", "(", "XEXP", "(", "newrtx", ",", "1", ")", ")", ";", "int", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "int", "mask", "=", "(", "size", "==", "1", "?", "0x1f", ":", "(", "size", "==", "2", "?", "0x3f", ":", "0x7f", ")", ")", ";", "int", "mask1", "=", "(", "size", "==", "1", "?", "0", ":", "(", "size", "==", "2", "?", "1", ":", "3", ")", ")", ";", "int", "offset_base", "=", "offset", "&", "~", "mask", ";", "if", "(", "4", "<", "size", "&&", "0x80", "<", "size", "+", "offset", "-", "offset_base", ")", "offset_base", "=", "offset", "&", "~", "0x3f", ";", "if", "(", "offset_base", "&&", "(", "offset", "&", "mask1", ")", "==", "0", ")", "{", "rtx", "temp", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "XEXP", "(", "newrtx", ",", "0", ")", ",", "GEN_INT", "(", "offset_base", ")", ")", ";", "x", "=", "gen_rtx_PLUS", "(", "Pmode", ",", "temp", ",", "GEN_INT", "(", "offset", "-", "offset_base", ")", ")", ";", "push_reload", "(", "XEXP", "(", "x", ",", "0", ")", ",", "0", ",", "&", "XEXP", "(", "x", ",", "0", ")", ",", "0", ",", "BASE_REG_CLASS", ",", "Pmode", ",", "VOIDmode", ",", "0", ",", "0", ",", "opnum", ",", "(", "enum", "reload_type", ")", "type", ")", ";", "return", "x", ";", "}", "}", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Perform", "a", "similar", "function", "to", "visium_legitimize_address", ",", "but", "this", "time", "for", "reload", ".", "Generating", "new", "registers", "is", "not", "an", "option", "here", ".", "Parts", "that", "need", "reloading", "are", "indicated", "by", "calling", "push_reload", "." ]

[ "visium", "0", "1", "1", "0", "0", "1", "1", "0x1f", "2", "0x3f", "0x7f", "1", "0", "2", "1", "3", "4", "0x80", "0x3f", "0", "0", "0", "0", "0", "0", "0", "0" ]

[]

[ "<s>", "static", "bool", "csky_cannot_copy_insn_p", "(", "rtx_insn", "*", "insn", ")", "{", "subrtx_iterator", "::", "array_type", "array", ";", "FOR_EACH_SUBRTX", "(", "iter", ",", "array", ",", "PATTERN", "(", "insn", ")", ",", "ALL", ")", "{", "const_rtx", "x", "=", "*", "iter", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", "&&", "(", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_TLS_LABEL", "||", "XINT", "(", "x", ",", "1", ")", "==", "UNSPEC_PIC_SYMBOL_GOTPC_GRS", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Implement", "TARGET_CANNOT_COPY_INSN_P", ".", "We", "must", "not", "copy", "any", "rtx", "that", "uses", "a", "pc-relative", "address", "." ]

[ "csky", "1", "1" ]

[]

[ "<s>", "static", "int", "visium_adjust_priority", "(", "rtx_insn", "*", "insn", ",", "int", "priority", ")", "{", "if", "(", "visium_cpu", "==", "PROCESSOR_GR5", "&&", "reload_completed", "&&", "INSN_P", "(", "insn", ")", "&&", "recog_memoized", "(", "insn", ")", ">=", "0", ")", "{", "enum", "attr_type", "attr_type", "=", "get_attr_type", "(", "insn", ")", ";", "if", "(", "attr_type", "==", "TYPE_REG_MEM", "||", "(", "attr_type", "==", "TYPE_MEM_REG", "&&", "MEM_READONLY_P", "(", "SET_SRC", "(", "PATTERN", "(", "insn", ")", ")", ")", ")", ")", "return", "priority", "+", "1", ";", "}", "return", "priority", ";", "}", "</s>" ]

[ "Return", "the", "adjusted", "PRIORITY", "of", "INSN", "." ]

[ "visium", "0", "1" ]

[]

[ "<s>", "std", "::", "unique_ptr", "<", "MCObjectWriter", ">", "createObjectWriter", "(", "raw_pwrite_stream", "&", "OS", ")", "const", "override", "{", "return", "createX86MachObjectWriter", "(", "OS", ",", "true", ",", "MachO", "::", "CPU_TYPE_X86_64", ",", "Subtype", ")", ";", "}", "</s>" ]

[ "Create", "a", "new", "MCObjectWriter", "instance", "for", "use", "by", "the", "assembler", "backend", "to", "emit", "the", "final", "object", "file", "." ]

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

[]

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

[ "isToken", "-", "Is", "this", "a", "token", "operand", "?" ]

[ "RISCV" ]

[]

[ "<s>", "void", "ARMAsmPrinter", "::", "EmitInstruction", "(", "const", "MachineInstr", "*", "MI", ")", "{", "if", "(", "EnableMCInst", ")", "{", "printInstructionThroughMCStreamer", "(", "MI", ")", ";", "return", ";", "}", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "CONSTPOOL_ENTRY", ")", "EmitAlignment", "(", "2", ")", ";", "SmallString", "<", "128", ">", "Str", ";", "raw_svector_ostream", "OS", "(", "Str", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "DBG_VALUE", ")", "{", "unsigned", "NOps", "=", "MI", "->", "getNumOperands", "(", ")", ";", "assert", "(", "NOps", "==", "4", ")", ";", "OS", "<<", "'\\t'", "<<", "MAI", "->", "getCommentString", "(", ")", "<<", "\"DEBUG_VALUE: \"", ";", "DIVariable", "V", "(", "const_cast", "<", "MDNode", "*", ">", "(", "MI", "->", "getOperand", "(", "NOps", "-", "1", ")", ".", "getMetadata", "(", ")", ")", ")", ";", "OS", "<<", "V", ".", "getName", "(", ")", ";", "OS", "<<", "\" <- \"", ";", "assert", "(", "MI", "->", "getOperand", "(", "0", ")", ".", "isReg", "(", ")", "&&", "MI", "->", "getOperand", "(", "1", ")", ".", "isImm", "(", ")", ")", ";", "OS", "<<", "'['", ";", "printOperand", "(", "MI", ",", "0", ",", "OS", ")", ";", "OS", "<<", "'+'", ";", "printOperand", "(", "MI", ",", "1", ",", "OS", ")", ";", "OS", "<<", "']'", ";", "OS", "<<", "\"+\"", ";", "printOperand", "(", "MI", ",", "NOps", "-", "2", ",", "OS", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "OS", ".", "str", "(", ")", ")", ";", "return", ";", "}", "printInstruction", "(", "MI", ",", "OS", ")", ";", "OutStreamer", ".", "EmitRawText", "(", "OS", ".", "str", "(", ")", ")", ";", "if", "(", "MI", "->", "getOpcode", "(", ")", "==", "ARM", "::", "t2TBB", ")", "EmitAlignment", "(", "1", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM::CONSTPOOL_ENTRY", "2", "128", "ARM::DBG_VALUE", "4", "\"DEBUG_VALUE: \"", "1", "\" <- \"", "0", "1", "0", "1", "\"+\"", "2", "ARM::t2TBB", "1" ]

[]

[ "<s>", "static", "void", "split_delayed_branch", "(", "rtx_insn", "*", "insn", ")", "{", "int", "code", "=", "recog_memoized", "(", "insn", ")", ";", "rtx_insn", "*", "i1", ";", "rtx", "newpat", ";", "rtx", "pat", "=", "PATTERN", "(", "insn", ")", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "COND_EXEC", ")", "pat", "=", "COND_EXEC_CODE", "(", "pat", ")", ";", "if", "(", "CALL_P", "(", "insn", ")", ")", "{", "rtx", "src", "=", "pat", ",", "dest", "=", "NULL_RTX", ";", "rtx", "callee", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "SET", ")", "{", "dest", "=", "SET_DEST", "(", "pat", ")", ";", "src", "=", "SET_SRC", "(", "pat", ")", ";", "}", "callee", "=", "XEXP", "(", "XEXP", "(", "src", ",", "0", ")", ",", "0", ")", ";", "if", "(", "SIBLING_CALL_P", "(", "insn", ")", ")", "{", "if", "(", "REG_P", "(", "callee", ")", ")", "newpat", "=", "gen_indirect_sibcall_shadow", "(", ")", ";", "else", "newpat", "=", "gen_sibcall_shadow", "(", "callee", ")", ";", "pat", "=", "gen_real_jump", "(", "callee", ")", ";", "}", "else", "if", "(", "dest", "!=", "NULL_RTX", ")", "{", "if", "(", "REG_P", "(", "callee", ")", ")", "newpat", "=", "gen_indirect_call_value_shadow", "(", "dest", ")", ";", "else", "newpat", "=", "gen_call_value_shadow", "(", "dest", ",", "callee", ")", ";", "pat", "=", "gen_real_call", "(", "callee", ")", ";", "}", "else", "{", "if", "(", "REG_P", "(", "callee", ")", ")", "newpat", "=", "gen_indirect_call_shadow", "(", ")", ";", "else", "newpat", "=", "gen_call_shadow", "(", "callee", ")", ";", "pat", "=", "gen_real_call", "(", "callee", ")", ";", "}", "pat", "=", "duplicate_cond", "(", "pat", ",", "insn", ")", ";", "newpat", "=", "duplicate_cond", "(", "newpat", ",", "insn", ")", ";", "}", "else", "{", "rtx", "src", ",", "op", ";", "if", "(", "GET_CODE", "(", "pat", ")", "==", "PARALLEL", "&&", "GET_CODE", "(", "XVECEXP", "(", "pat", ",", "0", ",", "0", ")", ")", "==", "RETURN", ")", "{", "newpat", "=", "gen_return_shadow", "(", ")", ";", "pat", "=", "gen_real_ret", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "1", ")", ",", "0", ")", ")", ";", "newpat", "=", "duplicate_cond", "(", "newpat", ",", "insn", ")", ";", "}", "else", "switch", "(", "code", ")", "{", "case", "CODE_FOR_br_true", ":", "case", "CODE_FOR_br_false", ":", "src", "=", "SET_SRC", "(", "pat", ")", ";", "op", "=", "XEXP", "(", "src", ",", "code", "==", "CODE_FOR_br_true", "?", "1", ":", "2", ")", ";", "newpat", "=", "gen_condjump_shadow", "(", "op", ")", ";", "pat", "=", "gen_real_jump", "(", "op", ")", ";", "if", "(", "code", "==", "CODE_FOR_br_true", ")", "pat", "=", "gen_rtx_COND_EXEC", "(", "VOIDmode", ",", "XEXP", "(", "src", ",", "0", ")", ",", "pat", ")", ";", "else", "pat", "=", "gen_rtx_COND_EXEC", "(", "VOIDmode", ",", "reversed_comparison", "(", "XEXP", "(", "src", ",", "0", ")", ",", "VOIDmode", ")", ",", "pat", ")", ";", "break", ";", "case", "CODE_FOR_jump", ":", "op", "=", "SET_SRC", "(", "pat", ")", ";", "newpat", "=", "gen_jump_shadow", "(", "op", ")", ";", "break", ";", "case", "CODE_FOR_indirect_jump", ":", "newpat", "=", "gen_indirect_jump_shadow", "(", ")", ";", "break", ";", "case", "CODE_FOR_return_internal", ":", "newpat", "=", "gen_return_shadow", "(", ")", ";", "pat", "=", "gen_real_ret", "(", "XEXP", "(", "XVECEXP", "(", "pat", ",", "0", ",", "1", ")", ",", "0", ")", ")", ";", "break", ";", "default", ":", "return", ";", "}", "}", "i1", "=", "emit_insn_before", "(", "pat", ",", "insn", ")", ";", "PATTERN", "(", "insn", ")", "=", "newpat", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "record_delay_slot_pair", "(", "i1", ",", "insn", ",", "5", ",", "0", ")", ";", "}", "</s>" ]

[ "If", "possible", ",", "split", "INSN", ",", "which", "we", "know", "is", "either", "a", "jump", "or", "a", "call", ",", "into", "a", "real", "insn", "and", "its", "shadow", "." ]

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

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"AArch64 Address Type Promotion\"", ";", "}", "</s>" ]

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

[ "AArch64", "\"AArch64 Address Type Promotion\"" ]

[]

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

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

[ "Mips" ]

[]

[ "<s>", "unsigned", "TPCTTIImpl", "::", "getLatency", "(", "const", "TPCLatencyEvaluation", "::", "InstructionForLatencyDetermination", "&", "src", ",", "const", "TPCLatencyEvaluation", "::", "InstructionForLatencyDetermination", "&", "dest", ",", "bool", "DestPresent", ")", "{", "int", "latency", "=", "TPCTTIImpl", "::", "DEFAULT_LATENCY", ";", "if", "(", "TPCLatencyEvaluation", "::", "latenciesDB", ".", "find", "(", "src", ")", "!=", "TPCLatencyEvaluation", "::", "latenciesDB", ".", "end", "(", ")", ")", "{", "if", "(", "DestPresent", ")", "{", "if", "(", "TPCLatencyEvaluation", "::", "latenciesDB", ".", "find", "(", "dest", ")", "!=", "TPCLatencyEvaluation", "::", "latenciesDB", ".", "end", "(", ")", ")", "{", "latency", "=", "TPCLatencyEvaluation", "::", "latenciesDB", "[", "dest", "]", ".", "first", "-", "TPCLatencyEvaluation", "::", "latenciesDB", "[", "src", "]", ".", "first", "+", "1", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Choosing default latency of 4 as destination \"", "\"ILD lookup has failed \\n\"", ")", ";", "}", "}", "else", "{", "latency", "=", "TPCLatencyEvaluation", "::", "latenciesDB", "[", "src", "]", ".", "first", "-", "TPCLatencyEvaluation", "::", "e_stage_d2", "+", "1", ";", "}", "assert", "(", "latency", ">", "0", "&&", "\"Error in calculating latency\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" Source ILD \"", "<<", "src", ".", "str", "(", ")", "<<", "\"\\n\"", ")", ";", "if", "(", "DestPresent", ")", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\" Destination ILD \"", "<<", "dest", ".", "str", "(", ")", "<<", "\"\\n\"", ")", ";", "}", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Calculated latency is \"", "<<", "latency", "<<", "\"\\n\"", ")", ";", "}", "else", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\nChoosing default latency of 4 as src ILD not found. \\n\"", ")", ";", "}", "return", "(", "unsigned", ")", "latency", ";", "}", "</s>" ]

[ "Returns", "the", "latency", "value", "for", "this", "edge", ",", "which", "roughly", "means", "the", "minimum", "number", "of", "cycles", "that", "must", "elapse", "between", "the", "predecessor", "and", "the", "successor", ",", "given", "that", "they", "have", "this", "edge", "between", "them", "." ]

[ "TPC", "TPC", "TPCLatencyEvaluation::InstructionForLatencyDetermination", "TPCLatencyEvaluation::InstructionForLatencyDetermination", "TPC", "TPCLatencyEvaluation::latenciesDB", "TPCLatencyEvaluation::latenciesDB", "TPCLatencyEvaluation::latenciesDB", "TPCLatencyEvaluation::latenciesDB", "TPCLatencyEvaluation::latenciesDB", "TPCLatencyEvaluation::latenciesDB", "1", "\"Choosing default latency of 4 as destination \"", "\"ILD lookup has failed \\n\"", "TPCLatencyEvaluation::latenciesDB", "TPCLatencyEvaluation::e_stage_d2", "1", "0", "\"Error in calculating latency\"", "\" Source ILD \"", "\"\\n\"", "\" Destination ILD \"", "\"\\n\"", "\"Calculated latency is \"", "\"\\n\"", "\"\\nChoosing default latency of 4 as src ILD not found. \\n\"" ]

[]

[ "<s>", "ScheduleDAGInstrs", "*", "GCNPassConfig", "::", "createMachineScheduler", "(", "MachineSchedContext", "*", "C", ")", "const", "{", "const", "SISubtarget", "&", "ST", "=", "C", "->", "MF", "->", "getSubtarget", "<", "SISubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "enableSIScheduler", "(", ")", ")", "return", "createSIMachineScheduler", "(", "C", ")", ";", "return", "createGCNMaxOccupancyMachineScheduler", "(", "C", ")", ";", "}", "</s>" ]

[ "Create", "an", "instance", "of", "ScheduleDAGInstrs", "to", "be", "run", "within", "the", "standard", "MachineScheduler", "pass", "for", "this", "function", "and", "target", "at", "the", "current", "optimization", "level", "." ]

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

[]

[ "<s>", "bool", "Mips16RegisterInfo", "::", "requiresRegisterScavenging", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "the", "target", "requires", "(", "and", "can", "make", "use", "of", ")", "the", "register", "scavenger", "." ]

[ "Mips", "Mips" ]

[]

[ "<s>", "void", "assignValueToAddress", "(", "Register", "ValVReg", ",", "Register", "Addr", ",", "uint64_t", "Size", ",", "MachinePointerInfo", "&", "MPO", ",", "CCValAssign", "&", "VA", ")", "override", "{", "MachineFunction", "&", "MF", "=", "MIRBuilder", ".", "getMF", "(", ")", ";", "auto", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MPO", ",", "MachineMemOperand", "::", "MOLoad", "|", "MachineMemOperand", "::", "MOInvariant", ",", "Size", ",", "inferAlignFromPtrInfo", "(", "MF", ",", "MPO", ")", ")", ";", "MIRBuilder", ".", "buildLoad", "(", "ValVReg", ",", "Addr", ",", "*", "MMO", ")", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]

[ "<s>", "bool", "fixupNeedsRelaxationAdvanced", "(", "const", "MCFixup", "&", "Fixup", ",", "bool", "Resolved", ",", "uint64_t", "Value", ",", "const", "MCRelaxableFragment", "*", "DF", ",", "const", "MCAsmLayout", "&", "Layout", ",", "const", "bool", "WasForced", ")", "const", "override", "{", "MCInst", "const", "&", "MCB", "=", "DF", "->", "getInst", "(", ")", ";", "assert", "(", "HexagonMCInstrInfo", "::", "isBundle", "(", "MCB", ")", ")", ";", "*", "RelaxTarget", "=", "nullptr", ";", "MCInst", "&", "MCI", "=", "const_cast", "<", "MCInst", "&", ">", "(", "HexagonMCInstrInfo", "::", "instruction", "(", "MCB", ",", "Fixup", ".", "getOffset", "(", ")", "/", "HEXAGON_INSTR_SIZE", ")", ")", ";", "bool", "Relaxable", "=", "isInstRelaxable", "(", "MCI", ")", ";", "if", "(", "Relaxable", "==", "false", ")", "return", "false", ";", "if", "(", "!", "Resolved", ")", "{", "switch", "(", "Fixup", ".", "getTargetKind", "(", ")", ")", "{", "case", "fixup_Hexagon_B22_PCREL", ":", "LLVM_FALLTHROUGH", ";", "default", ":", "return", "false", ";", "break", ";", "case", "fixup_Hexagon_B13_PCREL", ":", "case", "fixup_Hexagon_B15_PCREL", ":", "case", "fixup_Hexagon_B9_PCREL", ":", "case", "fixup_Hexagon_B7_PCREL", ":", "{", "if", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "MCB", ")", "<", "HEXAGON_PACKET_SIZE", ")", "{", "++", "relaxedCnt", ";", "*", "RelaxTarget", "=", "&", "MCI", ";", "setExtender", "(", "Layout", ".", "getAssembler", "(", ")", ".", "getContext", "(", ")", ")", ";", "return", "true", ";", "}", "else", "{", "return", "false", ";", "}", "break", ";", "}", "}", "}", "MCFixupKind", "Kind", "=", "Fixup", ".", "getKind", "(", ")", ";", "int64_t", "sValue", "=", "Value", ";", "int64_t", "maxValue", ";", "switch", "(", "(", "unsigned", ")", "Kind", ")", "{", "case", "fixup_Hexagon_B7_PCREL", ":", "maxValue", "=", "1", "<<", "8", ";", "break", ";", "case", "fixup_Hexagon_B9_PCREL", ":", "maxValue", "=", "1", "<<", "10", ";", "break", ";", "case", "fixup_Hexagon_B15_PCREL", ":", "maxValue", "=", "1", "<<", "16", ";", "break", ";", "case", "fixup_Hexagon_B22_PCREL", ":", "maxValue", "=", "1", "<<", "23", ";", "break", ";", "default", ":", "maxValue", "=", "INT64_MAX", ";", "break", ";", "}", "bool", "isFarAway", "=", "-", "maxValue", ">", "sValue", "||", "sValue", ">", "maxValue", "-", "1", ";", "if", "(", "isFarAway", ")", "{", "if", "(", "HexagonMCInstrInfo", "::", "bundleSize", "(", "MCB", ")", "<", "HEXAGON_PACKET_SIZE", ")", "{", "++", "relaxedCnt", ";", "*", "RelaxTarget", "=", "&", "MCI", ";", "setExtender", "(", "Layout", ".", "getAssembler", "(", ")", ".", "getContext", "(", ")", ")", ";", "return", "true", ";", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Target", "specific", "predicate", "for", "whether", "a", "given", "fixup", "requires", "the", "associated", "instruction", "to", "be", "relaxed", "." ]

[ "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "Hexagon", "1", "8", "Hexagon", "1", "10", "Hexagon", "1", "16", "Hexagon", "1", "23", "1", "Hexagon" ]

[]

[ "<s>", "void", "PPCTTI", "::", "getUnrollingPreferences", "(", "const", "Function", "*", "F", ",", "Loop", "*", "L", ",", "UnrollingPreferences", "&", "UP", ")", "const", "{", "if", "(", "TM", "->", "getSubtarget", "<", "PPCSubtarget", ">", "(", "F", ")", ".", "getDarwinDirective", "(", ")", "==", "PPC", "::", "DIR_A2", ")", "{", "UP", ".", "Partial", "=", "UP", ".", "Runtime", "=", "true", ";", "}", "}", "</s>" ]

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

[ "PowerPC", "PPC", "PPC", "PPC::DIR_A2" ]

[]

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

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

[ "X86", "X86" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isProfitableToIfCvt", "(", "MachineBasicBlock", "&", "TMBB", ",", "unsigned", "TCycles", ",", "unsigned", "TExtra", ",", "MachineBasicBlock", "&", "FMBB", ",", "unsigned", "FCycles", ",", "unsigned", "FExtra", ",", "const", "BranchProbability", "&", "Probability", ")", "const", "{", "if", "(", "!", "TCycles", "||", "!", "FCycles", ")", "return", "false", ";", "unsigned", "TUnpredCost", "=", "Probability", ".", "getNumerator", "(", ")", "*", "TCycles", ";", "TUnpredCost", "/=", "Probability", ".", "getDenominator", "(", ")", ";", "uint32_t", "Comp", "=", "Probability", ".", "getDenominator", "(", ")", "-", "Probability", ".", "getNumerator", "(", ")", ";", "unsigned", "FUnpredCost", "=", "Comp", "*", "FCycles", ";", "FUnpredCost", "/=", "Probability", ".", "getDenominator", "(", ")", ";", "unsigned", "UnpredCost", "=", "TUnpredCost", "+", "FUnpredCost", ";", "UnpredCost", "+=", "1", ";", "UnpredCost", "+=", "Subtarget", ".", "getMispredictionPenalty", "(", ")", "/", "10", ";", "return", "(", "TCycles", "+", "FCycles", "+", "TExtra", "+", "FExtra", ")", "<=", "UnpredCost", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "1", "10" ]

[]

[ "<s>", "bool", "X86TTIImpl", "::", "prefersVectorizedAddressing", "(", ")", "const", "{", "return", "supportsGather", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "target", "does", "n't", "mind", "addresses", "in", "vectors", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "static", "bool", "nvptx_pass_by_reference", "(", "cumulative_args_t", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", ")", "{", "return", "!", "PASS_IN_REG_P", "(", "mode", ",", "type", ")", ";", "}", "</s>" ]

[ "Types", "with", "a", "mode", "other", "than", "those", "supported", "by", "the", "machine", "are", "passed", "by", "reference", "in", "memory", "." ]

[ "nvptx" ]

[]

[ "<s>", "static", "void", "aarch64_define_unconditional_macros", "(", "cpp_reader", "*", "pfile", ")", "{", "builtin_define", "(", "\"__aarch64__\"", ")", ";", "builtin_define", "(", "\"__ARM_64BIT_STATE\"", ")", ";", "builtin_define", "(", "\"__ARM_ARCH_ISA_A64\"", ")", ";", "builtin_define_with_int_value", "(", "\"__ARM_ALIGN_MAX_PWR\"", ",", "28", ")", ";", "builtin_define_with_int_value", "(", "\"__ARM_ALIGN_MAX_STACK_PWR\"", ",", "16", ")", ";", "builtin_define", "(", "\"__ARM_ARCH_8A\"", ")", ";", "builtin_define_with_int_value", "(", "\"__ARM_ARCH_PROFILE\"", ",", "AARCH64_ISA_V8R", "?", "'R'", ":", "'A'", ")", ";", "builtin_define", "(", "\"__ARM_FEATURE_CLZ\"", ")", ";", "builtin_define", "(", "\"__ARM_FEATURE_IDIV\"", ")", ";", "builtin_define", "(", "\"__ARM_FEATURE_UNALIGNED\"", ")", ";", "builtin_define", "(", "\"__ARM_PCS_AAPCS64\"", ")", ";", "builtin_define_with_int_value", "(", "\"__ARM_SIZEOF_WCHAR_T\"", ",", "WCHAR_TYPE_SIZE", "/", "8", ")", ";", "builtin_define", "(", "\"__GCC_ASM_FLAG_OUTPUTS__\"", ")", ";", "}", "</s>" ]

[ "Define", "the", "macros", "that", "we", "always", "expect", "to", "have", "on", "AArch64", "." ]

[ "aarch64", "\"__aarch64__\"", "\"__ARM_64BIT_STATE\"", "\"__ARM_ARCH_ISA_A64\"", "\"__ARM_ALIGN_MAX_PWR\"", "28", "\"__ARM_ALIGN_MAX_STACK_PWR\"", "16", "\"__ARM_ARCH_8A\"", "\"__ARM_ARCH_PROFILE\"", "\"__ARM_FEATURE_CLZ\"", "\"__ARM_FEATURE_IDIV\"", "\"__ARM_FEATURE_UNALIGNED\"", "\"__ARM_PCS_AAPCS64\"", "\"__ARM_SIZEOF_WCHAR_T\"", "8", "\"__GCC_ASM_FLAG_OUTPUTS__\"" ]

[]

[ "<s>", "void", "rs6000_expand_vector_extract", "(", "rtx", "target", ",", "rtx", "vec", ",", "rtx", "elt", ")", "{", "machine_mode", "mode", "=", "GET_MODE", "(", "vec", ")", ";", "machine_mode", "inner_mode", "=", "GET_MODE_INNER", "(", "mode", ")", ";", "rtx", "mem", ";", "if", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "&&", "CONST_INT_P", "(", "elt", ")", ")", "{", "switch", "(", "mode", ")", "{", "default", ":", "break", ";", "case", "E_V1TImode", ":", "gcc_assert", "(", "INTVAL", "(", "elt", ")", "==", "0", "&&", "inner_mode", "==", "TImode", ")", ";", "emit_move_insn", "(", "target", ",", "gen_lowpart", "(", "TImode", ",", "vec", ")", ")", ";", "break", ";", "case", "E_V2DFmode", ":", "emit_insn", "(", "gen_vsx_extract_v2df", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "E_V2DImode", ":", "emit_insn", "(", "gen_vsx_extract_v2di", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "E_V4SFmode", ":", "emit_insn", "(", "gen_vsx_extract_v4sf", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "E_V16QImode", ":", "if", "(", "TARGET_DIRECT_MOVE_64BIT", ")", "{", "emit_insn", "(", "gen_vsx_extract_v16qi", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "}", "else", "break", ";", "case", "E_V8HImode", ":", "if", "(", "TARGET_DIRECT_MOVE_64BIT", ")", "{", "emit_insn", "(", "gen_vsx_extract_v8hi", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "}", "else", "break", ";", "case", "E_V4SImode", ":", "if", "(", "TARGET_DIRECT_MOVE_64BIT", ")", "{", "emit_insn", "(", "gen_vsx_extract_v4si", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "}", "break", ";", "}", "}", "else", "if", "(", "VECTOR_MEM_VSX_P", "(", "mode", ")", "&&", "!", "CONST_INT_P", "(", "elt", ")", "&&", "TARGET_DIRECT_MOVE_64BIT", ")", "{", "if", "(", "GET_MODE", "(", "elt", ")", "!=", "DImode", ")", "{", "rtx", "tmp", "=", "gen_reg_rtx", "(", "DImode", ")", ";", "convert_move", "(", "tmp", ",", "elt", ",", "0", ")", ";", "elt", "=", "tmp", ";", "}", "else", "if", "(", "!", "REG_P", "(", "elt", ")", ")", "elt", "=", "force_reg", "(", "DImode", ",", "elt", ")", ";", "switch", "(", "mode", ")", "{", "case", "E_V2DFmode", ":", "emit_insn", "(", "gen_vsx_extract_v2df_var", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "E_V2DImode", ":", "emit_insn", "(", "gen_vsx_extract_v2di_var", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "E_V4SFmode", ":", "emit_insn", "(", "gen_vsx_extract_v4sf_var", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "E_V4SImode", ":", "emit_insn", "(", "gen_vsx_extract_v4si_var", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "E_V8HImode", ":", "emit_insn", "(", "gen_vsx_extract_v8hi_var", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "case", "E_V16QImode", ":", "emit_insn", "(", "gen_vsx_extract_v16qi_var", "(", "target", ",", "vec", ",", "elt", ")", ")", ";", "return", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "gcc_assert", "(", "CONST_INT_P", "(", "elt", ")", ")", ";", "mem", "=", "assign_stack_temp", "(", "mode", ",", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "emit_move_insn", "(", "mem", ",", "vec", ")", ";", "mem", "=", "adjust_address_nv", "(", "mem", ",", "inner_mode", ",", "INTVAL", "(", "elt", ")", "*", "GET_MODE_SIZE", "(", "inner_mode", ")", ")", ";", "emit_move_insn", "(", "target", ",", "adjust_address_nv", "(", "mem", ",", "inner_mode", ",", "0", ")", ")", ";", "}", "</s>" ]

[ "Extract", "field", "ELT", "from", "VEC", "into", "TARGET", "." ]

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

[]

[ "<s>", "tree", "arm_builtin_decl", "(", "unsigned", "code", ",", "bool", "initialize_p", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "code", ">=", "ARM_BUILTIN_MAX", ")", "return", "error_mark_node", ";", "return", "arm_builtin_decls", "[", "code", "]", ";", "}", "</s>" ]

[ "Return", "the", "ARM", "builtin", "for", "CODE", "." ]

[ "arm" ]

[]

[ "<s>", "static", "void", "replace_pc_relative_symbol_ref", "(", "rtx_insn", "*", "insn", ",", "rtx", "opnds", "[", "4", "]", ",", "bool", "first_insn_p", ")", "{", "rtx_insn", "*", "new_insns", ";", "start_sequence", "(", ")", ";", "if", "(", "flag_pic", "==", "1", ")", "{", "if", "(", "!", "first_insn_p", ")", "{", "emit_insn", "(", "gen_add_got16", "(", "opnds", "[", "0", "]", ",", "tilepro_got_rtx", "(", ")", ",", "opnds", "[", "2", "]", ")", ")", ";", "emit_insn", "(", "gen_insn_lw", "(", "opnds", "[", "0", "]", ",", "opnds", "[", "0", "]", ")", ")", ";", "}", "}", "else", "{", "if", "(", "first_insn_p", ")", "{", "emit_insn", "(", "gen_addhi_got32", "(", "opnds", "[", "0", "]", ",", "tilepro_got_rtx", "(", ")", ",", "opnds", "[", "2", "]", ")", ")", ";", "}", "else", "{", "emit_insn", "(", "gen_addlo_got32", "(", "opnds", "[", "0", "]", ",", "opnds", "[", "1", "]", ",", "opnds", "[", "2", "]", ")", ")", ";", "emit_insn", "(", "gen_insn_lw", "(", "opnds", "[", "0", "]", ",", "opnds", "[", "0", "]", ")", ")", ";", "}", "}", "new_insns", "=", "get_insns", "(", ")", ";", "end_sequence", "(", ")", ";", "if", "(", "new_insns", ")", "emit_insn_before", "(", "new_insns", ",", "insn", ")", ";", "delete_insn", "(", "insn", ")", ";", "}", "</s>" ]

[ "Helper", "function", "for", "tilepro_fixup_pcrel_references", "." ]

[ "tilepro", "4", "1", "0", "2", "0", "0", "0", "2", "0", "1", "2", "0", "0" ]

[]

[ "<s>", "static", "void", "h8300_emit_stack_adjustment", "(", "int", "sign", ",", "HOST_WIDE_INT", "size", ")", "{", "if", "(", "size", "==", "0", ")", "return", ";", "if", "(", "Pmode", "==", "HImode", ")", "{", "rtx_insn", "*", "x", "=", "emit_insn", "(", "gen_addhi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "sign", "*", "size", ")", ")", ")", ";", "if", "(", "size", "<", "4", ")", "F", "(", "x", ",", "0", ")", ";", "}", "else", "F", "(", "emit_insn", "(", "gen_addsi3", "(", "stack_pointer_rtx", ",", "stack_pointer_rtx", ",", "GEN_INT", "(", "sign", "*", "size", ")", ")", ")", ",", "0", ")", ";", "}", "</s>" ]

[ "Output", "assembly", "language", "to", "FILE", "for", "the", "operation", "OP", "with", "operand", "size", "SIZE", "to", "adjust", "the", "stack", "pointer", "." ]

[ "h8300", "0", "4", "0", "0" ]

[]

[ "<s>", "static", "bool", "visium_modes_tieable_p", "(", "machine_mode", "mode1", ",", "machine_mode", "mode2", ")", "{", "return", "(", "GET_MODE_CLASS", "(", "mode1", ")", "==", "MODE_INT", "&&", "GET_MODE_CLASS", "(", "mode2", ")", "==", "MODE_INT", ")", ";", "}", "</s>" ]

[ "Implement", "TARGET_MODES_TIEABLE_P", "." ]

[ "visium" ]

[]

[ "<s>", "unsigned", "ARMTargetLowering", "::", "getRegisterByName", "(", "const", "char", "*", "RegName", ",", "EVT", "VT", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "unsigned", "Reg", "=", "StringSwitch", "<", "unsigned", ">", "(", "RegName", ")", ".", "Case", "(", "\"sp\"", ",", "ARM", "::", "SP", ")", ".", "Default", "(", "0", ")", ";", "if", "(", "Reg", ")", "return", "Reg", ";", "report_fatal_error", "(", "Twine", "(", "\"Invalid register name \\\"\"", "+", "StringRef", "(", "RegName", ")", "+", "\"\\\".\"", ")", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "\"sp\"", "ARM::SP", "0", "\"Invalid register name \\\"\"", "\"\\\".\"" ]

[]

[ "<s>", "void", "Thumb1RegisterInfo", "::", "emitLoadConstPool", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "&", "MBBI", ",", "DebugLoc", "dl", ",", "unsigned", "DestReg", ",", "unsigned", "SubIdx", ",", "int", "Val", ",", "ARMCC", "::", "CondCodes", "Pred", ",", "unsigned", "PredReg", ")", "const", "{", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineConstantPool", "*", "ConstantPool", "=", "MF", ".", "getConstantPool", "(", ")", ";", "const", "Constant", "*", "C", "=", "ConstantInt", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "MBB", ".", "getParent", "(", ")", "->", "getFunction", "(", ")", "->", "getContext", "(", ")", ")", ",", "Val", ")", ";", "unsigned", "Idx", "=", "ConstantPool", "->", "getConstantPoolIndex", "(", "C", ",", "4", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "ARM", "::", "tLDRcp", ")", ")", ".", "addReg", "(", "DestReg", ",", "getDefRegState", "(", "true", ")", ",", "SubIdx", ")", ".", "addConstantPoolIndex", "(", "Idx", ")", ".", "addImm", "(", "Pred", ")", ".", "addReg", "(", "PredReg", ")", ";", "}", "</s>" ]

[ "emitLoadConstPool", "-", "Emits", "a", "load", "from", "constpool", "to", "materialize", "the", "specified", "immediate", "." ]

[ "ARM", "ARMCC::CondCodes", "4", "ARM::tLDRcp" ]

[]

[ "<s>", "void", "ARMAsmPrinter", "::", "emitFunctionEntryLabel", "(", ")", "{", "if", "(", "AFI", "->", "isThumbFunction", "(", ")", ")", "{", "OutStreamer", "->", "emitAssemblerFlag", "(", "MCAF_Code16", ")", ";", "OutStreamer", "->", "emitThumbFunc", "(", "CurrentFnSym", ")", ";", "}", "else", "{", "OutStreamer", "->", "emitAssemblerFlag", "(", "MCAF_Code32", ")", ";", "}", "OutStreamer", "->", "emitLabel", "(", "CurrentFnSym", ")", ";", "}", "</s>" ]

[ "EmitFunctionEntryLabel", "-", "Emit", "the", "label", "that", "is", "the", "entrypoint", "for", "the", "function", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "bool", "ComplexPatternFuncMutatesDAG", "(", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "complex", "patterns", "for", "this", "target", "can", "mutate", "the", "DAG", "." ]

[ "X86" ]

[]

[ "<s>", "const", "TL45RegisterInfo", "*", "getRegisterInfo", "(", ")", "const", "override", "{", "return", "&", "RI", ";", "}", "</s>" ]

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

[ "TL45", "TL45" ]

[]

[ "<s>", "unsigned", "DLXInstrInfo", "::", "removeBranch", "(", "MachineBasicBlock", "&", "MBB", ",", "int", "*", "BytesRemoved", ")", "const", "{", "return", "false", ";", "}", "</s>" ]

[ "Remove", "the", "branching", "code", "at", "the", "end", "of", "the", "specific", "MBB", "." ]

[ "DLX", "DLX" ]

[]

[ "<s>", "unsigned", "MipsMCCodeEmitter", "::", "getBranchTarget26OpValue", "(", "const", "MCInst", "&", "MI", ",", "unsigned", "OpNo", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "const", "MCOperand", "&", "MO", "=", "MI", ".", "getOperand", "(", "OpNo", ")", ";", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "MO", ".", "getImm", "(", ")", ">>", "2", ";", "assert", "(", "MO", ".", "isExpr", "(", ")", "&&", "\"getBranchTarget26OpValue expects only expressions or immediates\"", ")", ";", "const", "MCExpr", "*", "Expr", "=", "MO", ".", "getExpr", "(", ")", ";", "Fixups", ".", "push_back", "(", "MCFixup", "::", "Create", "(", "0", ",", "Expr", ",", "MCFixupKind", "(", "Mips", "::", "fixup_MIPS_PC26_S2", ")", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "getBranchTarget26OpValue", "-", "Return", "binary", "encoding", "of", "the", "branch", "target", "operand", "." ]

[ "Mips", "Mips", "2", "\"getBranchTarget26OpValue expects only expressions or immediates\"", "0", "Mips::fixup_MIPS_PC26_S2", "0" ]

[]

[ "<s>", "static", "void", "riscv_set_current_function", "(", "tree", "decl", ")", "{", "if", "(", "decl", "==", "NULL_TREE", "||", "current_function_decl", "==", "NULL_TREE", "||", "current_function_decl", "==", "error_mark_node", "||", "!", "cfun", "->", "machine", "||", "cfun", "->", "machine", "->", "attributes_checked_p", ")", "return", ";", "cfun", "->", "machine", "->", "naked_p", "=", "riscv_naked_function_p", "(", "decl", ")", ";", "cfun", "->", "machine", "->", "interrupt_handler_p", "=", "riscv_interrupt_type_p", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "if", "(", "cfun", "->", "machine", "->", "naked_p", "&&", "cfun", "->", "machine", "->", "interrupt_handler_p", ")", "error", "(", "\"function attributes %qs and %qs are mutually exclusive\"", ",", "\"interrupt\"", ",", "\"naked\"", ")", ";", "if", "(", "cfun", "->", "machine", "->", "interrupt_handler_p", ")", "{", "tree", "ret", "=", "TREE_TYPE", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "tree", "args", "=", "TYPE_ARG_TYPES", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "if", "(", "TREE_CODE", "(", "ret", ")", "!=", "VOID_TYPE", ")", "error", "(", "\"%qs function cannot return a value\"", ",", "\"interrupt\"", ")", ";", "if", "(", "args", "&&", "TREE_CODE", "(", "TREE_VALUE", "(", "args", ")", ")", "!=", "VOID_TYPE", ")", "error", "(", "\"%qs function cannot have arguments\"", ",", "\"interrupt\"", ")", ";", "cfun", "->", "machine", "->", "interrupt_mode", "=", "riscv_get_interrupt_type", "(", "decl", ")", ";", "gcc_assert", "(", "cfun", "->", "machine", "->", "interrupt_mode", "!=", "UNKNOWN_MODE", ")", ";", "}", "cfun", "->", "machine", "->", "attributes_checked_p", "=", "1", ";", "}", "</s>" ]

[ "Sanity", "cheching", "for", "above", "function", "attributes", "." ]

[ "riscv", "\"function attributes %qs and %qs are mutually exclusive\"", "\"interrupt\"", "\"naked\"", "\"%qs function cannot return a value\"", "\"interrupt\"", "\"%qs function cannot have arguments\"", "\"interrupt\"", "1" ]

[]

[ "<s>", "bool", "X86RegisterInfo", "::", "canRealignStack", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "return", "(", "RealignStack", "&&", "!", "MFI", "->", "hasVarSizedObjects", "(", ")", ")", ";", "}", "</s>" ]

[ "True", "if", "the", "stack", "can", "be", "realigned", "for", "the", "target", "." ]

[ "X86", "X86" ]

[]

[ "<s>", "void", "ARCInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "Register", "DestReg", ",", "int", "FrameIndex", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "dl", "=", "MBB", ".", "findDebugLoc", "(", "I", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Align", "=", "MFI", ".", "getObjectAlignment", "(", "FrameIndex", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FrameIndex", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FrameIndex", ")", ",", "Align", ")", ";", "assert", "(", "MMO", "&&", "\"Couldn't get MachineMemOperand for store to stack.\"", ")", ";", "assert", "(", "TRI", "->", "getSpillSize", "(", "*", "RC", ")", "==", "4", "&&", "\"Only support 4-byte loads from stack now.\"", ")", ";", "assert", "(", "ARC", "::", "GPR32RegClass", ".", "hasSubClassEq", "(", "RC", ")", "&&", "\"Only support GPR32 stores to stack now.\"", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Created load reg=\"", "<<", "printReg", "(", "DestReg", ",", "TRI", ")", "<<", "\" from FrameIndex=\"", "<<", "FrameIndex", "<<", "\"\\n\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "dl", ",", "get", "(", "ARC", "::", "LD_rs9", ")", ")", ".", "addReg", "(", "DestReg", ",", "RegState", "::", "Define", ")", ".", "addFrameIndex", "(", "FrameIndex", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "</s>" ]

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

[ "ARC", "ARC", "\"Couldn't get MachineMemOperand for store to stack.\"", "4", "\"Only support 4-byte loads from stack now.\"", "ARC::GPR32RegClass", "\"Only support GPR32 stores to stack now.\"", "\"Created load reg=\"", "\" from FrameIndex=\"", "\"\\n\"", "ARC::LD_rs9", "0" ]

[]

[ "<s>", "void", "write", "(", "unsigned", "int", "i", ")", "{", "std", "::", "stringstream", "s", ";", "s", "<<", "MF", "->", "getFunction", "(", ")", "->", "getName", "(", ")", ".", "str", "(", ")", "<<", "\"-\"", "<<", "i", "<<", "\".dot\"", ";", "std", "::", "string", "err", ";", "raw_fd_ostream", "f", "(", "s", ".", "str", "(", ")", ".", "c_str", "(", ")", ",", "err", ")", ";", "WriteGraph", "(", "f", ",", "*", "this", ")", ";", "f", ".", "close", "(", ")", ";", "}", "</s>" ]

[ "Write", "the", "profile", "to", "a", "string", "output", "stream", "OS", "." ]

[ "Patmos", "\"-\"", "\".dot\"" ]

[]

[ "<s>", "tree", "ix86_valid_target_attribute_tree", "(", "tree", "args", ",", "struct", "gcc_options", "*", "opts", ",", "struct", "gcc_options", "*", "opts_set", ")", "{", "const", "char", "*", "orig_arch_string", "=", "opts", "->", "x_ix86_arch_string", ";", "const", "char", "*", "orig_tune_string", "=", "opts", "->", "x_ix86_tune_string", ";", "enum", "fpmath_unit", "orig_fpmath_set", "=", "opts_set", "->", "x_ix86_fpmath", ";", "int", "orig_tune_defaulted", "=", "ix86_tune_defaulted", ";", "int", "orig_arch_specified", "=", "ix86_arch_specified", ";", "char", "*", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_MAX", "]", "=", "{", "NULL", ",", "NULL", "}", ";", "tree", "t", "=", "NULL_TREE", ";", "int", "i", ";", "struct", "cl_target_option", "*", "def", "=", "TREE_TARGET_OPTION", "(", "target_option_default_node", ")", ";", "struct", "gcc_options", "enum_opts_set", ";", "memset", "(", "&", "enum_opts_set", ",", "0", ",", "sizeof", "(", "enum_opts_set", ")", ")", ";", "if", "(", "!", "ix86_valid_target_attribute_inner_p", "(", "args", ",", "option_strings", ",", "opts", ",", "opts_set", ",", "&", "enum_opts_set", ")", ")", "return", "error_mark_node", ";", "if", "(", "opts", "->", "x_ix86_isa_flags", "!=", "def", "->", "x_ix86_isa_flags", "||", "opts", "->", "x_target_flags", "!=", "def", "->", "x_target_flags", "||", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_ARCH", "]", "||", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_TUNE", "]", "||", "enum_opts_set", ".", "x_ix86_fpmath", ")", "{", "if", "(", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_ARCH", "]", ")", "opts", "->", "x_ix86_arch_string", "=", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_ARCH", "]", ";", "else", "if", "(", "!", "orig_arch_specified", ")", "opts", "->", "x_ix86_arch_string", "=", "NULL", ";", "if", "(", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_TUNE", "]", ")", "opts", "->", "x_ix86_tune_string", "=", "option_strings", "[", "IX86_FUNCTION_SPECIFIC_TUNE", "]", ";", "else", "if", "(", "orig_tune_defaulted", ")", "opts", "->", "x_ix86_tune_string", "=", "NULL", ";", "if", "(", "enum_opts_set", ".", "x_ix86_fpmath", ")", "opts_set", "->", "x_ix86_fpmath", "=", "(", "enum", "fpmath_unit", ")", "1", ";", "else", "if", "(", "!", "TARGET_64BIT_P", "(", "opts", "->", "x_ix86_isa_flags", ")", "&&", "TARGET_SSE_P", "(", "opts", "->", "x_ix86_isa_flags", ")", ")", "{", "opts", "->", "x_ix86_fpmath", "=", "(", "enum", "fpmath_unit", ")", "(", "FPMATH_SSE", "|", "FPMATH_387", ")", ";", "opts_set", "->", "x_ix86_fpmath", "=", "(", "enum", "fpmath_unit", ")", "1", ";", "}", "ix86_option_override_internal", "(", "false", ",", "opts", ",", "opts_set", ")", ";", "ix86_add_new_builtins", "(", "opts", "->", "x_ix86_isa_flags", ")", ";", "t", "=", "build_target_option_node", "(", "opts", ")", ";", "opts", "->", "x_ix86_arch_string", "=", "orig_arch_string", ";", "opts", "->", "x_ix86_tune_string", "=", "orig_tune_string", ";", "opts_set", "->", "x_ix86_fpmath", "=", "orig_fpmath_set", ";", "for", "(", "i", "=", "0", ";", "i", "<", "IX86_FUNCTION_SPECIFIC_MAX", ";", "i", "++", ")", "free", "(", "option_strings", "[", "i", "]", ")", ";", "}", "return", "t", ";", "}", "</s>" ]

[ "Return", "a", "TARGET_OPTION_NODE", "tree", "of", "the", "target", "options", "listed", "or", "NULL", "." ]

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

[]

[ "<s>", "void", "printAndVerify", "(", "PassManagerBase", "&", "PM", ",", "const", "char", "*", "Banner", ")", "{", "if", "(", "PrintMachineCode", ")", "PM", ".", "add", "(", "createMachineFunctionPrinterPass", "(", "dbgs", "(", ")", ",", "Banner", ")", ")", ";", "}", "</s>" ]

[ "printAndVerify", "-", "Add", "a", "pass", "to", "dump", "then", "verify", "the", "machine", "function", ",", "if", "those", "steps", "are", "enabled", "." ]

[ "PTX" ]

[]

[ "<s>", "static", "bool", "ix86_legitimate_constant_p", "(", "machine_mode", ",", "rtx", "x", ")", "{", "if", "(", "POINTER_BOUNDS_MODE_P", "(", "GET_MODE", "(", "x", ")", ")", ")", "return", "false", ";", "switch", "(", "GET_CODE", "(", "x", ")", ")", "{", "case", "CONST", ":", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "PLUS", ")", "{", "if", "(", "!", "CONST_INT_P", "(", "XEXP", "(", "x", ",", "1", ")", ")", ")", "return", "false", ";", "x", "=", "XEXP", "(", "x", ",", "0", ")", ";", "}", "if", "(", "TARGET_MACHO", "&&", "darwin_local_data_pic", "(", "x", ")", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "==", "UNSPEC", ")", "switch", "(", "XINT", "(", "x", ",", "1", ")", ")", "{", "case", "UNSPEC_GOT", ":", "case", "UNSPEC_GOTOFF", ":", "case", "UNSPEC_PLTOFF", ":", "return", "TARGET_64BIT", ";", "case", "UNSPEC_TPOFF", ":", "case", "UNSPEC_NTPOFF", ":", "x", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "return", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "==", "TLS_MODEL_LOCAL_EXEC", ")", ";", "case", "UNSPEC_DTPOFF", ":", "x", "=", "XVECEXP", "(", "x", ",", "0", ",", "0", ")", ";", "return", "(", "GET_CODE", "(", "x", ")", "==", "SYMBOL_REF", "&&", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", "==", "TLS_MODEL_LOCAL_DYNAMIC", ")", ";", "default", ":", "return", "false", ";", "}", "if", "(", "GET_CODE", "(", "x", ")", "==", "LABEL_REF", ")", "return", "true", ";", "if", "(", "GET_CODE", "(", "x", ")", "!=", "SYMBOL_REF", ")", "return", "false", ";", "case", "SYMBOL_REF", ":", "if", "(", "SYMBOL_REF_TLS_MODEL", "(", "x", ")", ")", "return", "false", ";", "if", "(", "TARGET_DLLIMPORT_DECL_ATTRIBUTES", "&&", "SYMBOL_REF_DLLIMPORT_P", "(", "x", ")", ")", "return", "false", ";", "if", "(", "MACHO_DYNAMIC_NO_PIC_P", ")", "return", "machopic_symbol_defined_p", "(", "x", ")", ";", "break", ";", "case", "CONST_WIDE_INT", ":", "if", "(", "!", "TARGET_64BIT", "&&", "!", "standard_sse_constant_p", "(", "x", ")", ")", "return", "false", ";", "break", ";", "case", "CONST_VECTOR", ":", "if", "(", "!", "standard_sse_constant_p", "(", "x", ")", ")", "return", "false", ";", "default", ":", "break", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Determine", "if", "a", "given", "RTX", "is", "a", "valid", "constant", ".", "We", "already", "know", "this", "satisfies", "CONSTANT_P", "." ]

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

[]

[ "<s>", "SDValue", "SHUXITargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "InputArg", ">", "&", "Ins", ",", "const", "SDLoc", "&", "dl", ",", "SelectionDAG", "&", "DAG", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "InVals", ")", "const", "{", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "AnalyzeReturnValues", "(", "CCInfo", ",", "RVLocs", ",", "Ins", ")", ";", "for", "(", "unsigned", "i", "=", "0", ";", "i", "!=", "RVLocs", ".", "size", "(", ")", ";", "++", "i", ")", "{", "Chain", "=", "DAG", ".", "getCopyFromReg", "(", "Chain", ",", "dl", ",", "RVLocs", "[", "i", "]", ".", "getLocReg", "(", ")", ",", "RVLocs", "[", "i", "]", ".", "getValVT", "(", ")", ",", "InFlag", ")", ".", "getValue", "(", "1", ")", ";", "InFlag", "=", "Chain", ".", "getValue", "(", "2", ")", ";", "InVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "return", "Chain", ";", "}", "</s>" ]

[ "LowerCallResult", "-", "Lower", "the", "result", "values", "of", "an", "ISD", ":", ":CALL", "into", "the", "appropriate", "copies", "out", "of", "appropriate", "physical", "registers", "." ]

[ "SHUXI", "SHUXI", "ISD::InputArg", "16", "0", "1", "2", "0" ]

[]

[ "<s>", "void", "XNCMInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "DebugLoc", "DL", ",", "unsigned", "DestReg", ",", "unsigned", "SrcReg", ",", "bool", "KillSrc", ")", "const", "{", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "</s>" ]

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

[ "XNCM", "XNCM", "\"Impossible reg-to-reg copy\"" ]

[]

[ "<s>", "bool", "HexagonExpandCondsets", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "HII", "=", "static_cast", "<", "const", "HexagonInstrInfo", "*", ">", "(", "MF", ".", "getSubtarget", "(", ")", ".", "getInstrInfo", "(", ")", ")", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MDT", "=", "&", "getAnalysis", "<", "MachineDominatorTree", ">", "(", ")", ";", "LIS", "=", "&", "getAnalysis", "<", "LiveIntervals", ">", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "LLVM_DEBUG", "(", "LIS", "->", "print", "(", "dbgs", "(", ")", "<<", "\"Before expand-condsets\\n\"", ",", "MF", ".", "getFunction", "(", ")", ".", "getParent", "(", ")", ")", ")", ";", "bool", "Changed", "=", "false", ";", "std", "::", "set", "<", "unsigned", ">", "CoalUpd", ",", "PredUpd", ";", "SmallVector", "<", "MachineInstr", "*", ",", "16", ">", "Condsets", ";", "for", "(", "auto", "&", "B", ":", "MF", ")", "for", "(", "auto", "&", "I", ":", "B", ")", "if", "(", "isCondset", "(", "I", ")", ")", "Condsets", ".", "push_back", "(", "&", "I", ")", ";", "Changed", "|=", "coalesceSegments", "(", "Condsets", ",", "CoalUpd", ")", ";", "std", "::", "set", "<", "unsigned", ">", "KillUpd", ";", "for", "(", "MachineInstr", "*", "MI", ":", "Condsets", ")", "for", "(", "MachineOperand", "&", "Op", ":", "MI", "->", "operands", "(", ")", ")", "if", "(", "Op", ".", "isReg", "(", ")", "&&", "Op", ".", "isUse", "(", ")", ")", "if", "(", "!", "CoalUpd", ".", "count", "(", "Op", ".", "getReg", "(", ")", ")", ")", "KillUpd", ".", "insert", "(", "Op", ".", "getReg", "(", ")", ")", ";", "updateLiveness", "(", "KillUpd", ",", "false", ",", "true", ",", "false", ")", ";", "LLVM_DEBUG", "(", "LIS", "->", "print", "(", "dbgs", "(", ")", "<<", "\"After coalescing\\n\"", ",", "MF", ".", "getFunction", "(", ")", ".", "getParent", "(", ")", ")", ")", ";", "for", "(", "MachineInstr", "*", "MI", ":", "Condsets", ")", "Changed", "|=", "split", "(", "*", "MI", ",", "PredUpd", ")", ";", "Condsets", ".", "clear", "(", ")", ";", "LLVM_DEBUG", "(", "LIS", "->", "print", "(", "dbgs", "(", ")", "<<", "\"After splitting\\n\"", ",", "MF", ".", "getFunction", "(", ")", ".", "getParent", "(", ")", ")", ")", ";", "for", "(", "auto", "&", "B", ":", "MF", ")", "Changed", "|=", "predicateInBlock", "(", "B", ",", "PredUpd", ")", ";", "LLVM_DEBUG", "(", "LIS", "->", "print", "(", "dbgs", "(", ")", "<<", "\"After predicating\\n\"", ",", "MF", ".", "getFunction", "(", ")", ".", "getParent", "(", ")", ")", ")", ";", "PredUpd", ".", "insert", "(", "CoalUpd", ".", "begin", "(", ")", ",", "CoalUpd", ".", "end", "(", ")", ")", ";", "updateLiveness", "(", "PredUpd", ",", "true", ",", "true", ",", "true", ")", ";", "LLVM_DEBUG", "(", "{", "if", "(", "Changed", ")", "LIS", "->", "print", "(", "dbgs", "(", ")", "<<", "\"After expand-condsets\\n\"", ",", "MF", ".", "getFunction", "(", ")", ".", "getParent", "(", ")", ")", ";", "}", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon", "\"Before expand-condsets\\n\"", "16", "\"After coalescing\\n\"", "\"After splitting\\n\"", "\"After predicating\\n\"", "\"After expand-condsets\\n\"" ]

[]

[ "<s>", "static", "void", "ix86_init_tm_builtins", "(", "void", ")", "{", "enum", "ix86_builtin_func_type", "ftype", ";", "const", "struct", "builtin_description", "*", "d", ";", "size_t", "i", ";", "tree", "decl", ";", "tree", "attrs_load", ",", "attrs_type_load", ",", "attrs_store", ",", "attrs_type_store", ";", "tree", "attrs_log", ",", "attrs_type_log", ";", "if", "(", "!", "flag_tm", ")", "return", ";", "if", "(", "!", "builtin_decl_explicit_p", "(", "BUILT_IN_TM_LOAD_1", ")", ")", "return", ";", "decl", "=", "builtin_decl_explicit", "(", "BUILT_IN_TM_LOAD_1", ")", ";", "attrs_load", "=", "DECL_ATTRIBUTES", "(", "decl", ")", ";", "attrs_type_load", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "decl", "=", "builtin_decl_explicit", "(", "BUILT_IN_TM_STORE_1", ")", ";", "attrs_store", "=", "DECL_ATTRIBUTES", "(", "decl", ")", ";", "attrs_type_store", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "decl", "=", "builtin_decl_explicit", "(", "BUILT_IN_TM_LOG", ")", ";", "attrs_log", "=", "DECL_ATTRIBUTES", "(", "decl", ")", ";", "attrs_type_log", "=", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "decl", ")", ")", ";", "for", "(", "i", "=", "0", ",", "d", "=", "bdesc_tm", ";", "i", "<", "ARRAY_SIZE", "(", "bdesc_tm", ")", ";", "i", "++", ",", "d", "++", ")", "{", "if", "(", "(", "d", "->", "mask", "&", "ix86_isa_flags", ")", "!=", "0", "||", "(", "(", "d", "->", "mask", "&", "OPTION_MASK_ISA_MMX", ")", "!=", "0", "&&", "TARGET_MMX_WITH_SSE", ")", "||", "(", "lang_hooks", ".", "builtin_function", "==", "lang_hooks", ".", "builtin_function_ext_scope", ")", ")", "{", "tree", "type", ",", "attrs", ",", "attrs_type", ";", "enum", "built_in_function", "code", "=", "(", "enum", "built_in_function", ")", "d", "->", "code", ";", "ftype", "=", "(", "enum", "ix86_builtin_func_type", ")", "d", "->", "flag", ";", "type", "=", "ix86_get_builtin_func_type", "(", "ftype", ")", ";", "if", "(", "BUILTIN_TM_LOAD_P", "(", "code", ")", ")", "{", "attrs", "=", "attrs_load", ";", "attrs_type", "=", "attrs_type_load", ";", "}", "else", "if", "(", "BUILTIN_TM_STORE_P", "(", "code", ")", ")", "{", "attrs", "=", "attrs_store", ";", "attrs_type", "=", "attrs_type_store", ";", "}", "else", "{", "attrs", "=", "attrs_log", ";", "attrs_type", "=", "attrs_type_log", ";", "}", "decl", "=", "add_builtin_function", "(", "d", "->", "name", ",", "type", ",", "code", ",", "BUILT_IN_NORMAL", ",", "d", "->", "name", "+", "strlen", "(", "\"__builtin_\"", ")", ",", "attrs", ")", ";", "decl_attributes", "(", "&", "TREE_TYPE", "(", "decl", ")", ",", "attrs_type", ",", "ATTR_FLAG_BUILT_IN", ")", ";", "set_builtin_decl", "(", "code", ",", "decl", ",", "false", ")", ";", "}", "}", "}", "</s>" ]

[ "Initialize", "the", "transactional", "memory", "vector", "load/store", "builtins", "." ]

[ "i386", "0", "0", "0", "\"__builtin_\"" ]

[]

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

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

[ "X86", "\"X86 LEA Fixup\"" ]

[]

[ "<s>", "bool", "AlphaAsmPrinter", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "if", "(", "TM", ".", "getSubtarget", "<", "AlphaSubtarget", ">", "(", ")", ".", "hasCT", "(", ")", ")", "O", "<<", "\"\\t.arch ev6\\n\"", ";", "else", "O", "<<", "\"\\t.arch ev6\\n\"", ";", "O", "<<", "\"\\t.set noat\\n\"", ";", "return", "AsmPrinter", "::", "doInitialization", "(", "M", ")", ";", "}", "</s>" ]

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

[ "Alpha", "Alpha", "Alpha", "\"\\t.arch ev6\\n\"", "\"\\t.arch ev6\\n\"", "\"\\t.set noat\\n\"" ]

[]

[ "<s>", "int", "sh_dynamicalize_shift_p", "(", "rtx", "count", ")", "{", "return", "shift_insns", "[", "INTVAL", "(", "count", ")", "]", ">", "1", "+", "SH_DYNAMIC_SHIFT_COST", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "potentially", "beneficial", "to", "use", "a", "dynamic", "shift", "instruction", "(", "shad", "/", "shar", ")", "instead", "of", "a", "combination", "of", "1/2/8/16", "shift", "instructions", "for", "the", "specified", "shift", "count", ".", "If", "dynamic", "shifts", "are", "not", "available", ",", "always", "return", "false", "." ]

[ "sh", "1" ]

[]

[ "<s>", "static", "bool", "s390_call_saved_register_used", "(", "tree", "call_expr", ")", "{", "CUMULATIVE_ARGS", "cum_v", ";", "cumulative_args_t", "cum", ";", "tree", "parameter", ";", "rtx", "parm_rtx", ";", "int", "reg", ",", "i", ";", "INIT_CUMULATIVE_ARGS", "(", "cum_v", ",", "NULL", ",", "NULL", ",", "0", ",", "0", ")", ";", "cum", "=", "pack_cumulative_args", "(", "&", "cum_v", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "call_expr_nargs", "(", "call_expr", ")", ";", "i", "++", ")", "{", "parameter", "=", "CALL_EXPR_ARG", "(", "call_expr", ",", "i", ")", ";", "gcc_assert", "(", "parameter", ")", ";", "if", "(", "TREE_CODE", "(", "parameter", ")", "==", "ERROR_MARK", ")", "return", "true", ";", "function_arg_info", "arg", "(", "TREE_TYPE", "(", "parameter", ")", ",", "true", ")", ";", "apply_pass_by_reference_rules", "(", "&", "cum_v", ",", "arg", ")", ";", "parm_rtx", "=", "s390_function_arg", "(", "cum", ",", "arg", ")", ";", "s390_function_arg_advance", "(", "cum", ",", "arg", ")", ";", "if", "(", "!", "parm_rtx", ")", "continue", ";", "if", "(", "REG_P", "(", "parm_rtx", ")", ")", "{", "int", "size", "=", "s390_function_arg_size", "(", "arg", ".", "mode", ",", "arg", ".", "type", ")", ";", "int", "nregs", "=", "(", "size", "+", "UNITS_PER_LONG", "-", "1", ")", "/", "UNITS_PER_LONG", ";", "for", "(", "reg", "=", "0", ";", "reg", "<", "nregs", ";", "reg", "++", ")", "if", "(", "!", "call_used_or_fixed_reg_p", "(", "reg", "+", "REGNO", "(", "parm_rtx", ")", ")", ")", "return", "true", ";", "}", "else", "if", "(", "GET_CODE", "(", "parm_rtx", ")", "==", "PARALLEL", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "XVECLEN", "(", "parm_rtx", ",", "0", ")", ";", "i", "++", ")", "{", "rtx", "r", "=", "XEXP", "(", "XVECEXP", "(", "parm_rtx", ",", "0", ",", "i", ")", ",", "0", ")", ";", "gcc_assert", "(", "REG_P", "(", "r", ")", ")", ";", "gcc_assert", "(", "REG_NREGS", "(", "r", ")", "==", "1", ")", ";", "if", "(", "!", "call_used_or_fixed_reg_p", "(", "REGNO", "(", "r", ")", ")", ")", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Checks", "whether", "the", "given", "ARGUMENT_LIST", "would", "use", "a", "caller", "saved", "register", ".", "This", "is", "used", "to", "decide", "whether", "sibling", "call", "optimization", "could", "be", "performed", "on", "the", "respective", "function", "call", "." ]

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

[]

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

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

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

[]

[ "<s>", "int", "mask_ok_for_mem_btst", "(", "int", "len", ",", "int", "bit", ")", "{", "unsigned", "int", "mask", "=", "0", ";", "while", "(", "len", ">", "0", ")", "{", "mask", "|=", "(", "1", "<<", "bit", ")", ";", "bit", "++", ";", "len", "--", ";", "}", "return", "(", "(", "(", "mask", "&", "0xff", ")", "==", "mask", ")", "||", "(", "(", "mask", "&", "0xff00", ")", "==", "mask", ")", "||", "(", "(", "mask", "&", "0xff0000", ")", "==", "mask", ")", "||", "(", "(", "mask", "&", "0xff000000", ")", "==", "mask", ")", ")", ";", "}", "</s>" ]

[ "Similarly", ",", "but", "when", "using", "a", "zero_extract", "pattern", "for", "a", "btst", "where", "the", "source", "operand", "might", "end", "up", "in", "memory", "." ]

[ "mn10300", "0", "0", "1", "0xff", "0xff00", "0xff0000", "0xff000000" ]

[]

[ "<s>", "static", "int", "rs6000_adjust_priority", "(", "rtx", "insn", "ATTRIBUTE_UNUSED", ",", "int", "priority", ")", "{", "if", "(", "!", "INSN_P", "(", "insn", ")", ")", "return", "priority", ";", "if", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "USE", ")", "return", "priority", ";", "switch", "(", "rs6000_cpu_attr", ")", "{", "case", "CPU_PPC750", ":", "switch", "(", "get_attr_type", "(", "insn", ")", ")", "{", "default", ":", "break", ";", "case", "TYPE_IMUL", ":", "case", "TYPE_IDIV", ":", "fprintf", "(", "stderr", ",", "\"priority was %#x (%d) before adjustment\\n\"", ",", "priority", ",", "priority", ")", ";", "if", "(", "priority", ">=", "0", "&&", "priority", "<", "0x01000000", ")", "priority", ">>=", "3", ";", "break", ";", "}", "}", "if", "(", "is_dispatch_slot_restricted", "(", "insn", ")", "&&", "reload_completed", "&&", "current_sched_info", "->", "sched_max_insns_priority", "&&", "rs6000_sched_restricted_insns_priority", ")", "{", "if", "(", "rs6000_sched_restricted_insns_priority", "==", "1", ")", "return", "current_sched_info", "->", "sched_max_insns_priority", ";", "else", "if", "(", "rs6000_sched_restricted_insns_priority", "==", "2", ")", "return", "(", "priority", "+", "1", ")", ";", "}", "return", "priority", ";", "}", "</s>" ]

[ "A", "C", "statement", "(", "sans", "semicolon", ")", "to", "update", "the", "integer", "scheduling", "priority", "INSN_PRIORITY", "(", "INSN", ")", ".", "Reduce", "the", "priority", "to", "execute", "the", "INSN", "earlier", ",", "increase", "the", "priority", "to", "execute", "INSN", "later", ".", "Do", "not", "define", "this", "macro", "if", "you", "do", "not", "need", "to", "adjust", "the", "scheduling", "priorities", "of", "insns", "." ]

[ "rs6000", "\"priority was %#x (%d) before adjustment\\n\"", "0", "0x01000000", "3", "1", "2", "1" ]

[]

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

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

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

[]

[ "<s>", "bool", "isMasked", "(", ")", "const", "{", "return", "Mask", "!=", "~", "0u", ";", "}", "</s>" ]

[ "Returns", "true", "if", "at", "least", "one", "of", "the", "operands", "to", "the", "vectorized", "function", "has", "the", "kind", "'GlobalPredicate", "'", "." ]

[ "AMDGPU", "0u" ]

[]

[ "<s>", "void", "SystemZInstrInfo", "::", "insertSelect", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "const", "DebugLoc", "&", "DL", ",", "Register", "DstReg", ",", "ArrayRef", "<", "MachineOperand", ">", "Pred", ",", "Register", "TrueReg", ",", "Register", "FalseReg", ")", "const", "{", "MachineRegisterInfo", "&", "MRI", "=", "MBB", ".", "getParent", "(", ")", "->", "getRegInfo", "(", ")", ";", "const", "TargetRegisterClass", "*", "RC", "=", "MRI", ".", "getRegClass", "(", "DstReg", ")", ";", "assert", "(", "Pred", ".", "size", "(", ")", "==", "2", "&&", "\"Invalid condition\"", ")", ";", "unsigned", "CCValid", "=", "Pred", "[", "0", "]", ".", "getImm", "(", ")", ";", "unsigned", "CCMask", "=", "Pred", "[", "1", "]", ".", "getImm", "(", ")", ";", "unsigned", "Opc", ";", "if", "(", "SystemZ", "::", "GRX32BitRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "if", "(", "STI", ".", "hasMiscellaneousExtensions3", "(", ")", ")", "Opc", "=", "SystemZ", "::", "SELRMux", ";", "else", "if", "(", "STI", ".", "hasLoadStoreOnCond2", "(", ")", ")", "Opc", "=", "SystemZ", "::", "LOCRMux", ";", "else", "{", "Opc", "=", "SystemZ", "::", "LOCR", ";", "MRI", ".", "constrainRegClass", "(", "DstReg", ",", "&", "SystemZ", "::", "GR32BitRegClass", ")", ";", "Register", "TReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "SystemZ", "::", "GR32BitRegClass", ")", ";", "Register", "FReg", "=", "MRI", ".", "createVirtualRegister", "(", "&", "SystemZ", "::", "GR32BitRegClass", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "TReg", ")", ".", "addReg", "(", "TrueReg", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "TargetOpcode", "::", "COPY", ")", ",", "FReg", ")", ".", "addReg", "(", "FalseReg", ")", ";", "TrueReg", "=", "TReg", ";", "FalseReg", "=", "FReg", ";", "}", "}", "else", "if", "(", "SystemZ", "::", "GR64BitRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "if", "(", "STI", ".", "hasMiscellaneousExtensions3", "(", ")", ")", "Opc", "=", "SystemZ", "::", "SELGR", ";", "else", "Opc", "=", "SystemZ", "::", "LOCGR", ";", "}", "else", "llvm_unreachable", "(", "\"Invalid register class\"", ")", ";", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Opc", ")", ",", "DstReg", ")", ".", "addReg", "(", "FalseReg", ")", ".", "addReg", "(", "TrueReg", ")", ".", "addImm", "(", "CCValid", ")", ".", "addImm", "(", "CCMask", ")", ";", "}", "</s>" ]

[ "Insert", "a", "select", "instruction", "into", "MBB", "before", "I", "that", "will", "copy", "TrueReg", "to", "DstReg", "when", "Cond", "is", "true", ",", "and", "FalseReg", "to", "DstReg", "when", "Cond", "is", "false", "." ]

[ "SystemZ", "SystemZ", "2", "\"Invalid condition\"", "0", "1", "SystemZ::GRX32BitRegClass", "SystemZ::SELRMux", "SystemZ::LOCRMux", "SystemZ::LOCR", "SystemZ::GR32BitRegClass", "SystemZ::GR32BitRegClass", "SystemZ::GR32BitRegClass", "SystemZ::GR64BitRegClass", "SystemZ::SELGR", "SystemZ::LOCGR", "\"Invalid register class\"" ]

[]

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

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

[ "PowerPC" ]

[]

[ "<s>", "SDValue", "ARMSelectionDAGInfo", "::", "EmitTargetCodeForMemset", "(", "SelectionDAG", "&", "DAG", ",", "SDLoc", "dl", ",", "SDValue", "Chain", ",", "SDValue", "Dst", ",", "SDValue", "Src", ",", "SDValue", "Size", ",", "unsigned", "Align", ",", "bool", "isVolatile", ",", "MachinePointerInfo", "DstPtrInfo", ")", "const", "{", "return", "EmitSpecializedLibcall", "(", "DAG", ",", "dl", ",", "Chain", ",", "Dst", ",", "Src", ",", "Size", ",", "Align", ",", "RTLIB", "::", "MEMSET", ")", ";", "}", "</s>" ]

[ "Emit", "target-specific", "code", "that", "performs", "a", "memset", "." ]

[ "ARM", "ARM" ]

[]

[ "<s>", "void", "BlackfinTargetLowering", "::", "ReplaceNodeResults", "(", "SDNode", "*", "N", ",", "SmallVectorImpl", "<", "SDValue", ">", "&", "Results", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "DebugLoc", "dl", "=", "N", "->", "getDebugLoc", "(", ")", ";", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Do not know how to custom type legalize this operation!\"", ")", ";", "return", ";", "case", "ISD", "::", "READCYCLECOUNTER", ":", "{", "SDValue", "TheChain", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "lo", "=", "DAG", ".", "getCopyFromReg", "(", "TheChain", ",", "dl", ",", "BF", "::", "CYCLES", ",", "MVT", "::", "i32", ")", ";", "SDValue", "hi", "=", "DAG", ".", "getCopyFromReg", "(", "lo", ".", "getValue", "(", "1", ")", ",", "dl", ",", "BF", "::", "CYCLES2", ",", "MVT", "::", "i32", ")", ";", "Results", ".", "push_back", "(", "DAG", ".", "getNode", "(", "ISD", "::", "BUILD_PAIR", ",", "dl", ",", "MVT", "::", "i64", ",", "lo", ",", "hi", ")", ")", ";", "Results", ".", "push_back", "(", "hi", ".", "getValue", "(", "1", ")", ")", ";", "return", ";", "}", "}", "}", "</s>" ]

[ "ReplaceNodeResults", "-", "Replace", "the", "results", "of", "node", "with", "an", "illegal", "result", "type", "with", "new", "values", "built", "out", "of", "custom", "code", "." ]

[ "Blackfin", "\"Do not know how to custom type legalize this operation!\"", "ISD::READCYCLECOUNTER", "0", "BF::CYCLES", "MVT::i32", "1", "BF::CYCLES2", "MVT::i32", "ISD::BUILD_PAIR", "MVT::i64", "1" ]

[]

[ "<s>", "static", "bool", "aarch64_extending_load_p", "(", "class", "vec_info", "*", "vinfo", ",", "stmt_vec_info", "stmt_info", ")", "{", "gassign", "*", "assign", "=", "dyn_cast", "<", "gassign", "*", ">", "(", "stmt_info", "->", "stmt", ")", ";", "if", "(", "!", "assign", "||", "!", "CONVERT_EXPR_CODE_P", "(", "gimple_assign_rhs_code", "(", "assign", ")", ")", ")", "return", "false", ";", "tree", "rhs", "=", "gimple_assign_rhs1", "(", "stmt_info", "->", "stmt", ")", ";", "tree", "lhs_type", "=", "TREE_TYPE", "(", "gimple_assign_lhs", "(", "assign", ")", ")", ";", "tree", "rhs_type", "=", "TREE_TYPE", "(", "rhs", ")", ";", "if", "(", "!", "INTEGRAL_TYPE_P", "(", "lhs_type", ")", "||", "!", "INTEGRAL_TYPE_P", "(", "rhs_type", ")", "||", "TYPE_PRECISION", "(", "lhs_type", ")", "<=", "TYPE_PRECISION", "(", "rhs_type", ")", ")", "return", "false", ";", "stmt_vec_info", "def_stmt_info", "=", "vinfo", "->", "lookup_def", "(", "rhs", ")", ";", "return", "(", "def_stmt_info", "&&", "STMT_VINFO_DATA_REF", "(", "def_stmt_info", ")", "&&", "DR_IS_READ", "(", "STMT_VINFO_DATA_REF", "(", "def_stmt_info", ")", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "STMT_INFO", "extends", "the", "result", "of", "a", "load", "." ]

[ "aarch64" ]

[]

[ "<s>", "EVT", "ARMTargetLowering", "::", "getOptimalMemOpType", "(", "uint64_t", "Size", ",", "unsigned", "DstAlign", ",", "unsigned", "SrcAlign", ",", "bool", "IsZeroVal", ",", "bool", "MemcpyStrSrc", ",", "MachineFunction", "&", "MF", ")", "const", "{", "const", "Function", "*", "F", "=", "MF", ".", "getFunction", "(", ")", ";", "if", "(", "IsZeroVal", "&&", "!", "F", "->", "getFnAttributes", "(", ")", ".", "hasNoImplicitFloatAttr", "(", ")", "&&", "Subtarget", "->", "hasNEON", "(", ")", ")", "{", "if", "(", "memOpAlign", "(", "SrcAlign", ",", "DstAlign", ",", "16", ")", "&&", "Size", ">=", "16", ")", "{", "return", "MVT", "::", "v4i32", ";", "}", "else", "if", "(", "memOpAlign", "(", "SrcAlign", ",", "DstAlign", ",", "8", ")", "&&", "Size", ">=", "8", ")", "{", "return", "MVT", "::", "v2i32", ";", "}", "}", "if", "(", "Size", ">=", "4", ")", "{", "return", "MVT", "::", "i32", ";", "}", "else", "if", "(", "Size", ">=", "2", ")", "{", "return", "MVT", "::", "i16", ";", "}", "return", "MVT", "::", "Other", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "16", "16", "MVT::v4i32", "8", "8", "MVT::v2i32", "4", "MVT::i32", "2", "MVT::i16", "MVT::Other" ]

[]

[ "<s>", "X86Subtarget", "::", "X86Subtarget", "(", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "X86TargetMachine", "&", "TM", ",", "unsigned", "StackAlignOverride", ",", "unsigned", "PreferVectorWidthOverride", ",", "unsigned", "RequiredVectorWidth", ")", ":", "X86GenSubtargetInfo", "(", "TT", ",", "CPU", ",", "FS", ")", ",", "X86ProcFamily", "(", "Others", ")", ",", "PICStyle", "(", "PICStyles", "::", "None", ")", ",", "TM", "(", "TM", ")", ",", "TargetTriple", "(", "TT", ")", ",", "StackAlignOverride", "(", "StackAlignOverride", ")", ",", "PreferVectorWidthOverride", "(", "PreferVectorWidthOverride", ")", ",", "RequiredVectorWidth", "(", "RequiredVectorWidth", ")", ",", "In64BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86_64", ")", ",", "In32BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "!=", "Triple", "::", "CODE16", ")", ",", "In16BitMode", "(", "TargetTriple", ".", "getArch", "(", ")", "==", "Triple", "::", "x86", "&&", "TargetTriple", ".", "getEnvironment", "(", ")", "==", "Triple", "::", "CODE16", ")", ",", "InstrInfo", "(", "initializeSubtargetDependencies", "(", "CPU", ",", "FS", ")", ")", ",", "TLInfo", "(", "TM", ",", "*", "this", ")", ",", "FrameLowering", "(", "*", "this", ",", "getStackAlignment", "(", ")", ")", "{", "if", "(", "!", "isPositionIndependent", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "else", "if", "(", "is64Bit", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "RIPRel", ")", ";", "else", "if", "(", "isTargetCOFF", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "None", ")", ";", "else", "if", "(", "isTargetDarwin", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "StubPIC", ")", ";", "else", "if", "(", "isTargetELF", "(", ")", ")", "setPICStyle", "(", "PICStyles", "::", "GOT", ")", ";", "CallLoweringInfo", ".", "reset", "(", "new", "X86CallLowering", "(", "*", "getTargetLowering", "(", ")", ")", ")", ";", "Legalizer", ".", "reset", "(", "new", "X86LegalizerInfo", "(", "*", "this", ",", "TM", ")", ")", ";", "auto", "*", "RBI", "=", "new", "X86RegisterBankInfo", "(", "*", "getRegisterInfo", "(", ")", ")", ";", "RegBankInfo", ".", "reset", "(", "RBI", ")", ";", "InstSelector", ".", "reset", "(", "createX86InstructionSelector", "(", "TM", ",", "*", "this", ",", "*", "RBI", ")", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "isThumb", "(", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "return", "(", "STI", ".", "getFeatureBits", "(", ")", "&", "ARM", "::", "ModeThumb", ")", "!=", "0", ";", "}", "</s>" ]

[ "Tests", "whether", "the", "target", "is", "Thumb", "(", "little", "and", "big", "endian", ")", "." ]

[ "ARM", "ARM::ModeThumb", "0" ]

[]

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

[ "getCPUDirective", "-", "Returns", "the", "-m", "directive", "specified", "for", "the", "cpu", "." ]

[ "PowerPC" ]

[]

[ "<s>", "void", "AlphaFrameInfo", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ")", "const", "{", "MachineBasicBlock", "&", "MBB", "=", "MF", ".", "front", "(", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "begin", "(", ")", ";", "MachineFrameInfo", "*", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "const", "TargetInstrInfo", "&", "TII", "=", "*", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "DebugLoc", "dl", "=", "(", "MBBI", "!=", "MBB", ".", "end", "(", ")", "?", "MBBI", "->", "getDebugLoc", "(", ")", ":", "DebugLoc", "(", ")", ")", ";", "bool", "FP", "=", "hasFP", "(", "MF", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDAHg", ")", ",", "Alpha", "::", "R29", ")", ".", "addGlobalAddress", "(", "MF", ".", "getFunction", "(", ")", ")", ".", "addReg", "(", "Alpha", "::", "R27", ")", ".", "addImm", "(", "++", "curgpdist", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDAg", ")", ",", "Alpha", "::", "R29", ")", ".", "addGlobalAddress", "(", "MF", ".", "getFunction", "(", ")", ")", ".", "addReg", "(", "Alpha", "::", "R29", ")", ".", "addImm", "(", "curgpdist", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "ALTENT", ")", ")", ".", "addGlobalAddress", "(", "MF", ".", "getFunction", "(", ")", ")", ";", "long", "NumBytes", "=", "MFI", "->", "getStackSize", "(", ")", ";", "if", "(", "FP", ")", "NumBytes", "+=", "8", ";", "if", "(", "NumBytes", "==", "0", ")", "return", ";", "unsigned", "Align", "=", "getStackAlignment", "(", ")", ";", "NumBytes", "=", "(", "NumBytes", "+", "Align", "-", "1", ")", "/", "Align", "*", "Align", ";", "MFI", "->", "setStackSize", "(", "NumBytes", ")", ";", "NumBytes", "=", "-", "NumBytes", ";", "if", "(", "NumBytes", ">=", "Alpha", "::", "IMM_LOW", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDA", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "NumBytes", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "}", "else", "if", "(", "getUpper16", "(", "NumBytes", ")", ">=", "Alpha", "::", "IMM_LOW", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDAH", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "getUpper16", "(", "NumBytes", ")", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "LDA", ")", ",", "Alpha", "::", "R30", ")", ".", "addImm", "(", "getLower16", "(", "NumBytes", ")", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "}", "else", "{", "report_fatal_error", "(", "\"Too big a stack frame at \"", "+", "Twine", "(", "NumBytes", ")", ")", ";", "}", "if", "(", "FP", ")", "{", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "STQ", ")", ")", ".", "addReg", "(", "Alpha", "::", "R15", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "BuildMI", "(", "MBB", ",", "MBBI", ",", "dl", ",", "TII", ".", "get", "(", "Alpha", "::", "BISr", ")", ",", "Alpha", "::", "R15", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ".", "addReg", "(", "Alpha", "::", "R30", ")", ";", "}", "}", "</s>" ]

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

[ "Alpha", "Alpha", "Alpha::LDAHg", "Alpha::R29", "Alpha::R27", "Alpha::LDAg", "Alpha::R29", "Alpha::R29", "Alpha::ALTENT", "8", "0", "1", "Alpha::IMM_LOW", "Alpha::LDA", "Alpha::R30", "Alpha::R30", "Alpha::IMM_LOW", "Alpha::LDAH", "Alpha::R30", "Alpha::R30", "Alpha::LDA", "Alpha::R30", "Alpha::R30", "\"Too big a stack frame at \"", "Alpha::STQ", "Alpha::R15", "0", "Alpha::R30", "Alpha::BISr", "Alpha::R15", "Alpha::R30", "Alpha::R30" ]

[]

[ "<s>", "tree", "rs6000_builtin_decl", "(", "unsigned", "code", ",", "bool", "initialize_p", "ATTRIBUTE_UNUSED", ")", "{", "HOST_WIDE_INT", "fnmask", ";", "if", "(", "code", ">=", "RS6000_BUILTIN_COUNT", ")", "return", "error_mark_node", ";", "fnmask", "=", "rs6000_builtin_info", "[", "code", "]", ".", "mask", ";", "if", "(", "(", "fnmask", "&", "rs6000_builtin_mask", ")", "!=", "fnmask", ")", "{", "rs6000_invalid_builtin", "(", "(", "enum", "rs6000_builtins", ")", "code", ")", ";", "return", "error_mark_node", ";", "}", "return", "rs6000_builtin_decls", "[", "code", "]", ";", "}", "</s>" ]

[ "Returns", "the", "rs6000", "builtin", "decl", "for", "CODE", "." ]

[ "rs6000" ]

[]

[ "<s>", "void", "RISCVFrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "RISCVRegisterInfo", "*", "RI", "=", "STI", ".", "getRegisterInfo", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "auto", "*", "RVFI", "=", "MF", ".", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "Register", "FPReg", "=", "getFPReg", "(", "STI", ")", ";", "Register", "SPReg", "=", "getSPReg", "(", "STI", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "end", "(", ")", ";", "DebugLoc", "DL", ";", "if", "(", "!", "MBB", ".", "empty", "(", ")", ")", "{", "MBBI", "=", "MBB", ".", "getFirstTerminator", "(", ")", ";", "if", "(", "MBBI", "==", "MBB", ".", "end", "(", ")", ")", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "DL", "=", "MBBI", "->", "getDebugLoc", "(", ")", ";", "if", "(", "!", "MBBI", "->", "isTerminator", "(", ")", ")", "MBBI", "=", "std", "::", "next", "(", "MBBI", ")", ";", "while", "(", "MBBI", "!=", "MBB", ".", "begin", "(", ")", "&&", "std", "::", "prev", "(", "MBBI", ")", "->", "getFlag", "(", "MachineInstr", "::", "FrameDestroy", ")", ")", "--", "MBBI", ";", "}", "const", "auto", "&", "CSI", "=", "getNonLibcallCSI", "(", "MFI", ".", "getCalleeSavedInfo", "(", ")", ")", ";", "auto", "LastFrameDestroy", "=", "MBBI", ";", "if", "(", "!", "CSI", ".", "empty", "(", ")", ")", "LastFrameDestroy", "=", "std", "::", "prev", "(", "MBBI", ",", "CSI", ".", "size", "(", ")", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", ";", "uint64_t", "RealStackSize", "=", "StackSize", "+", "RVFI", "->", "getLibCallStackSize", "(", ")", ";", "uint64_t", "FPOffset", "=", "RealStackSize", "-", "RVFI", "->", "getVarArgsSaveSize", "(", ")", ";", "if", "(", "RI", "->", "needsStackRealignment", "(", "MF", ")", "||", "MFI", ".", "hasVarSizedObjects", "(", ")", ")", "{", "assert", "(", "hasFP", "(", "MF", ")", "&&", "\"frame pointer should not have been eliminated\"", ")", ";", "adjustReg", "(", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "SPReg", ",", "FPReg", ",", "-", "FPOffset", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "uint64_t", "FirstSPAdjustAmount", "=", "getFirstSPAdjustAmount", "(", "MF", ")", ";", "if", "(", "FirstSPAdjustAmount", ")", "{", "uint64_t", "SecondSPAdjustAmount", "=", "MFI", ".", "getStackSize", "(", ")", "-", "FirstSPAdjustAmount", ";", "assert", "(", "SecondSPAdjustAmount", ">", "0", "&&", "\"SecondSPAdjustAmount should be greater than zero\"", ")", ";", "adjustReg", "(", "MBB", ",", "LastFrameDestroy", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "SecondSPAdjustAmount", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "if", "(", "FirstSPAdjustAmount", ")", "StackSize", "=", "FirstSPAdjustAmount", ";", "adjustReg", "(", "MBB", ",", "MBBI", ",", "DL", ",", "SPReg", ",", "SPReg", ",", "StackSize", ",", "MachineInstr", "::", "FrameDestroy", ")", ";", "}", "</s>" ]

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

[ "RISCV", "RISCV", "RISCV", "RISCV", "\"frame pointer should not have been eliminated\"", "0", "\"SecondSPAdjustAmount should be greater than zero\"" ]

[]

[ "<s>", "bool", "HexagonMCChecker", "::", "check", "(", ")", "{", "bool", "chkB", "=", "checkBranches", "(", ")", ";", "bool", "chkP", "=", "checkPredicates", "(", ")", ";", "bool", "chkNV", "=", "checkNewValues", "(", ")", ";", "bool", "chkR", "=", "checkRegisters", "(", ")", ";", "bool", "chkS", "=", "checkSolo", "(", ")", ";", "bool", "chkSh", "=", "checkShuffle", "(", ")", ";", "bool", "chkSl", "=", "checkSlots", "(", ")", ";", "bool", "chk", "=", "chkB", "&&", "chkP", "&&", "chkNV", "&&", "chkR", "&&", "chkS", "&&", "chkSh", "&&", "chkSl", ";", "return", "chk", ";", "}", "</s>" ]

[ "Check", "if", "the", "constraints", "are", "satisfiable", "." ]

[ "Hexagon", "Hexagon" ]

[]

[ "<s>", "static", "const", "char", "*", "avr_out_store_psi", "(", "rtx_insn", "*", "insn", ",", "rtx", "*", "op", ",", "int", "*", "plen", ")", "{", "rtx", "dest", "=", "op", "[", "0", "]", ";", "rtx", "src", "=", "op", "[", "1", "]", ";", "rtx", "base", "=", "XEXP", "(", "dest", ",", "0", ")", ";", "int", "reg_base", "=", "true_regnum", "(", "base", ")", ";", "if", "(", "CONSTANT_ADDRESS_P", "(", "base", ")", ")", "{", "int", "n_words", "=", "AVR_TINY", "?", "3", ":", "6", ";", "return", "avr_asm_len", "(", "\"sts %m0,%A1\"", "CR_TAB", "\"sts %m0+1,%B1\"", "CR_TAB", "\"sts %m0+2,%C1\"", ",", "op", ",", "plen", ",", "-", "n_words", ")", ";", "}", "if", "(", "reg_base", ">", "0", ")", "{", "if", "(", "AVR_TINY", ")", "return", "avr_out_store_psi_reg_no_disp_tiny", "(", "insn", ",", "op", ",", "plen", ")", ";", "if", "(", "reg_base", "==", "REG_X", ")", "{", "gcc_assert", "(", "!", "reg_overlap_mentioned_p", "(", "base", ",", "src", ")", ")", ";", "avr_asm_len", "(", "\"st %0+,%A1\"", "CR_TAB", "\"st %0+,%B1\"", "CR_TAB", "\"st %0,%C1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "if", "(", "!", "reg_unused_after", "(", "insn", ",", "base", ")", ")", "avr_asm_len", "(", "\"sbiw r26,2\"", ",", "op", ",", "plen", ",", "1", ")", ";", "return", "\"\"", ";", "}", "else", "return", "avr_asm_len", "(", "\"st %0,%A1\"", "CR_TAB", "\"std %0+1,%B1\"", "CR_TAB", "\"std %0+2,%C1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "base", ")", "==", "PLUS", ")", "{", "int", "disp", "=", "INTVAL", "(", "XEXP", "(", "base", ",", "1", ")", ")", ";", "if", "(", "AVR_TINY", ")", "return", "avr_out_store_psi_reg_disp_tiny", "(", "op", ",", "plen", ")", ";", "reg_base", "=", "REGNO", "(", "XEXP", "(", "base", ",", "0", ")", ")", ";", "if", "(", "disp", ">", "MAX_LD_OFFSET", "(", "GET_MODE", "(", "dest", ")", ")", ")", "{", "if", "(", "reg_base", "!=", "REG_Y", ")", "fatal_insn", "(", "\"incorrect insn:\"", ",", "insn", ")", ";", "if", "(", "disp", "<=", "63", "+", "MAX_LD_OFFSET", "(", "GET_MODE", "(", "dest", ")", ")", ")", "return", "avr_asm_len", "(", "\"adiw r28,%o0-61\"", "CR_TAB", "\"std Y+61,%A1\"", "CR_TAB", "\"std Y+62,%B1\"", "CR_TAB", "\"std Y+63,%C1\"", "CR_TAB", "\"sbiw r28,%o0-61\"", ",", "op", ",", "plen", ",", "-", "5", ")", ";", "return", "avr_asm_len", "(", "\"subi r28,lo8(-%o0)\"", "CR_TAB", "\"sbci r29,hi8(-%o0)\"", "CR_TAB", "\"st Y,%A1\"", "CR_TAB", "\"std Y+1,%B1\"", "CR_TAB", "\"std Y+2,%C1\"", "CR_TAB", "\"subi r28,lo8(%o0)\"", "CR_TAB", "\"sbci r29,hi8(%o0)\"", ",", "op", ",", "plen", ",", "-", "7", ")", ";", "}", "if", "(", "reg_base", "==", "REG_X", ")", "{", "gcc_assert", "(", "!", "reg_overlap_mentioned_p", "(", "XEXP", "(", "base", ",", "0", ")", ",", "src", ")", ")", ";", "avr_asm_len", "(", "\"adiw r26,%o0\"", "CR_TAB", "\"st X+,%A1\"", "CR_TAB", "\"st X+,%B1\"", "CR_TAB", "\"st X,%C1\"", ",", "op", ",", "plen", ",", "-", "4", ")", ";", "if", "(", "!", "reg_unused_after", "(", "insn", ",", "XEXP", "(", "base", ",", "0", ")", ")", ")", "avr_asm_len", "(", "\"sbiw r26,%o0+2\"", ",", "op", ",", "plen", ",", "1", ")", ";", "return", "\"\"", ";", "}", "return", "avr_asm_len", "(", "\"std %A0,%A1\"", "CR_TAB", "\"std %B0,%B1\"", "CR_TAB", "\"std %C0,%C1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "}", "else", "if", "(", "GET_CODE", "(", "base", ")", "==", "PRE_DEC", ")", "return", "avr_asm_len", "(", "\"st %0,%C1\"", "CR_TAB", "\"st %0,%B1\"", "CR_TAB", "\"st %0,%A1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "else", "if", "(", "GET_CODE", "(", "base", ")", "==", "POST_INC", ")", "return", "avr_asm_len", "(", "\"st %0,%A1\"", "CR_TAB", "\"st %0,%B1\"", "CR_TAB", "\"st %0,%C1\"", ",", "op", ",", "plen", ",", "-", "3", ")", ";", "fatal_insn", "(", "\"unknown move insn:\"", ",", "insn", ")", ";", "return", "\"\"", ";", "}", "</s>" ]

[ "Handle", "store", "of", "24-bit", "type", "from", "register", "or", "zero", "to", "memory", "." ]

[ "avr", "0", "1", "0", "3", "6", "\"sts %m0,%A1\"", "\"sts %m0+1,%B1\"", "\"sts %m0+2,%C1\"", "0", "\"st %0+,%A1\"", "\"st %0+,%B1\"", "\"st %0,%C1\"", "3", "\"sbiw r26,2\"", "1", "\"\"", "\"st %0,%A1\"", "\"std %0+1,%B1\"", "\"std %0+2,%C1\"", "3", "1", "0", "\"incorrect insn:\"", "63", "\"adiw r28,%o0-61\"", "\"std Y+61,%A1\"", "\"std Y+62,%B1\"", "\"std Y+63,%C1\"", "\"sbiw r28,%o0-61\"", "5", "\"subi r28,lo8(-%o0)\"", "\"sbci r29,hi8(-%o0)\"", "\"st Y,%A1\"", "\"std Y+1,%B1\"", "\"std Y+2,%C1\"", "\"subi r28,lo8(%o0)\"", "\"sbci r29,hi8(%o0)\"", "7", "0", "\"adiw r26,%o0\"", "\"st X+,%A1\"", "\"st X+,%B1\"", "\"st X,%C1\"", "4", "0", "\"sbiw r26,%o0+2\"", "1", "\"\"", "\"std %A0,%A1\"", "\"std %B0,%B1\"", "\"std %C0,%C1\"", "3", "\"st %0,%C1\"", "\"st %0,%B1\"", "\"st %0,%A1\"", "3", "\"st %0,%A1\"", "\"st %0,%B1\"", "\"st %0,%C1\"", "3", "\"unknown move insn:\"", "\"\"" ]

[]

[ "<s>", "static", "unsigned", "getTOCSaveOffset", "(", "void", ")", "{", "return", "40", ";", "}", "</s>" ]

[ "getTOCSaveOffset", "-", "Return", "the", "previous", "frame", "offset", "to", "save", "the", "TOC", "register", "�", "?", "64-bit", "SVR4", "ABI", "only", "." ]

[ "PowerPC", "40" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "decomposeMulByConstant", "(", "LLVMContext", "&", "Context", ",", "EVT", "VT", ",", "SDValue", "C", ")", "const", "{", "if", "(", "VT", ".", "isScalarInteger", "(", ")", ")", "{", "if", "(", "Subtarget", ".", "hasStdExtM", "(", ")", "&&", "VT", ".", "getSizeInBits", "(", ")", ">", "Subtarget", ".", "getXLen", "(", ")", ")", "return", "false", ";", "if", "(", "auto", "*", "ConstNode", "=", "dyn_cast", "<", "ConstantSDNode", ">", "(", "C", ".", "getNode", "(", ")", ")", ")", "{", "const", "APInt", "&", "Imm", "=", "ConstNode", "->", "getAPIntValue", "(", ")", ";", "if", "(", "(", "Imm", "+", "1", ")", ".", "isPowerOf2", "(", ")", "||", "(", "Imm", "-", "1", ")", ".", "isPowerOf2", "(", ")", "||", "(", "1", "-", "Imm", ")", ".", "isPowerOf2", "(", ")", "||", "(", "-", "1", "-", "Imm", ")", ".", "isPowerOf2", "(", ")", ")", "return", "true", ";", "if", "(", "Subtarget", ".", "hasStdExtM", "(", ")", "&&", "VT", ".", "getSizeInBits", "(", ")", ">=", "Subtarget", ".", "getXLen", "(", ")", ")", "return", "false", ";", "if", "(", "!", "Imm", ".", "isSignedIntN", "(", "12", ")", "&&", "Imm", ".", "countTrailingZeros", "(", ")", "<", "12", ")", "{", "APInt", "ImmS", "=", "Imm", ".", "ashr", "(", "Imm", ".", "countTrailingZeros", "(", ")", ")", ";", "if", "(", "(", "ImmS", "+", "1", ")", ".", "isPowerOf2", "(", ")", "||", "(", "ImmS", "-", "1", ")", ".", "isPowerOf2", "(", ")", "||", "(", "1", "-", "ImmS", ")", ".", "isPowerOf2", "(", ")", ")", "return", "true", ";", "}", "}", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "to", "transform", "an", "integer", "multiplication-by-constant", "into", "simpler", "operations", "like", "shifts", "and", "adds", "." ]

[ "RISCV", "RISCV", "1", "1", "1", "1", "12", "12", "1", "1", "1" ]

[]

[ "<s>", "static", "_Unwind_Reason_Code", "unwind_phase2_forced", "(", "_Unwind_Control_Block", "*", "ucbp", ",", "phase2_vrs", "*", "entry_vrs", ",", "int", "resuming", ")", "{", "_Unwind_Stop_Fn", "stop_fn", "=", "(", "_Unwind_Stop_Fn", ")", "UCB_FORCED_STOP_FN", "(", "ucbp", ")", ";", "void", "*", "stop_arg", "=", "(", "void", "*", ")", "UCB_FORCED_STOP_ARG", "(", "ucbp", ")", ";", "_Unwind_Reason_Code", "pr_result", "=", "0", ";", "phase1_vrs", "saved_vrs", ",", "next_vrs", ";", "saved_vrs", ".", "core", "=", "entry_vrs", "->", "core", ";", "saved_vrs", ".", "demand_save_flags", "=", "0", ";", "do", "{", "_Unwind_State", "action", ";", "_Unwind_Reason_Code", "entry_code", ";", "_Unwind_Reason_Code", "stop_code", ";", "entry_code", "=", "get_eit_entry", "(", "ucbp", ",", "saved_vrs", ".", "core", ".", "r", "[", "R_PC", "]", ")", ";", "if", "(", "resuming", ")", "{", "action", "=", "_US_UNWIND_FRAME_RESUME", "|", "_US_FORCE_UNWIND", ";", "resuming", "=", "0", ";", "}", "else", "action", "=", "_US_UNWIND_FRAME_STARTING", "|", "_US_FORCE_UNWIND", ";", "if", "(", "entry_code", "==", "_URC_OK", ")", "{", "UCB_SAVED_CALLSITE_ADDR", "(", "ucbp", ")", "=", "saved_vrs", ".", "core", ".", "r", "[", "R_PC", "]", ";", "next_vrs", "=", "saved_vrs", ";", "pr_result", "=", "(", "(", "personality_routine", ")", "UCB_PR_ADDR", "(", "ucbp", ")", ")", "(", "action", ",", "ucbp", ",", "(", "void", "*", ")", "&", "next_vrs", ")", ";", "saved_vrs", ".", "prev_sp", "=", "next_vrs", ".", "core", ".", "r", "[", "R_SP", "]", ";", "}", "else", "{", "action", "|=", "_US_END_OF_STACK", ";", "saved_vrs", ".", "prev_sp", "=", "saved_vrs", ".", "core", ".", "r", "[", "R_SP", "]", ";", "}", "stop_code", "=", "stop_fn", "(", "1", ",", "action", ",", "ucbp", "->", "exception_class", ",", "ucbp", ",", "(", "void", "*", ")", "&", "saved_vrs", ",", "stop_arg", ")", ";", "if", "(", "stop_code", "!=", "_URC_NO_REASON", ")", "return", "_URC_FAILURE", ";", "if", "(", "entry_code", "!=", "_URC_OK", ")", "return", "entry_code", ";", "saved_vrs", "=", "next_vrs", ";", "}", "while", "(", "pr_result", "==", "_URC_CONTINUE_UNWIND", ")", ";", "if", "(", "pr_result", "!=", "_URC_INSTALL_CONTEXT", ")", "{", "return", "_URC_FAILURE", ";", "}", "restore_core_regs", "(", "&", "saved_vrs", ".", "core", ")", ";", "}", "</s>" ]

[ "Perform", "phase2", "forced", "unwinding", "." ]

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

[]

[ "<s>", "std", "::", "string", "getDataLayout", "(", ")", "const", "{", "return", "std", "::", "string", "(", "\"e-p:32:8:8-i8:8:8-i16:8:8-i32:8:8-f32:8:8-f64:8:8-n16:8\"", ")", ";", "}", "</s>" ]

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

[ "WDC65816", "\"e-p:32:8:8-i8:8:8-i16:8:8-i32:8:8-f32:8:8-f64:8:8-n16:8\"" ]

[]

[ "<s>", "BitVector", "SIRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "AMDGPU", "::", "INDIRECT_BASE_ADDR", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "EXEC", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "FLAT_SCR", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SGPR102_SGPR103", ")", ";", "const", "AMDGPUSubtarget", "&", "ST", "=", "MF", ".", "getSubtarget", "<", "AMDGPUSubtarget", ">", "(", ")", ";", "if", "(", "ST", ".", "getGeneration", "(", ")", ">=", "AMDGPUSubtarget", "::", "VOLCANIC_ISLANDS", ")", "{", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SGPR98_SGPR99", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "AMDGPU", "::", "SGPR100_SGPR101", ")", ";", "}", "if", "(", "ST", ".", "hasSGPRInitBug", "(", ")", ")", "{", "unsigned", "NumSGPRs", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getNumRegs", "(", ")", ";", "unsigned", "Limit", "=", "AMDGPUSubtarget", "::", "FIXED_SGPR_COUNT_FOR_INIT_BUG", "-", "4", ";", "for", "(", "unsigned", "i", "=", "Limit", ";", "i", "<", "NumSGPRs", ";", "++", "i", ")", "{", "unsigned", "Reg", "=", "AMDGPU", "::", "SGPR_32RegClass", ".", "getRegister", "(", "i", ")", ";", "reserveRegisterTuples", "(", "Reserved", ",", "Reg", ")", ";", "}", "}", "return", "Reserved", ";", "}", "</s>" ]

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

[ "AMDGPU", "SI", "AMDGPU::INDIRECT_BASE_ADDR", "AMDGPU::EXEC", "AMDGPU::FLAT_SCR", "AMDGPU::SGPR102_SGPR103", "AMDGPU", "AMDGPU", "AMDGPU", "AMDGPU::SGPR98_SGPR99", "AMDGPU::SGPR100_SGPR101", "AMDGPU::SGPR_32RegClass", "AMDGPU", "4", "AMDGPU::SGPR_32RegClass" ]

[]

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

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

[ "MOS", "MOS" ]

[]

[ "<s>", "InstructionCost", "X86TTIImpl", "::", "getIntImmCost", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "~", "0U", ";", "if", "(", "BitSize", ">", "128", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "Imm", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "APInt", "ImmVal", "=", "Imm", ";", "if", "(", "BitSize", "%", "64", "!=", "0", ")", "ImmVal", "=", "Imm", ".", "sext", "(", "alignTo", "(", "BitSize", ",", "64", ")", ")", ";", "InstructionCost", "Cost", "=", "0", ";", "for", "(", "unsigned", "ShiftVal", "=", "0", ";", "ShiftVal", "<", "BitSize", ";", "ShiftVal", "+=", "64", ")", "{", "APInt", "Tmp", "=", "ImmVal", ".", "ashr", "(", "ShiftVal", ")", ".", "sextOrTrunc", "(", "64", ")", ";", "int64_t", "Val", "=", "Tmp", ".", "getSExtValue", "(", ")", ";", "Cost", "+=", "getIntImmCost", "(", "Val", ")", ";", "}", "return", "std", "::", "max", "<", "InstructionCost", ">", "(", "1", ",", "Cost", ")", ";", "}", "</s>" ]

[ "Calculate", "the", "cost", "of", "materializing", "a", "64-bit", "value", "." ]

[ "X86", "X86", "0", "0U", "128", "0", "64", "0", "64", "0", "0", "64", "64", "1" ]

[]

[ "<s>", "bool", "PPCLinuxAsmPrinter", "::", "doFinalization", "(", "Module", "&", "M", ")", "{", "const", "DataLayout", "*", "TD", "=", "TM", ".", "getDataLayout", "(", ")", ";", "bool", "isPPC64", "=", "TD", "->", "getPointerSizeInBits", "(", ")", "==", "64", ";", "PPCTargetStreamer", "&", "TS", "=", "static_cast", "<", "PPCTargetStreamer", "&", ">", "(", "*", "OutStreamer", ".", "getTargetStreamer", "(", ")", ")", ";", "if", "(", "!", "TOC", ".", "empty", "(", ")", ")", "{", "const", "MCSectionELF", "*", "Section", ";", "if", "(", "isPPC64", ")", "Section", "=", "OutStreamer", ".", "getContext", "(", ")", ".", "getELFSection", "(", "\".toc\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "else", "Section", "=", "OutStreamer", ".", "getContext", "(", ")", ".", "getELFSection", "(", "\".got2\"", ",", "ELF", "::", "SHT_PROGBITS", ",", "ELF", "::", "SHF_WRITE", "|", "ELF", "::", "SHF_ALLOC", ")", ";", "OutStreamer", ".", "SwitchSection", "(", "Section", ")", ";", "for", "(", "MapVector", "<", "MCSymbol", "*", ",", "MCSymbol", "*", ">", "::", "iterator", "I", "=", "TOC", ".", "begin", "(", ")", ",", "E", "=", "TOC", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "OutStreamer", ".", "EmitLabel", "(", "I", "->", "second", ")", ";", "MCSymbol", "*", "S", "=", "I", "->", "first", ";", "if", "(", "isPPC64", ")", "TS", ".", "emitTCEntry", "(", "*", "S", ")", ";", "else", "OutStreamer", ".", "EmitSymbolValue", "(", "S", ",", "4", ")", ";", "}", "}", "return", "AsmPrinter", "::", "doFinalization", "(", "M", ")", ";", "}", "</s>" ]

[ "doFinalization", "-", "Virtual", "method", "overriden", "by", "subclasses", "to", "do", "any", "necessary", "clean", "up", "after", "all", "passes", "have", "run", "." ]

[ "PowerPC", "PPC", "PPC", "64", "PPC", "PPC", "PPC", "\".toc\"", "\".got2\"", "PPC", "4" ]

[]

[ "<s>", "virtual", "const", "AMDGPUIntrinsicInfo", "*", "getIntrinsicInfo", "(", ")", "const", "{", "return", "&", "IntrinsicInfo", ";", "}", "</s>" ]

[ "If", "intrinsic", "information", "is", "available", ",", "return", "it", ".", "If", "not", ",", "return", "null", "." ]

[ "R600" ]

[]

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

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

[ "BPF", "BPF" ]

[]

[ "<s>", "void", "ARMTargetELFStreamer", "::", "emitLabel", "(", "MCSymbol", "*", "Symbol", ")", "{", "ARMELFStreamer", "&", "Streamer", "=", "getStreamer", "(", ")", ";", "if", "(", "!", "Streamer", ".", "IsThumb", ")", "return", ";", "Streamer", ".", "getAssembler", "(", ")", ".", "registerSymbol", "(", "*", "Symbol", ")", ";", "unsigned", "Type", "=", "cast", "<", "MCSymbolELF", ">", "(", "Symbol", ")", "->", "getType", "(", ")", ";", "if", "(", "Type", "==", "ELF", "::", "STT_FUNC", "||", "Type", "==", "ELF", "::", "STT_GNU_IFUNC", ")", "Streamer", ".", "emitThumbFunc", "(", "Symbol", ")", ";", "}", "</s>" ]

[ "Emit", "a", "label", "for", "Symbol", "into", "the", "current", "section", "." ]

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

[]

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

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

[ "X86", "X86" ]

[]

[ "<s>", "void", "M680x0MCCodeEmitter", "::", "encodeInstruction", "(", "const", "MCInst", "&", "MI", ",", "raw_ostream", "&", "OS", ",", "SmallVectorImpl", "<", "MCFixup", ">", "&", "Fixups", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "const", "{", "unsigned", "Opcode", "=", "MI", ".", "getOpcode", "(", ")", ";", "const", "MCInstrDesc", "&", "Desc", "=", "MCII", ".", "get", "(", "Opcode", ")", ";", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"EncodeInstruction: \"", "<<", "MCII", ".", "getName", "(", "Opcode", ")", "<<", "\"(\"", "<<", "Opcode", "<<", "\")\\n\"", ")", ";", "const", "uint8_t", "*", "Beads", "=", "getGenInstrBeads", "(", "MI", ")", ";", "if", "(", "!", "*", "Beads", ")", "{", "llvm_unreachable", "(", "\"*** Instruction does not have Beads defined\"", ")", ";", "}", "uint64_t", "Buffer", "=", "0", ";", "unsigned", "Offset", "=", "0", ";", "unsigned", "ThisByte", "=", "0", ";", "while", "(", "*", "Beads", ")", "{", "uint8_t", "Bead", "=", "*", "Beads", ";", "Beads", "++", ";", "if", "(", "!", "(", "Bead", "&", "0xF", ")", ")", "{", "switch", "(", "Bead", ">>", "4", ")", "{", "case", "M680x0Beads", "::", "Ignore", ":", "continue", ";", "}", "}", "switch", "(", "Bead", "&", "0xF", ")", "{", "default", ":", "llvm_unreachable", "(", "\"Unknown Bead code\"", ")", ";", "break", ";", "case", "M680x0Beads", "::", "Bits1", ":", "case", "M680x0Beads", "::", "Bits2", ":", "case", "M680x0Beads", "::", "Bits3", ":", "case", "M680x0Beads", "::", "Bits4", ":", "Offset", "+=", "EncodeBits", "(", "ThisByte", ",", "Bead", ",", "MI", ",", "Desc", ",", "Buffer", ",", "Offset", ",", "Fixups", ",", "STI", ")", ";", "break", ";", "case", "M680x0Beads", "::", "DAReg", ":", "case", "M680x0Beads", "::", "DA", ":", "case", "M680x0Beads", "::", "Reg", ":", "Offset", "+=", "EncodeReg", "(", "ThisByte", ",", "Bead", ",", "MI", ",", "Desc", ",", "Buffer", ",", "Offset", ",", "Fixups", ",", "STI", ")", ";", "break", ";", "case", "M680x0Beads", "::", "Disp8", ":", "case", "M680x0Beads", "::", "Imm8", ":", "case", "M680x0Beads", "::", "Imm16", ":", "case", "M680x0Beads", "::", "Imm32", ":", "case", "M680x0Beads", "::", "Imm3", ":", "Offset", "+=", "EncodeImm", "(", "ThisByte", ",", "Bead", ",", "MI", ",", "Desc", ",", "Buffer", ",", "Offset", ",", "Fixups", ",", "STI", ")", ";", "break", ";", "}", "while", "(", "Offset", "/", "16", ")", "{", "OS", ".", "write", "(", "(", "char", ")", "(", "(", "Buffer", ">>", "8", ")", "&", "0xFF", ")", ")", ";", "OS", ".", "write", "(", "(", "char", ")", "(", "(", "Buffer", ">>", "0", ")", "&", "0xFF", ")", ")", ";", "Buffer", ">>=", "16", ";", "Offset", "-=", "16", ";", "ThisByte", "+=", "2", ";", "}", "}", "assert", "(", "Offset", "==", "0", "&&", "\"M680x0 Instructions are % 2 bytes\"", ")", ";", "assert", "(", "(", "ThisByte", "&&", "!", "(", "ThisByte", "%", "2", ")", ")", "&&", "\"M680x0 Instructions are % 2 bytes\"", ")", ";", "}", "</s>" ]

[ "Encode", "the", "given", "Inst", "to", "bytes", "and", "append", "to", "CB", "." ]

[ "M680x0", "M680x0", "\"EncodeInstruction: \"", "\"(\"", "\")\\n\"", "\"*** Instruction does not have Beads defined\"", "0", "0", "0", "0xF", "4", "M680x0Beads::Ignore", "0xF", "\"Unknown Bead code\"", "M680x0Beads::Bits1", "M680x0Beads::Bits2", "M680x0Beads::Bits3", "M680x0Beads::Bits4", "M680x0Beads::DAReg", "M680x0Beads::DA", "M680x0Beads::Reg", "M680x0Beads::Disp8", "M680x0Beads::Imm8", "M680x0Beads::Imm16", "M680x0Beads::Imm32", "M680x0Beads::Imm3", "16", "8", "0xFF", "0", "0xFF", "16", "16", "2", "0", "\"M680x0 Instructions are % 2 bytes\"", "2", "\"M680x0 Instructions are % 2 bytes\"" ]

[]

[ "<s>", "static", "rtx", "cris_function_incoming_arg", "(", "cumulative_args_t", "ca", ",", "machine_mode", "mode", ",", "const_tree", "type", ",", "bool", "named", ")", "{", "return", "cris_function_arg_1", "(", "ca", ",", "mode", ",", "type", ",", "named", ",", "true", ")", ";", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_FUNCTION_INCOMING_ARG", ".", "The", "differences", "between", "this", "and", "the", "previous", ",", "is", "that", "this", "one", "checks", "that", "an", "argument", "is", "named", ",", "since", "incoming", "stdarg/varargs", "arguments", "are", "pushed", "onto", "the", "stack", ",", "and", "we", "do", "n't", "have", "to", "check", "against", "the", "``", "closing", "''", "void_type_node", "TYPE", "parameter", "." ]

[ "cris" ]

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "{", "assert", "(", "Kind", "==", "Register", "&&", "\"Invalid type access!\"", ")", ";", "return", "Reg", ".", "RegNum", ";", "}", "</s>" ]

[ "Returns", "the", "register", "associated", "with", "this", "edge", "." ]

[ "AAP", "\"Invalid type access!\"" ]

[]

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

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

[ "ARM" ]

[]

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

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

[ "AAP", "\"AAP DAG->DAG Pattern Instruction Selection\"" ]

[]

[ "<s>", "static", "int", "ft32_arg_partial_bytes", "(", "cumulative_args_t", "cum_v", ",", "machine_mode", "mode", ",", "tree", "type", ",", "bool", "named", ")", "{", "CUMULATIVE_ARGS", "*", "cum", "=", "get_cumulative_args", "(", "cum_v", ")", ";", "int", "bytes_left", ",", "size", ";", "if", "(", "*", "cum", ">=", "8", ")", "return", "0", ";", "if", "(", "ft32_pass_by_reference", "(", "cum_v", ",", "mode", ",", "type", ",", "named", ")", ")", "size", "=", "4", ";", "else", "if", "(", "type", ")", "{", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", ")", "return", "0", ";", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "}", "else", "size", "=", "GET_MODE_SIZE", "(", "mode", ")", ";", "bytes_left", "=", "(", "4", "*", "6", ")", "-", "(", "(", "*", "cum", "-", "2", ")", "*", "4", ")", ";", "if", "(", "size", ">", "bytes_left", ")", "return", "bytes_left", ";", "else", "return", "0", ";", "}", "</s>" ]

[ "Some", "function", "arguments", "will", "only", "partially", "fit", "in", "the", "registers", "that", "hold", "arguments", ".", "Given", "a", "new", "arg", ",", "return", "the", "number", "of", "bytes", "that", "fit", "in", "argument", "passing", "registers", "." ]

[ "ft32", "8", "0", "4", "0", "4", "6", "2", "4", "0" ]

[]

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

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

[ "Nios2", "Nios2" ]

[]

[ "<s>", "bool", "AGCInstrInfo", "::", "isCopyInstrImpl", "(", "const", "MachineInstr", "&", "MI", ",", "const", "MachineOperand", "*", "&", "SourceOpNum", ",", "const", "MachineOperand", "*", "&", "Destination", ")", "const", "{", "switch", "(", "MI", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "AGC", "::", "CA", ":", "case", "AGC", "::", "TS", ":", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "If", "the", "specific", "machine", "instruction", "is", "a", "instruction", "that", "moves/copies", "value", "from", "one", "register", "to", "another", "register", "return", "destination", "and", "source", "registers", "as", "machine", "operands", "." ]

[ "AGC", "AGC", "AGC::CA", "AGC::TS" ]

[]

[ "<s>", "MCFixupKindInfo", "const", "&", "AVRAsmBackend", "::", "getFixupKindInfo", "(", "MCFixupKind", "Kind", ")", "const", "{", "const", "static", "MCFixupKindInfo", "Infos", "[", "AVR", "::", "NumTargetFixupKinds", "]", "=", "{", "{", "\"fixup_32\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_7_pcrel\"", ",", "3", ",", "7", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_13_pcrel\"", ",", "0", ",", "12", ",", "MCFixupKindInfo", "::", "FKF_IsPCRel", "}", ",", "{", "\"fixup_16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_16_pm\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_ldi\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_lo8_ldi\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hi8_ldi\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hh8_ldi\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_ms8_ldi\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_lo8_ldi_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hi8_ldi_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hh8_ldi_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_ms8_ldi_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_lo8_ldi_pm\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hi8_ldi_pm\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hh8_ldi_pm\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_lo8_ldi_pm_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hi8_ldi_pm_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hh8_ldi_pm_neg\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_call\"", ",", "0", ",", "22", ",", "0", "}", ",", "{", "\"fixup_6\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_6_adiw\"", ",", "0", ",", "6", ",", "0", "}", ",", "{", "\"fixup_lo8_ldi_gs\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_hi8_ldi_gs\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_8\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_8_lo8\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_8_hi8\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_8_hlo8\"", ",", "0", ",", "8", ",", "0", "}", ",", "{", "\"fixup_sym_diff\"", ",", "0", ",", "32", ",", "0", "}", ",", "{", "\"fixup_16_ldst\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_lds_sts_16\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_port6\"", ",", "0", ",", "16", ",", "0", "}", ",", "{", "\"fixup_port5\"", ",", "3", ",", "5", ",", "0", "}", ",", "}", ";", "if", "(", "Kind", "<", "FirstTargetFixupKind", ")", "return", "MCAsmBackend", "::", "getFixupKindInfo", "(", "Kind", ")", ";", "assert", "(", "unsigned", "(", "Kind", "-", "FirstTargetFixupKind", ")", "<", "getNumFixupKinds", "(", ")", "&&", "\"Invalid kind!\"", ")", ";", "return", "Infos", "[", "Kind", "-", "FirstTargetFixupKind", "]", ";", "}", "</s>" ]

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

[ "AVR", "AVR", "AVR::NumTargetFixupKinds", "\"fixup_32\"", "0", "32", "0", "\"fixup_7_pcrel\"", "3", "7", "\"fixup_13_pcrel\"", "0", "12", "\"fixup_16\"", "0", "16", "0", "\"fixup_16_pm\"", "0", "16", "0", "\"fixup_ldi\"", "0", "8", "0", "\"fixup_lo8_ldi\"", "0", "8", "0", "\"fixup_hi8_ldi\"", "0", "8", "0", "\"fixup_hh8_ldi\"", "0", "8", "0", "\"fixup_ms8_ldi\"", "0", "8", "0", "\"fixup_lo8_ldi_neg\"", "0", "8", "0", "\"fixup_hi8_ldi_neg\"", "0", "8", "0", "\"fixup_hh8_ldi_neg\"", "0", "8", "0", "\"fixup_ms8_ldi_neg\"", "0", "8", "0", "\"fixup_lo8_ldi_pm\"", "0", "8", "0", "\"fixup_hi8_ldi_pm\"", "0", "8", "0", "\"fixup_hh8_ldi_pm\"", "0", "8", "0", "\"fixup_lo8_ldi_pm_neg\"", "0", "8", "0", "\"fixup_hi8_ldi_pm_neg\"", "0", "8", "0", "\"fixup_hh8_ldi_pm_neg\"", "0", "8", "0", "\"fixup_call\"", "0", "22", "0", "\"fixup_6\"", "0", "16", "0", "\"fixup_6_adiw\"", "0", "6", "0", "\"fixup_lo8_ldi_gs\"", "0", "8", "0", "\"fixup_hi8_ldi_gs\"", "0", "8", "0", "\"fixup_8\"", "0", "8", "0", "\"fixup_8_lo8\"", "0", "8", "0", "\"fixup_8_hi8\"", "0", "8", "0", "\"fixup_8_hlo8\"", "0", "8", "0", "\"fixup_sym_diff\"", "0", "32", "0", "\"fixup_16_ldst\"", "0", "16", "0", "\"fixup_lds_sts_16\"", "0", "16", "0", "\"fixup_port6\"", "0", "16", "0", "\"fixup_port5\"", "3", "5", "0", "\"Invalid kind!\"" ]

[]

[ "<s>", "void", "ScheduleDAGPostRA", "::", "releaseSuccessors", "(", "SUnit", "*", "SU", ")", "{", "for", "(", "SUnit", "::", "succ_iterator", "I", "=", "SU", "->", "Succs", ".", "begin", "(", ")", ",", "E", "=", "SU", "->", "Succs", ".", "end", "(", ")", ";", "I", "!=", "E", ";", "++", "I", ")", "{", "releaseSucc", "(", "SU", ",", "&", "*", "I", ")", ";", "}", "}", "</s>" ]

[ "releaseSuccessors", "-", "Call", "releaseSucc", "on", "each", "of", "SU", "'s", "successors", "." ]

[ "Patmos" ]

[]

[ "<s>", "SDValue", "LEGTargetLowering", "::", "LowerReturn", "(", "SDValue", "Chain", ",", "CallingConv", "::", "ID", "CallConv", ",", "bool", "isVarArg", ",", "const", "SmallVectorImpl", "<", "ISD", "::", "OutputArg", ">", "&", "Outs", ",", "const", "SmallVectorImpl", "<", "SDValue", ">", "&", "OutVals", ",", "SDLoc", "dl", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "if", "(", "isVarArg", ")", "{", "report_fatal_error", "(", "\"VarArg not supported\"", ")", ";", "}", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallConv", ",", "isVarArg", ",", "DAG", ".", "getMachineFunction", "(", ")", ",", "RVLocs", ",", "*", "DAG", ".", "getContext", "(", ")", ")", ";", "CCInfo", ".", "AnalyzeReturn", "(", "Outs", ",", "RetCC_LEG", ")", ";", "SDValue", "Flag", ";", "SmallVector", "<", "SDValue", ",", "4", ">", "RetOps", "(", "1", ",", "Chain", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "RVLocs", ".", "size", "(", ")", ";", "i", "<", "e", ";", "++", "i", ")", "{", "CCValAssign", "&", "VA", "=", "RVLocs", "[", "i", "]", ";", "assert", "(", "VA", ".", "isRegLoc", "(", ")", "&&", "\"Can only return in registers!\"", ")", ";", "Chain", "=", "DAG", ".", "getCopyToReg", "(", "Chain", ",", "dl", ",", "VA", ".", "getLocReg", "(", ")", ",", "OutVals", "[", "i", "]", ",", "Flag", ")", ";", "Flag", "=", "Chain", ".", "getValue", "(", "1", ")", ";", "RetOps", ".", "push_back", "(", "DAG", ".", "getRegister", "(", "VA", ".", "getLocReg", "(", ")", ",", "VA", ".", "getLocVT", "(", ")", ")", ")", ";", "}", "RetOps", "[", "0", "]", "=", "Chain", ";", "if", "(", "Flag", ".", "getNode", "(", ")", ")", "{", "RetOps", ".", "push_back", "(", "Flag", ")", ";", "}", "return", "DAG", ".", "getNode", "(", "LEGISD", "::", "RET_FLAG", ",", "dl", ",", "MVT", "::", "Other", ",", "RetOps", ")", ";", "}", "</s>" ]

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

[ "LEG", "LEG", "ISD::OutputArg", "\"VarArg not supported\"", "16", "LEG", "4", "1", "0", "\"Can only return in registers!\"", "1", "0", "LEGISD::RET_FLAG", "MVT::Other" ]

[]

[ "<s>", "static", "unsigned", "int", "swap_feeds_both_load_and_store", "(", "swap_web_entry", "*", "insn_entry", ")", "{", "rtx", "insn", "=", "insn_entry", "->", "insn", ";", "struct", "df_insn_info", "*", "insn_info", "=", "DF_INSN_INFO_GET", "(", "insn", ")", ";", "df_ref", "def", ",", "use", ";", "struct", "df_link", "*", "link", "=", "0", ";", "rtx_insn", "*", "load", "=", "0", ",", "*", "store", "=", "0", ";", "bool", "fed_by_load", "=", "0", ";", "bool", "feeds_store", "=", "0", ";", "FOR_EACH_INSN_INFO_USE", "(", "use", ",", "insn_info", ")", "{", "link", "=", "DF_REF_CHAIN", "(", "use", ")", ";", "load", "=", "DF_REF_INSN", "(", "link", "->", "ref", ")", ";", "if", "(", "insn_is_load_p", "(", "load", ")", "&&", "insn_is_swap_p", "(", "load", ")", ")", "fed_by_load", "=", "1", ";", "}", "FOR_EACH_INSN_INFO_DEF", "(", "def", ",", "insn_info", ")", "{", "link", "=", "DF_REF_CHAIN", "(", "def", ")", ";", "store", "=", "DF_REF_INSN", "(", "link", "->", "ref", ")", ";", "if", "(", "insn_is_store_p", "(", "store", ")", "&&", "insn_is_swap_p", "(", "store", ")", ")", "feeds_store", "=", "1", ";", "}", "return", "fed_by_load", "&&", "feeds_store", ";", "}", "</s>" ]

[ "Return", "1", "iff", "UID", ",", "known", "to", "reference", "a", "swap", ",", "is", "both", "fed", "by", "a", "load", "and", "a", "feeder", "of", "a", "store", "." ]

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

[]