Datasets:

---

docz1105

/

ComBack

like 9

[ "<s>", "static", "rtx", "frv_expand_voidtriop_builtin", "(", "enum", "insn_code", "icode", ",", "tree", "call", ")", "{", "rtx", "pat", ";", "rtx", "op0", "=", "frv_read_argument", "(", "call", ",", "0", ")", ";", "rtx", "op1", "=", "frv_read_argument", "(", "call", ",", "1", ")", ";", "rtx", "op2", "=", "frv_read_argument", "(", "call", ",", "2", ")", ";", "rtx", "op3", ";", "op0", "=", "frv_int_to_acc", "(", "icode", ",", "0", ",", "op0", ")", ";", "if", "(", "!", "op0", ")", "return", "NULL_RTX", ";", "op1", "=", "frv_legitimize_argument", "(", "icode", ",", "1", ",", "op1", ")", ";", "op2", "=", "frv_legitimize_argument", "(", "icode", ",", "2", ",", "op2", ")", ";", "op3", "=", "frv_matching_accg_for_acc", "(", "op0", ")", ";", "pat", "=", "GEN_FCN", "(", "icode", ")", "(", "op0", ",", "op1", ",", "op2", ",", "op3", ")", ";", "if", "(", "!", "pat", ")", "return", "NULL_RTX", ";", "emit_insn", "(", "pat", ")", ";", "return", "NULL_RTX", ";", "}", "</s>" ]

[ "Expand", "builtins", "that", "take", "three", "operands", "and", "return", "void", ".", "The", "first", "argument", "must", "be", "a", "constant", "that", "describes", "a", "pair", "or", "quad", "accumulators", ".", "A", "fourth", "argument", "is", "created", "that", "is", "the", "accumulator", "guard", "register", "that", "corresponds", "to", "the", "accumulator", "." ]

[ "frv", "0", "1", "2", "0", "1", "2" ]

[]

[ "<s>", "int", "PPCTTIImpl", "::", "getIntImmCost", "(", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ")", "{", "if", "(", "DisablePPCConstHoist", ")", "return", "BaseT", "::", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ";", "assert", "(", "Ty", "->", "isIntegerTy", "(", ")", ")", ";", "unsigned", "BitSize", "=", "Ty", "->", "getPrimitiveSizeInBits", "(", ")", ";", "if", "(", "BitSize", "==", "0", ")", "return", "~", "0U", ";", "if", "(", "Imm", "==", "0", ")", "return", "TTI", "::", "TCC_Free", ";", "if", "(", "Imm", ".", "getBitWidth", "(", ")", "<=", "64", ")", "{", "if", "(", "isInt", "<", "16", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "return", "TTI", "::", "TCC_Basic", ";", "if", "(", "isInt", "<", "32", ">", "(", "Imm", ".", "getSExtValue", "(", ")", ")", ")", "{", "if", "(", "(", "Imm", ".", "getZExtValue", "(", ")", "&", "0xFFFF", ")", "==", "0", ")", "return", "TTI", "::", "TCC_Basic", ";", "return", "2", "*", "TTI", "::", "TCC_Basic", ";", "}", "}", "return", "4", "*", "TTI", "::", "TCC_Basic", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "SystemZInstrInfo", "::", "isProfitableToDupForIfCvt", "(", "MachineBasicBlock", "&", "MBB", ",", "unsigned", "NumCycles", ",", "BranchProbability", "Probability", ")", "const", "{", "return", "NumCycles", "==", "1", ";", "}", "</s>" ]

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

[ "SystemZ", "SystemZ", "1" ]

[]

[ "<s>", "void", "emitInstruction", "(", "const", "MCInst", "&", "Inst", ",", "const", "MCSubtargetInfo", "&", "STI", ")", "override", "{", "if", "(", "isIndirectJump", "(", "Inst", ")", ")", "{", "if", "(", "PendingCall", ")", "report_fatal_error", "(", "\"Dangerous instruction in branch delay slot!\"", ")", ";", "sandboxIndirectJump", "(", "Inst", ",", "STI", ")", ";", "return", ";", "}", "unsigned", "AddrIdx", "=", "0", ";", "bool", "IsStore", "=", "false", ";", "bool", "IsMemAccess", "=", "isBasePlusOffsetMemoryAccess", "(", "Inst", ".", "getOpcode", "(", ")", ",", "&", "AddrIdx", ",", "&", "IsStore", ")", ";", "bool", "IsSPFirstOperand", "=", "isStackPointerFirstOperand", "(", "Inst", ")", ";", "if", "(", "IsMemAccess", "||", "IsSPFirstOperand", ")", "{", "bool", "MaskBefore", "=", "(", "IsMemAccess", "&&", "baseRegNeedsLoadStoreMask", "(", "Inst", ".", "getOperand", "(", "AddrIdx", ")", ".", "getReg", "(", ")", ")", ")", ";", "bool", "MaskAfter", "=", "IsSPFirstOperand", "&&", "!", "IsStore", ";", "if", "(", "MaskBefore", "||", "MaskAfter", ")", "{", "if", "(", "PendingCall", ")", "report_fatal_error", "(", "\"Dangerous instruction in branch delay slot!\"", ")", ";", "sandboxLoadStoreStackChange", "(", "Inst", ",", "AddrIdx", ",", "STI", ",", "MaskBefore", ",", "MaskAfter", ")", ";", "return", ";", "}", "}", "bool", "IsIndirectCall", ";", "if", "(", "isCall", "(", "Inst", ",", "&", "IsIndirectCall", ")", ")", "{", "if", "(", "PendingCall", ")", "report_fatal_error", "(", "\"Dangerous instruction in branch delay slot!\"", ")", ";", "emitBundleLock", "(", "true", ")", ";", "if", "(", "IsIndirectCall", ")", "{", "unsigned", "TargetReg", "=", "Inst", ".", "getOperand", "(", "1", ")", ".", "getReg", "(", ")", ";", "emitMask", "(", "TargetReg", ",", "IndirectBranchMaskReg", ",", "STI", ")", ";", "}", "MipsELFStreamer", "::", "emitInstruction", "(", "Inst", ",", "STI", ")", ";", "PendingCall", "=", "true", ";", "return", ";", "}", "if", "(", "PendingCall", ")", "{", "MipsELFStreamer", "::", "emitInstruction", "(", "Inst", ",", "STI", ")", ";", "emitBundleUnlock", "(", ")", ";", "PendingCall", "=", "false", ";", "return", ";", "}", "MipsELFStreamer", "::", "emitInstruction", "(", "Inst", ",", "STI", ")", ";", "}", "</s>" ]

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

[ "Mips", "\"Dangerous instruction in branch delay slot!\"", "0", "\"Dangerous instruction in branch delay slot!\"", "\"Dangerous instruction in branch delay slot!\"", "1", "Mips", "Mips", "Mips" ]

[]

[ "<s>", "bool", "MipsPassConfig", "::", "addPreRegAlloc", "(", ")", "{", "if", "(", "!", "getMipsSubtarget", "(", ")", ".", "hasMips64", "(", ")", ")", "PM", ".", "add", "(", "createMipsEmitGPRestorePass", "(", "getMipsTargetMachine", "(", ")", ")", ")", ";", "return", "true", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "AArch64RedundantCopyElimination", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "if", "(", "skipFunction", "(", "MF", ".", "getFunction", "(", ")", ")", ")", "return", "false", ";", "TRI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getRegisterInfo", "(", ")", ";", "MRI", "=", "&", "MF", ".", "getRegInfo", "(", ")", ";", "DomBBClobberedRegs", ".", "init", "(", "*", "TRI", ")", ";", "DomBBUsedRegs", ".", "init", "(", "*", "TRI", ")", ";", "OptBBClobberedRegs", ".", "init", "(", "*", "TRI", ")", ";", "OptBBUsedRegs", ".", "init", "(", "*", "TRI", ")", ";", "bool", "Changed", "=", "false", ";", "for", "(", "MachineBasicBlock", "&", "MBB", ":", "MF", ")", "Changed", "|=", "optimizeBlock", "(", "&", "MBB", ")", ";", "return", "Changed", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]

[ "<s>", "SDNode", "*", "SparcDAGToDAGISel", "::", "Select", "(", "SDNode", "*", "N", ")", "{", "SDLoc", "dl", "(", "N", ")", ";", "if", "(", "N", "->", "isMachineOpcode", "(", ")", ")", "{", "N", "->", "setNodeId", "(", "-", "1", ")", ";", "return", "nullptr", ";", "}", "switch", "(", "N", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "break", ";", "case", "ISD", "::", "INLINEASM", ":", "{", "SDNode", "*", "ResNode", "=", "SelectInlineAsm", "(", "N", ")", ";", "if", "(", "ResNode", ")", "return", "ResNode", ";", "break", ";", "}", "case", "SPISD", "::", "GLOBAL_BASE_REG", ":", "return", "getGlobalBaseReg", "(", ")", ";", "case", "ISD", "::", "SDIV", ":", "case", "ISD", "::", "UDIV", ":", "{", "if", "(", "N", "->", "getValueType", "(", "0", ")", "==", "MVT", "::", "i64", ")", "break", ";", "SDValue", "DivLHS", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "DivRHS", "=", "N", "->", "getOperand", "(", "1", ")", ";", "SDValue", "TopPart", ";", "if", "(", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SDIV", ")", "{", "TopPart", "=", "SDValue", "(", "CurDAG", "->", "getMachineNode", "(", "SP", "::", "SRAri", ",", "dl", ",", "MVT", "::", "i32", ",", "DivLHS", ",", "CurDAG", "->", "getTargetConstant", "(", "31", ",", "dl", ",", "MVT", "::", "i32", ")", ")", ",", "0", ")", ";", "}", "else", "{", "TopPart", "=", "CurDAG", "->", "getRegister", "(", "SP", "::", "G0", ",", "MVT", "::", "i32", ")", ";", "}", "TopPart", "=", "CurDAG", "->", "getCopyToReg", "(", "CurDAG", "->", "getEntryNode", "(", ")", ",", "dl", ",", "SP", "::", "Y", ",", "TopPart", ",", "SDValue", "(", ")", ")", ".", "getValue", "(", "1", ")", ";", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "SDIV", "?", "SP", "::", "SDIVrr", ":", "SP", "::", "UDIVrr", ";", "return", "CurDAG", "->", "SelectNodeTo", "(", "N", ",", "Opcode", ",", "MVT", "::", "i32", ",", "DivLHS", ",", "DivRHS", ",", "TopPart", ")", ";", "}", "case", "ISD", "::", "MULHU", ":", "case", "ISD", "::", "MULHS", ":", "{", "SDValue", "MulLHS", "=", "N", "->", "getOperand", "(", "0", ")", ";", "SDValue", "MulRHS", "=", "N", "->", "getOperand", "(", "1", ")", ";", "unsigned", "Opcode", "=", "N", "->", "getOpcode", "(", ")", "==", "ISD", "::", "MULHU", "?", "SP", "::", "UMULrr", ":", "SP", "::", "SMULrr", ";", "SDNode", "*", "Mul", "=", "CurDAG", "->", "getMachineNode", "(", "Opcode", ",", "dl", ",", "MVT", "::", "i32", ",", "MVT", "::", "i32", ",", "MulLHS", ",", "MulRHS", ")", ";", "SDValue", "ResultHigh", "=", "SDValue", "(", "Mul", ",", "1", ")", ";", "ReplaceUses", "(", "SDValue", "(", "N", ",", "0", ")", ",", "ResultHigh", ")", ";", "return", "nullptr", ";", "}", "}", "return", "SelectCode", "(", "N", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "1", "ISD::INLINEASM", "SPISD::GLOBAL_BASE_REG", "ISD::SDIV", "ISD::UDIV", "0", "MVT::i64", "0", "1", "ISD::SDIV", "SP::SRAri", "MVT::i32", "31", "MVT::i32", "0", "SP::G0", "MVT::i32", "SP::Y", "1", "ISD::SDIV", "SP::SDIVrr", "SP::UDIVrr", "MVT::i32", "ISD::MULHU", "ISD::MULHS", "0", "1", "ISD::MULHU", "SP::UMULrr", "SP::SMULrr", "MVT::i32", "MVT::i32", "1", "0" ]

[]

[ "<s>", "InstructionCost", "ARMTTIImpl", "::", "getIntImmCostInst", "(", "unsigned", "Opcode", ",", "unsigned", "Idx", ",", "const", "APInt", "&", "Imm", ",", "Type", "*", "Ty", ",", "TTI", "::", "TargetCostKind", "CostKind", ",", "Instruction", "*", "Inst", ")", "{", "if", "(", "(", "Opcode", "==", "Instruction", "::", "SDiv", "||", "Opcode", "==", "Instruction", "::", "UDiv", "||", "Opcode", "==", "Instruction", "::", "SRem", "||", "Opcode", "==", "Instruction", "::", "URem", ")", "&&", "Idx", "==", "1", ")", "return", "0", ";", "if", "(", "Opcode", "==", "Instruction", "::", "GetElementPtr", "&&", "Idx", "!=", "0", ")", "return", "0", ";", "if", "(", "Opcode", "==", "Instruction", "::", "And", ")", "{", "if", "(", "Imm", "==", "255", "||", "Imm", "==", "65535", ")", "return", "0", ";", "return", "std", "::", "min", "(", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ",", "getIntImmCost", "(", "~", "Imm", ",", "Ty", ",", "CostKind", ")", ")", ";", "}", "if", "(", "Opcode", "==", "Instruction", "::", "Add", ")", "return", "std", "::", "min", "(", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ",", "getIntImmCost", "(", "-", "Imm", ",", "Ty", ",", "CostKind", ")", ")", ";", "if", "(", "Opcode", "==", "Instruction", "::", "ICmp", "&&", "Imm", ".", "isNegative", "(", ")", "&&", "Ty", "->", "getIntegerBitWidth", "(", ")", "==", "32", ")", "{", "int64_t", "NegImm", "=", "-", "Imm", ".", "getSExtValue", "(", ")", ";", "if", "(", "ST", "->", "isThumb2", "(", ")", "&&", "NegImm", "<", "1", "<<", "12", ")", "return", "0", ";", "if", "(", "ST", "->", "isThumb", "(", ")", "&&", "NegImm", "<", "1", "<<", "8", ")", "return", "0", ";", "}", "if", "(", "Opcode", "==", "Instruction", "::", "Xor", "&&", "Imm", ".", "isAllOnes", "(", ")", ")", "return", "0", ";", "if", "(", "Inst", "&&", "(", "(", "ST", "->", "hasV6Ops", "(", ")", "&&", "!", "ST", "->", "isThumb", "(", ")", ")", "||", "ST", "->", "isThumb2", "(", ")", ")", "&&", "Ty", "->", "getIntegerBitWidth", "(", ")", "<=", "32", ")", "{", "if", "(", "isSSATMinMaxPattern", "(", "Inst", ",", "Imm", ")", "||", "(", "isa", "<", "ICmpInst", ">", "(", "Inst", ")", "&&", "Inst", "->", "hasOneUse", "(", ")", "&&", "isSSATMinMaxPattern", "(", "cast", "<", "Instruction", ">", "(", "*", "Inst", "->", "user_begin", "(", ")", ")", ",", "Imm", ")", ")", ")", "return", "0", ";", "}", "if", "(", "Inst", "&&", "ST", "->", "hasVFP2Base", "(", ")", "&&", "isFPSatMinMaxPattern", "(", "Inst", ",", "Imm", ")", ")", "return", "0", ";", "if", "(", "Inst", "&&", "Opcode", "==", "Instruction", "::", "ICmp", "&&", "Idx", "==", "1", "&&", "Imm", ".", "isAllOnesValue", "(", ")", ")", "{", "ICmpInst", "::", "Predicate", "Pred", "=", "cast", "<", "ICmpInst", ">", "(", "Inst", ")", "->", "getPredicate", "(", ")", ";", "if", "(", "Pred", "==", "ICmpInst", "::", "ICMP_SGT", "||", "Pred", "==", "ICmpInst", "::", "ICMP_SLE", ")", "return", "std", "::", "min", "(", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ",", "getIntImmCost", "(", "Imm", "+", "1", ",", "Ty", ",", "CostKind", ")", ")", ";", "}", "return", "getIntImmCost", "(", "Imm", ",", "Ty", ",", "CostKind", ")", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "1", "0", "0", "0", "255", "65535", "0", "32", "1", "12", "0", "1", "8", "0", "0", "32", "0", "0", "1", "1" ]

[]

[ "<s>", "bool", "ARMConstantIslands", "::", "runOnMachineFunction", "(", "MachineFunction", "&", "MF", ")", "{", "MachineConstantPool", "&", "MCP", "=", "*", "MF", ".", "getConstantPool", "(", ")", ";", "TII", "=", "MF", ".", "getTarget", "(", ")", ".", "getInstrInfo", "(", ")", ";", "AFI", "=", "MF", ".", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "STI", "=", "&", "MF", ".", "getTarget", "(", ")", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", ")", ";", "isThumb", "=", "AFI", "->", "isThumbFunction", "(", ")", ";", "isThumb1", "=", "AFI", "->", "isThumb1OnlyFunction", "(", ")", ";", "isThumb2", "=", "AFI", "->", "isThumb2Function", "(", ")", ";", "HasFarJump", "=", "false", ";", "MF", ".", "RenumberBlocks", "(", ")", ";", "AFI", "->", "setAlign", "(", "isThumb1", "?", "1U", ":", "2U", ")", ";", "std", "::", "vector", "<", "MachineInstr", "*", ">", "CPEMIs", ";", "if", "(", "!", "MCP", ".", "isEmpty", "(", ")", ")", "{", "DoInitialPlacement", "(", "MF", ",", "CPEMIs", ")", ";", "if", "(", "isThumb1", ")", "AFI", "->", "setAlign", "(", "2U", ")", ";", "}", "AFI", "->", "initConstPoolEntryUId", "(", "CPEMIs", ".", "size", "(", ")", ")", ";", "InitialFunctionScan", "(", "MF", ",", "CPEMIs", ")", ";", "CPEMIs", ".", "clear", "(", ")", ";", "RemoveUnusedCPEntries", "(", ")", ";", "bool", "MadeChange", "=", "false", ";", "unsigned", "NoCPIters", "=", "0", ",", "NoBRIters", "=", "0", ";", "while", "(", "true", ")", "{", "bool", "CPChange", "=", "false", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "CPUsers", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "CPChange", "|=", "HandleConstantPoolUser", "(", "MF", ",", "i", ")", ";", "if", "(", "CPChange", "&&", "++", "NoCPIters", ">", "30", ")", "llvm_unreachable", "(", "\"Constant Island pass failed to converge!\"", ")", ";", "DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "bool", "BRChange", "=", "false", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "ImmBranches", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "BRChange", "|=", "FixUpImmediateBr", "(", "MF", ",", "ImmBranches", "[", "i", "]", ")", ";", "if", "(", "BRChange", "&&", "++", "NoBRIters", ">", "30", ")", "llvm_unreachable", "(", "\"Branch Fix Up pass failed to converge!\"", ")", ";", "DEBUG", "(", "dumpBBs", "(", ")", ")", ";", "if", "(", "!", "CPChange", "&&", "!", "BRChange", ")", "break", ";", "MadeChange", "=", "true", ";", "}", "if", "(", "isThumb2", ")", "MadeChange", "|=", "OptimizeThumb2Instructions", "(", "MF", ")", ";", "verify", "(", "MF", ")", ";", "if", "(", "isThumb", "&&", "!", "HasFarJump", "&&", "AFI", "->", "isLRSpilledForFarJump", "(", ")", ")", "MadeChange", "|=", "UndoLRSpillRestore", "(", ")", ";", "BBSizes", ".", "clear", "(", ")", ";", "BBOffsets", ".", "clear", "(", ")", ";", "WaterList", ".", "clear", "(", ")", ";", "CPUsers", ".", "clear", "(", ")", ";", "CPEntries", ".", "clear", "(", ")", ";", "ImmBranches", ".", "clear", "(", ")", ";", "PushPopMIs", ".", "clear", "(", ")", ";", "T2JumpTables", ".", "clear", "(", ")", ";", "return", "MadeChange", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "ARM", "ARM", "1U", "2U", "2U", "0", "0", "0", "30", "\"Constant Island pass failed to converge!\"", "0", "30", "\"Branch Fix Up pass failed to converge!\"" ]

[]

[ "<s>", "static", "void", "init_alignment_context", "(", "struct", "alignment_context", "*", "ac", ",", "rtx", "mem", ",", "machine_mode", "mode", ")", "{", "ac", "->", "shift", "=", "GEN_INT", "(", "GET_MODE_SIZE", "(", "SImode", ")", "-", "GET_MODE_SIZE", "(", "mode", ")", ")", ";", "ac", "->", "aligned", "=", "(", "MEM_ALIGN", "(", "mem", ")", ">=", "GET_MODE_BITSIZE", "(", "SImode", ")", ")", ";", "if", "(", "ac", "->", "aligned", ")", "ac", "->", "memsi", "=", "adjust_address", "(", "mem", ",", "SImode", ",", "0", ")", ";", "else", "{", "rtx", "byteoffset", ",", "addr", ",", "align", ";", "addr", "=", "force_reg", "(", "Pmode", ",", "XEXP", "(", "mem", ",", "0", ")", ")", ";", "align", "=", "expand_simple_binop", "(", "Pmode", ",", "AND", ",", "addr", ",", "GEN_INT", "(", "-", "GET_MODE_SIZE", "(", "SImode", ")", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "ac", "->", "memsi", "=", "gen_rtx_MEM", "(", "SImode", ",", "align", ")", ";", "MEM_VOLATILE_P", "(", "ac", "->", "memsi", ")", "=", "MEM_VOLATILE_P", "(", "mem", ")", ";", "set_mem_alias_set", "(", "ac", "->", "memsi", ",", "ALIAS_SET_MEMORY_BARRIER", ")", ";", "set_mem_align", "(", "ac", "->", "memsi", ",", "GET_MODE_BITSIZE", "(", "SImode", ")", ")", ";", "byteoffset", "=", "expand_simple_binop", "(", "Pmode", ",", "AND", ",", "addr", ",", "GEN_INT", "(", "GET_MODE_SIZE", "(", "SImode", ")", "-", "1", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "ac", "->", "shift", "=", "expand_simple_binop", "(", "SImode", ",", "MINUS", ",", "ac", "->", "shift", ",", "byteoffset", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "}", "ac", "->", "shift", "=", "expand_simple_binop", "(", "SImode", ",", "ASHIFT", ",", "ac", "->", "shift", ",", "GEN_INT", "(", "3", ")", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "ac", "->", "modemask", "=", "expand_simple_binop", "(", "SImode", ",", "ASHIFT", ",", "GEN_INT", "(", "GET_MODE_MASK", "(", "mode", ")", ")", ",", "ac", "->", "shift", ",", "NULL_RTX", ",", "1", ",", "OPTAB_DIRECT", ")", ";", "ac", "->", "modemaski", "=", "expand_simple_unop", "(", "SImode", ",", "NOT", ",", "ac", "->", "modemask", ",", "NULL_RTX", ",", "1", ")", ";", "}", "</s>" ]

[ "Initialize", "structure", "AC", "for", "word", "access", "to", "HI", "and", "QI", "mode", "memory", "." ]

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

[]

[ "<s>", "unsigned", "AMDGPUCommonSubtarget", "::", "getMaxLocalMemSizeWithWaveCount", "(", "unsigned", "NWaves", ",", "const", "Function", "&", "F", ")", "const", "{", "if", "(", "NWaves", "==", "1", ")", "return", "getLocalMemorySize", "(", ")", ";", "unsigned", "WorkGroupSize", "=", "getFlatWorkGroupSizes", "(", "F", ")", ".", "second", ";", "unsigned", "WorkGroupsPerCu", "=", "getMaxWorkGroupsPerCU", "(", "WorkGroupSize", ")", ";", "unsigned", "MaxWaves", "=", "getMaxWavesPerEU", "(", ")", ";", "return", "getLocalMemorySize", "(", ")", "*", "MaxWaves", "/", "WorkGroupsPerCu", "/", "NWaves", ";", "}", "</s>" ]

[ "Return", "the", "amount", "of", "LDS", "that", "can", "be", "used", "that", "will", "not", "restrict", "the", "occupancy", "lower", "than", "WaveCount", "." ]

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

[]

[ "<s>", "unsigned", "getReg", "(", ")", "const", "override", "{", "return", "Reg", ".", "RegNo", ";", "}", "</s>" ]

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

[ "AMDGPU" ]

[]

[ "<s>", "static", "void", "s390_reorg", "(", "void", ")", "{", "bool", "pool_overflow", "=", "false", ";", "int", "hw_before", ",", "hw_after", ";", "if", "(", "s390_tune", "==", "PROCESSOR_2964_Z13", ")", "s390_adjust_loops", "(", ")", ";", "split_all_insns_noflow", "(", ")", ";", "for", "(", ";", ";", ")", "{", "struct", "constant_pool", "*", "pool", "=", "NULL", ";", "if", "(", "!", "pool_overflow", ")", "{", "pool", "=", "s390_mainpool_start", "(", ")", ";", "if", "(", "!", "pool", ")", "pool_overflow", "=", "true", ";", "}", "if", "(", "pool_overflow", ")", "pool", "=", "s390_chunkify_start", "(", ")", ";", "if", "(", "!", "TARGET_CPU_ZARCH", "&&", "s390_split_branches", "(", ")", ")", "{", "if", "(", "pool_overflow", ")", "s390_chunkify_cancel", "(", "pool", ")", ";", "else", "s390_mainpool_cancel", "(", "pool", ")", ";", "continue", ";", "}", "if", "(", "pool_overflow", ")", "s390_chunkify_finish", "(", "pool", ")", ";", "else", "s390_mainpool_finish", "(", "pool", ")", ";", "cfun", "->", "machine", "->", "split_branches_pending_p", "=", "false", ";", "break", ";", "}", "if", "(", "TARGET_CPU_ZARCH", ")", "{", "rtx_insn", "*", "insn", ",", "*", "target", ";", "rtx", "label", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "label", "=", "s390_execute_label", "(", "insn", ")", ";", "if", "(", "!", "label", ")", "continue", ";", "gcc_assert", "(", "label", "!=", "const0_rtx", ")", ";", "target", "=", "emit_label", "(", "XEXP", "(", "label", ",", "0", ")", ")", ";", "INSN_ADDRESSES_NEW", "(", "target", ",", "-", "1", ")", ";", "target", "=", "emit_insn", "(", "s390_execute_target", "(", "insn", ")", ")", ";", "INSN_ADDRESSES_NEW", "(", "target", ",", "-", "1", ")", ";", "}", "}", "s390_optimize_prologue", "(", ")", ";", "if", "(", "s390_tune", ">=", "PROCESSOR_2097_Z10", ")", "{", "rtx_insn", "*", "insn", ";", "bool", "insn_added_p", "=", "false", ";", "shorten_branches", "(", "get_insns", "(", ")", ")", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "{", "if", "(", "!", "INSN_P", "(", "insn", ")", "||", "INSN_CODE", "(", "insn", ")", "<=", "0", ")", "continue", ";", "if", "(", "JUMP_P", "(", "insn", ")", ")", "insn_added_p", "|=", "s390_fix_long_loop_prediction", "(", "insn", ")", ";", "if", "(", "(", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "PARALLEL", "||", "GET_CODE", "(", "PATTERN", "(", "insn", ")", ")", "==", "SET", ")", "&&", "s390_tune", "==", "PROCESSOR_2097_Z10", ")", "insn_added_p", "|=", "s390_z10_optimize_cmp", "(", "insn", ")", ";", "}", "if", "(", "insn_added_p", ")", "shorten_branches", "(", "get_insns", "(", ")", ")", ";", "}", "s390_function_num_hotpatch_hw", "(", "current_function_decl", ",", "&", "hw_before", ",", "&", "hw_after", ")", ";", "if", "(", "hw_after", ">", "0", ")", "{", "rtx_insn", "*", "insn", ";", "for", "(", "insn", "=", "get_insns", "(", ")", ";", "insn", ";", "insn", "=", "NEXT_INSN", "(", "insn", ")", ")", "if", "(", "active_insn_p", "(", "insn", ")", "||", "BARRIER_P", "(", "insn", ")", "||", "LABEL_P", "(", "insn", ")", ")", "break", ";", "while", "(", "insn", "&&", "hw_after", ">", "0", ")", "{", "if", "(", "hw_after", ">=", "3", "&&", "TARGET_CPU_ZARCH", ")", "{", "emit_insn_before", "(", "gen_nop_6_byte", "(", ")", ",", "insn", ")", ";", "hw_after", "-=", "3", ";", "}", "else", "if", "(", "hw_after", ">=", "2", ")", "{", "emit_insn_before", "(", "gen_nop_4_byte", "(", ")", ",", "insn", ")", ";", "hw_after", "-=", "2", ";", "}", "else", "{", "emit_insn_before", "(", "gen_nop_2_byte", "(", ")", ",", "insn", ")", ";", "hw_after", "-=", "1", ";", "}", "}", "}", "}", "</s>" ]

[ "Perform", "machine-dependent", "processing", "." ]

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

[]

[ "<s>", "const", "X86Subtarget", "*", "X86TargetMachine", "::", "getSubtargetImpl", "(", "const", "Function", "&", "F", ")", "const", "{", "Attribute", "CPUAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-cpu\"", ")", ";", "Attribute", "FSAttr", "=", "F", ".", "getFnAttribute", "(", "\"target-features\"", ")", ";", "StringRef", "CPU", "=", "!", "CPUAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "CPUAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetCPU", ";", "StringRef", "FS", "=", "!", "FSAttr", ".", "hasAttribute", "(", "Attribute", "::", "None", ")", "?", "FSAttr", ".", "getValueAsString", "(", ")", ":", "(", "StringRef", ")", "TargetFS", ";", "SmallString", "<", "512", ">", "Key", ";", "Key", ".", "reserve", "(", "CPU", ".", "size", "(", ")", "+", "FS", ".", "size", "(", ")", ")", ";", "Key", "+=", "CPU", ";", "Key", "+=", "FS", ";", "bool", "SoftFloat", "=", "F", ".", "getFnAttribute", "(", "\"use-soft-float\"", ")", ".", "getValueAsString", "(", ")", "==", "\"true\"", ";", "if", "(", "SoftFloat", ")", "Key", "+=", "FS", ".", "empty", "(", ")", "?", "\"+soft-float\"", ":", "\",+soft-float\"", ";", "FS", "=", "Key", ".", "substr", "(", "CPU", ".", "size", "(", ")", ")", ";", "auto", "&", "I", "=", "SubtargetMap", "[", "Key", "]", ";", "if", "(", "!", "I", ")", "{", "resetTargetOptions", "(", "F", ")", ";", "I", "=", "llvm", "::", "make_unique", "<", "X86Subtarget", ">", "(", "TargetTriple", ",", "CPU", ",", "FS", ",", "*", "this", ",", "Options", ".", "StackAlignmentOverride", ")", ";", "GISelAccessor", "*", "GISel", "=", "new", "GISelAccessor", "(", ")", ";", "X86GISelActualAccessor", "*", "GISel", "=", "new", "X86GISelActualAccessor", "(", ")", ";", "GISel", "->", "CallLoweringInfo", ".", "reset", "(", "new", "X86CallLowering", "(", "*", "I", "->", "getTargetLowering", "(", ")", ")", ")", ";", "GISel", "->", "Legalizer", ".", "reset", "(", "new", "X86LegalizerInfo", "(", "*", "I", ")", ")", ";", "auto", "*", "RBI", "=", "new", "X86RegisterBankInfo", "(", "*", "I", "->", "getRegisterInfo", "(", ")", ")", ";", "GISel", "->", "RegBankInfo", ".", "reset", "(", "RBI", ")", ";", "I", "->", "setGISelAccessor", "(", "*", "GISel", ")", ";", "}", "return", "I", ".", "get", "(", ")", ";", "}", "</s>" ]

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

[ "X86", "X86", "X86", "\"target-cpu\"", "\"target-features\"", "512", "\"use-soft-float\"", "\"true\"", "\"+soft-float\"", "\",+soft-float\"", "X86", "X86", "X86", "X86", "X86", "X86" ]

[]

[ "<s>", "unsigned", "SICRegisterInfo", "::", "getFrameRegister", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "MF", ".", "getSubtarget", "(", ")", ".", "getFrameLowering", "(", ")", ";", "return", "TFI", "->", "hasFP", "(", "MF", ")", "?", "(", "SIC", "::", "X", ")", ":", "(", "SIC", "::", "X", ")", ";", "}", "</s>" ]

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

[ "SIC", "SIC", "SIC::X", "SIC::X" ]

[]

[ "<s>", "SDNode", "*", "MipsTargetLowering", "::", "LowerCallResult", "(", "SDValue", "Chain", ",", "SDValue", "InFlag", ",", "CallSDNode", "*", "TheCall", ",", "unsigned", "CallingConv", ",", "SelectionDAG", "&", "DAG", ")", "{", "bool", "isVarArg", "=", "TheCall", "->", "isVarArg", "(", ")", ";", "DebugLoc", "dl", "=", "TheCall", "->", "getDebugLoc", "(", ")", ";", "SmallVector", "<", "CCValAssign", ",", "16", ">", "RVLocs", ";", "CCState", "CCInfo", "(", "CallingConv", ",", "isVarArg", ",", "getTargetMachine", "(", ")", ",", "RVLocs", ")", ";", "CCInfo", ".", "AnalyzeCallResult", "(", "TheCall", ",", "RetCC_Mips", ")", ";", "SmallVector", "<", "SDValue", ",", "8", ">", "ResultVals", ";", "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", ")", ";", "ResultVals", ".", "push_back", "(", "Chain", ".", "getValue", "(", "0", ")", ")", ";", "}", "ResultVals", ".", "push_back", "(", "Chain", ")", ";", "return", "DAG", ".", "getNode", "(", "ISD", "::", "MERGE_VALUES", ",", "dl", ",", "TheCall", "->", "getVTList", "(", ")", ",", "&", "ResultVals", "[", "0", "]", ",", "ResultVals", ".", "size", "(", ")", ")", ".", "getNode", "(", ")", ";", "}", "</s>" ]

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

[ "Mips", "Mips", "16", "Mips", "8", "0", "1", "2", "0", "ISD::MERGE_VALUES", "0" ]

[]

[ "<s>", "void", "MipsELFStreamer", "::", "EmitMipsOptionRecords", "(", ")", "{", "for", "(", "const", "auto", "&", "I", ":", "MipsOptionRecords", ")", "I", "->", "EmitMipsOptionRecord", "(", ")", ";", "}", "</s>" ]

[ "Emits", "all", "the", "option", "records", "stored", "up", "until", "the", "point", "it", "'s", "called", "." ]

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

[]

[ "<s>", "virtual", "const", "char", "*", "getPassName", "(", ")", "const", "{", "return", "\"AArch64 Assembly Printer\"", ";", "}", "</s>" ]

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

[ "AArch64", "\"AArch64 Assembly Printer\"" ]

[]

[ "<s>", "static", "int", "s390_builtin_vectorization_cost", "(", "enum", "vect_cost_for_stmt", "type_of_cost", ",", "tree", "vectype", ",", "int", "misalign", "ATTRIBUTE_UNUSED", ")", "{", "switch", "(", "type_of_cost", ")", "{", "case", "scalar_stmt", ":", "case", "scalar_load", ":", "case", "scalar_store", ":", "case", "vector_stmt", ":", "case", "vector_load", ":", "case", "vector_store", ":", "case", "vec_to_scalar", ":", "case", "scalar_to_vec", ":", "case", "cond_branch_not_taken", ":", "case", "vec_perm", ":", "case", "vec_promote_demote", ":", "case", "unaligned_load", ":", "case", "unaligned_store", ":", "return", "1", ";", "case", "cond_branch_taken", ":", "return", "3", ";", "case", "vec_construct", ":", "return", "TYPE_VECTOR_SUBPARTS", "(", "vectype", ")", "-", "1", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "PPCTargetLowering", "::", "isProfitableToHoist", "(", "Instruction", "*", "I", ")", "const", "{", "if", "(", "I", "->", "getOpcode", "(", ")", "!=", "Instruction", "::", "FMul", ")", "return", "true", ";", "if", "(", "!", "I", "->", "hasOneUse", "(", ")", ")", "return", "true", ";", "Instruction", "*", "User", "=", "I", "->", "user_back", "(", ")", ";", "assert", "(", "User", "&&", "\"A single use instruction with no uses.\"", ")", ";", "if", "(", "User", "->", "getOpcode", "(", ")", "!=", "Instruction", "::", "FSub", "&&", "User", "->", "getOpcode", "(", ")", "!=", "Instruction", "::", "FAdd", ")", "return", "true", ";", "const", "TargetOptions", "&", "Options", "=", "getTargetMachine", "(", ")", ".", "Options", ";", "const", "Function", "*", "F", "=", "I", "->", "getFunction", "(", ")", ";", "const", "DataLayout", "&", "DL", "=", "F", "->", "getParent", "(", ")", "->", "getDataLayout", "(", ")", ";", "Type", "*", "Ty", "=", "User", "->", "getOperand", "(", "0", ")", "->", "getType", "(", ")", ";", "return", "!", "(", "isFMAFasterThanFMulAndFAdd", "(", "*", "F", ",", "Ty", ")", "&&", "isOperationLegalOrCustom", "(", "ISD", "::", "FMA", ",", "getValueType", "(", "DL", ",", "Ty", ")", ")", "&&", "(", "Options", ".", "AllowFPOpFusion", "==", "FPOpFusion", "::", "Fast", "||", "Options", ".", "UnsafeFPMath", ")", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "it", "is", "profitable", "to", "hoist", "instruction", "in", "the", "then/else", "to", "before", "if", "." ]

[ "PowerPC", "PPC", "\"A single use instruction with no uses.\"", "0", "ISD::FMA" ]

[]

[ "<s>", "bool", "SNESInstrumentFunctions", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "ShouldInstrument", "(", "F", ")", ")", "{", "BuildEntryBlock", "(", "F", ")", ";", "BuildExitHooks", "(", "F", ")", ";", "}", "return", "true", ";", "}", "</s>" ]

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

[ "SNES", "SNES" ]

[]

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

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

[ "WebAssembly", "\"WebAssembly Optimize Live Intervals\"" ]

[]

[ "<s>", "void", "init_68881_table", "(", "void", ")", "{", "int", "i", ";", "REAL_VALUE_TYPE", "r", ";", "enum", "machine_mode", "mode", ";", "mode", "=", "SFmode", ";", "for", "(", "i", "=", "0", ";", "i", "<", "7", ";", "i", "++", ")", "{", "if", "(", "i", "==", "6", ")", "mode", "=", "DFmode", ";", "r", "=", "REAL_VALUE_ATOF", "(", "strings_68881", "[", "i", "]", ",", "mode", ")", ";", "values_68881", "[", "i", "]", "=", "r", ";", "}", "inited_68881_table", "=", "1", ";", "}", "</s>" ]

[ "Set", "up", "values_68881", "array", "by", "converting", "the", "decimal", "values", "strings_68881", "to", "binary", "." ]

[ "m68k", "0", "7", "6", "1" ]

[]

[ "<s>", "void", "mips_output_ascii", "(", "FILE", "*", "stream", ",", "const", "char", "*", "string_param", ",", "size_t", "len", ",", "const", "char", "*", "prefix", ")", "{", "size_t", "i", ";", "int", "cur_pos", "=", "17", ";", "register", "const", "unsigned", "char", "*", "string", "=", "(", "const", "unsigned", "char", "*", ")", "string_param", ";", "fprintf", "(", "stream", ",", "\"%s\\\"\"", ",", "prefix", ")", ";", "for", "(", "i", "=", "0", ";", "i", "<", "len", ";", "i", "++", ")", "{", "register", "int", "c", "=", "string", "[", "i", "]", ";", "if", "(", "ISPRINT", "(", "c", ")", ")", "{", "if", "(", "c", "==", "'\\\\'", "||", "c", "==", "'\\\"'", ")", "{", "putc", "(", "'\\\\'", ",", "stream", ")", ";", "cur_pos", "++", ";", "}", "putc", "(", "c", ",", "stream", ")", ";", "cur_pos", "++", ";", "}", "else", "{", "fprintf", "(", "stream", ",", "\"\\\\%03o\"", ",", "c", ")", ";", "cur_pos", "+=", "4", ";", "}", "if", "(", "cur_pos", ">", "72", "&&", "i", "+", "1", "<", "len", ")", "{", "cur_pos", "=", "17", ";", "fprintf", "(", "stream", ",", "\"\\\"\\n%s\\\"\"", ",", "prefix", ")", ";", "}", "}", "fprintf", "(", "stream", ",", "\"\\\"\\n\"", ")", ";", "}", "</s>" ]

[ "Output", "an", "ASCII", "string", ",", "in", "a", "space-saving", "way", ".", "PREFIX", "is", "the", "string", "that", "should", "be", "written", "before", "the", "opening", "quote", ",", "such", "as", "``", "\\t.ascii\\t", "''", "for", "real", "string", "data", "or", "``", "\\t", "#", "``", "for", "a", "comment", "." ]

[ "mips", "17", "\"%s\\\"\"", "0", "\"\\\\%03o\"", "4", "72", "1", "17", "\"\\\"\\n%s\\\"\"", "\"\\\"\\n\"" ]

[]

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

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

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

[]

[ "<s>", "bool", "MBlazeAsmParser", "::", "MatchAndEmitInstruction", "(", "SMLoc", "IDLoc", ",", "unsigned", "&", "Opcode", ",", "SmallVectorImpl", "<", "MCParsedAsmOperand", "*", ">", "&", "Operands", ",", "MCStreamer", "&", "Out", ",", "unsigned", "&", "ErrorInfo", ",", "bool", "MatchingInlineAsm", ")", "{", "MCInst", "Inst", ";", "switch", "(", "MatchInstructionImpl", "(", "Operands", ",", "Inst", ",", "ErrorInfo", ",", "MatchingInlineAsm", ")", ")", "{", "default", ":", "break", ";", "case", "Match_Success", ":", "Out", ".", "EmitInstruction", "(", "Inst", ")", ";", "return", "false", ";", "case", "Match_MissingFeature", ":", "return", "Error", "(", "IDLoc", ",", "\"instruction use requires an option to be enabled\"", ")", ";", "case", "Match_MnemonicFail", ":", "return", "Error", "(", "IDLoc", ",", "\"unrecognized instruction mnemonic\"", ")", ";", "case", "Match_InvalidOperand", ":", "{", "SMLoc", "ErrorLoc", "=", "IDLoc", ";", "if", "(", "ErrorInfo", "!=", "~", "0U", ")", "{", "if", "(", "ErrorInfo", ">=", "Operands", ".", "size", "(", ")", ")", "return", "Error", "(", "IDLoc", ",", "\"too few operands for instruction\"", ")", ";", "ErrorLoc", "=", "(", "(", "MBlazeOperand", "*", ")", "Operands", "[", "ErrorInfo", "]", ")", "->", "getStartLoc", "(", ")", ";", "if", "(", "ErrorLoc", "==", "SMLoc", "(", ")", ")", "ErrorLoc", "=", "IDLoc", ";", "}", "return", "Error", "(", "ErrorLoc", ",", "\"invalid operand for instruction\"", ")", ";", "}", "}", "llvm_unreachable", "(", "\"Implement any new match types added!\"", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "VLIWResourceModel", "::", "reserveResources", "(", "SUnit", "*", "SU", ",", "bool", "IsTop", ")", "{", "bool", "startNewCycle", "=", "false", ";", "if", "(", "!", "SU", ")", "{", "ResourcesModel", "->", "clearResources", "(", ")", ";", "Packet", ".", "clear", "(", ")", ";", "TotalPackets", "++", ";", "return", "false", ";", "}", "if", "(", "!", "isResourceAvailable", "(", "SU", ",", "IsTop", ")", "||", "Packet", ".", "size", "(", ")", ">=", "SchedModel", "->", "getIssueWidth", "(", ")", ")", "{", "ResourcesModel", "->", "clearResources", "(", ")", ";", "Packet", ".", "clear", "(", ")", ";", "TotalPackets", "++", ";", "startNewCycle", "=", "true", ";", "}", "switch", "(", "SU", "->", "getInstr", "(", ")", "->", "getOpcode", "(", ")", ")", "{", "default", ":", "ResourcesModel", "->", "reserveResources", "(", "*", "SU", "->", "getInstr", "(", ")", ")", ";", "break", ";", "case", "TargetOpcode", "::", "EXTRACT_SUBREG", ":", "case", "TargetOpcode", "::", "INSERT_SUBREG", ":", "case", "TargetOpcode", "::", "SUBREG_TO_REG", ":", "case", "TargetOpcode", "::", "REG_SEQUENCE", ":", "case", "TargetOpcode", "::", "IMPLICIT_DEF", ":", "case", "TargetOpcode", "::", "KILL", ":", "case", "TargetOpcode", "::", "CFI_INSTRUCTION", ":", "case", "TargetOpcode", "::", "EH_LABEL", ":", "case", "TargetOpcode", "::", "COPY", ":", "case", "TargetOpcode", "::", "INLINEASM", ":", "break", ";", "}", "Packet", ".", "push_back", "(", "SU", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"Packet[\"", "<<", "TotalPackets", "<<", "\"]:\\n\"", ")", ";", "for", "(", "unsigned", "i", "=", "0", ",", "e", "=", "Packet", ".", "size", "(", ")", ";", "i", "!=", "e", ";", "++", "i", ")", "{", "DEBUG", "(", "dbgs", "(", ")", "<<", "\"\\t[\"", "<<", "i", "<<", "\"] SU(\"", ")", ";", "DEBUG", "(", "dbgs", "(", ")", "<<", "Packet", "[", "i", "]", "->", "NodeNum", "<<", "\")\\t\"", ")", ";", "DEBUG", "(", "Packet", "[", "i", "]", "->", "getInstr", "(", ")", "->", "dump", "(", ")", ")", ";", "}", "return", "startNewCycle", ";", "}", "</s>" ]

[ "Keep", "track", "of", "available", "resources", "." ]

[ "Hexagon", "\"Packet[\"", "\"]:\\n\"", "0", "\"\\t[\"", "\"] SU(\"", "\")\\t\"" ]

[]

[ "<s>", "static", "bool", "arc_return_in_memory", "(", "const_tree", "type", ",", "const_tree", "fntype", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "AGGREGATE_TYPE_P", "(", "type", ")", "||", "TREE_ADDRESSABLE", "(", "type", ")", ")", "return", "true", ";", "else", "{", "HOST_WIDE_INT", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "return", "(", "size", "==", "-", "1", "||", "size", ">", "(", "TARGET_V2", "?", "16", ":", "8", ")", ")", ";", "}", "}", "</s>" ]

[ "Worker", "function", "for", "TARGET_RETURN_IN_MEMORY", "." ]

[ "arc", "1", "16", "8" ]

[]

[ "<s>", "static", "void", "ix86_emit_restore_sse_regs_using_mov", "(", "HOST_WIDE_INT", "cfa_offset", ",", "bool", "maybe_eh_return", ")", "{", "unsigned", "int", "regno", ";", "for", "(", "regno", "=", "0", ";", "regno", "<", "FIRST_PSEUDO_REGISTER", ";", "regno", "++", ")", "if", "(", "SSE_REGNO_P", "(", "regno", ")", "&&", "ix86_save_reg", "(", "regno", ",", "maybe_eh_return", ")", ")", "{", "rtx", "reg", "=", "gen_rtx_REG", "(", "V4SFmode", ",", "regno", ")", ";", "rtx", "mem", ";", "unsigned", "int", "align", ";", "mem", "=", "choose_baseaddr", "(", "cfa_offset", ")", ";", "mem", "=", "gen_rtx_MEM", "(", "V4SFmode", ",", "mem", ")", ";", "align", "=", "MIN", "(", "GET_MODE_ALIGNMENT", "(", "V4SFmode", ")", ",", "INCOMING_STACK_BOUNDARY", ")", ";", "set_mem_align", "(", "mem", ",", "align", ")", ";", "if", "(", "align", "<", "128", ")", "{", "rtx", "unspec", "=", "gen_rtx_UNSPEC", "(", "V4SFmode", ",", "gen_rtvec", "(", "1", ",", "mem", ")", ",", "UNSPEC_LOADU", ")", ";", "emit_insn", "(", "gen_rtx_SET", "(", "reg", ",", "unspec", ")", ")", ";", "}", "else", "emit_insn", "(", "gen_rtx_SET", "(", "reg", ",", "mem", ")", ")", ";", "ix86_add_cfa_restore_note", "(", "NULL", ",", "reg", ",", "cfa_offset", ")", ";", "cfa_offset", "-=", "GET_MODE_SIZE", "(", "V4SFmode", ")", ";", "}", "}", "</s>" ]

[ "Emit", "code", "to", "restore", "saved", "registers", "using", "MOV", "insns", ".", "First", "register", "is", "restored", "from", "CFA", "-", "CFA_OFFSET", "." ]

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

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "shouldExtendTypeInLibCall", "(", "EVT", "Type", ")", "const", "{", "RISCVABI", "::", "ABI", "ABI", "=", "Subtarget", ".", "getTargetABI", "(", ")", ";", "if", "(", "(", "ABI", "==", "RISCVABI", "::", "ABI_LP64", "||", "ABI", "==", "RISCVABI", "::", "ABI_L64PC128", ")", "&&", "(", "Type", "==", "MVT", "::", "f32", ")", ")", "return", "false", ";", "return", "true", ";", "}", "</s>" ]

[ "Returns", "true", "if", "arguments", "should", "be", "extended", "in", "lib", "calls", "." ]

[ "RISCV", "RISCV", "RISCVABI::ABI", "RISCVABI::ABI_LP64", "RISCVABI::ABI_L64PC128", "MVT::f32" ]

[]

[ "<s>", "void", "RISCVAsmPrinter", "::", "emitBasicBlockStart", "(", "const", "MachineBasicBlock", "&", "MBB", ")", "{", "AsmPrinter", "::", "emitBasicBlockStart", "(", "MBB", ")", ";", "auto", "*", "RVFI", "=", "MF", "->", "getInfo", "<", "RISCVMachineFunctionInfo", ">", "(", ")", ";", "RISCVTargetStreamer", "&", "RTS", "=", "static_cast", "<", "RISCVTargetStreamer", "&", ">", "(", "*", "OutStreamer", "->", "getTargetStreamer", "(", ")", ")", ";", "if", "(", "RVFI", "->", "isHwlpBasicBlock", "(", "&", "MBB", ")", ")", "{", "RTS", ".", "emitDirectiveOptionPush", "(", ")", ";", "RTS", ".", "emitDirectiveOptionNoRVC", "(", ")", ";", "}", "}", "</s>" ]

[ "Targets", "can", "override", "this", "to", "emit", "stuff", "at", "the", "start", "of", "a", "basic", "block", "." ]

[ "RISCV", "RISCV", "RISCV", "RISCV", "RISCV" ]

[]

[ "<s>", "bool", "X86TargetLowering", "::", "shouldScalarizeBinop", "(", "SDValue", "VecOp", ")", "const", "{", "unsigned", "Opc", "=", "VecOp", ".", "getOpcode", "(", ")", ";", "if", "(", "Opc", ">=", "ISD", "::", "BUILTIN_OP_END", ")", "return", "false", ";", "EVT", "VecVT", "=", "VecOp", ".", "getValueType", "(", ")", ";", "if", "(", "!", "isOperationLegalOrCustomOrPromote", "(", "Opc", ",", "VecVT", ")", ")", "return", "true", ";", "EVT", "ScalarVT", "=", "VecVT", ".", "getScalarType", "(", ")", ";", "return", "isOperationLegalOrCustomOrPromote", "(", "Opc", ",", "ScalarVT", ")", ";", "}", "</s>" ]

[ "Scalar", "ops", "always", "have", "equal", "or", "better", "analysis/performance/power", "than", "the", "vector", "equivalent", ",", "so", "this", "always", "makes", "sense", "if", "the", "scalar", "op", "is", "supported", "." ]

[ "X86", "X86", "ISD::BUILTIN_OP_END" ]

[]

[ "<s>", "static", "bool", "arm_block_set_vect_profit_p", "(", "unsigned", "HOST_WIDE_INT", "length", ",", "unsigned", "HOST_WIDE_INT", "align", ",", "machine_mode", "mode", ")", "{", "int", "num", ";", "bool", "unaligned_p", "=", "(", "(", "align", "&", "3", ")", "!=", "0", ")", ";", "unsigned", "int", "nelt", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "num", "=", "1", ";", "num", "+=", "(", "length", "+", "nelt", "-", "1", ")", "/", "nelt", ";", "if", "(", "!", "unaligned_p", "&&", "(", "length", "&", "3", ")", "!=", "0", ")", "num", "++", ";", "if", "(", "!", "unaligned_p", "&&", "mode", "==", "V16QImode", ")", "num", "--", ";", "return", "(", "num", "<=", "arm_block_set_max_insns", "(", ")", ")", ";", "}", "</s>" ]

[ "Return", "TRUE", "if", "it", "'s", "profitable", "to", "set", "block", "of", "memory", "for", "vectorized", "case", ".", "LENGTH", "is", "the", "number", "of", "bytes", "to", "set", ".", "ALIGN", "is", "the", "alignment", "of", "destination", "memory", "in", "bytes", ".", "MODE", "is", "the", "vector", "mode", "used", "to", "set", "the", "memory", "." ]

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

[]

[ "<s>", "static", "void", "expand_block_set_4", "(", "rtx", "dst", ",", "rtx", "dst_reg", ",", "rtx", "value_rtx", ",", "rtx", "bytes_rtx", ")", "{", "unsigned", "HOST_WIDE_INT", "bytes", "=", "UINTVAL", "(", "bytes_rtx", ")", ";", "unsigned", "int", "rem", "=", "bytes", "%", "4", ";", "value_rtx", "=", "convert_to_mode", "(", "Pmode", ",", "value_rtx", ",", "1", ")", ";", "emit_library_call", "(", "long_int_memset_libfunc", ",", "LCT_NORMAL", ",", "VOIDmode", ",", "dst_reg", ",", "Pmode", ",", "value_rtx", ",", "Pmode", ",", "convert_to_mode", "(", "TYPE_MODE", "(", "sizetype", ")", ",", "GEN_INT", "(", "bytes", ">>", "2", ")", ",", "TYPE_UNSIGNED", "(", "sizetype", ")", ")", ",", "TYPE_MODE", "(", "sizetype", ")", ")", ";", "if", "(", "rem", "==", "0", ")", "return", ";", "dst", "=", "replace_equiv_address_nv", "(", "dst", ",", "dst_reg", ")", ";", "bytes", "-=", "rem", ";", "if", "(", "rem", ">", "1", ")", "{", "if", "(", "CONST_INT_P", "(", "value_rtx", ")", ")", "{", "const", "unsigned", "HOST_WIDE_INT", "value", "=", "UINTVAL", "(", "value_rtx", ")", "&", "0xff", ";", "emit_move_insn", "(", "adjust_address_nv", "(", "dst", ",", "HImode", ",", "bytes", ")", ",", "gen_int_mode", "(", "(", "value", "<<", "8", ")", "|", "value", ",", "HImode", ")", ")", ";", "}", "else", "{", "rtx", "temp", "=", "convert_to_mode", "(", "QImode", ",", "value_rtx", ",", "1", ")", ";", "emit_move_insn", "(", "adjust_address_nv", "(", "dst", ",", "QImode", ",", "bytes", ")", ",", "temp", ")", ";", "emit_move_insn", "(", "adjust_address_nv", "(", "dst", ",", "QImode", ",", "bytes", "+", "1", ")", ",", "temp", ")", ";", "}", "bytes", "+=", "2", ";", "rem", "-=", "2", ";", "}", "if", "(", "rem", ">", "0", ")", "emit_move_insn", "(", "adjust_address_nv", "(", "dst", ",", "QImode", ",", "bytes", ")", ",", "convert_to_mode", "(", "QImode", ",", "value_rtx", ",", "1", ")", ")", ";", "}", "</s>" ]

[ "Generate", "a", "call", "to", "a", "library", "function", "to", "set", "BYTES_RTX", "bytes", "of", "DST", "with", "address", "DST_REG", "to", "VALUE_RTX", "in", "4-byte", "chunks", "." ]

[ "visium", "4", "1", "2", "0", "1", "0xff", "8", "1", "1", "2", "2", "0", "1" ]

[]

[ "<s>", "bool", "DirectXTargetMachine", "::", "addPassesToEmitFile", "(", "PassManagerBase", "&", "PM", ",", "raw_pwrite_stream", "&", "Out", ",", "raw_pwrite_stream", "*", "DwoOut", ",", "CodeGenFileType", "FileType", ",", "bool", "DisableVerify", ",", "MachineModuleInfoWrapperPass", "*", "MMIWP", ")", "{", "switch", "(", "FileType", ")", "{", "case", "CGFT_AssemblyFile", ":", "PM", ".", "add", "(", "createPrintModulePass", "(", "Out", ",", "\"\"", ",", "true", ")", ")", ";", "break", ";", "case", "CGFT_ObjectFile", ":", "PM", ".", "add", "(", "createBitcodeWriterPass", "(", "Out", ",", "true", ",", "false", ",", "false", ")", ")", ";", "break", ";", "case", "CGFT_Null", ":", "break", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Add", "passes", "to", "the", "specified", "pass", "manager", "to", "get", "the", "specified", "file", "emitted", "." ]

[ "DirectX", "\"\"" ]

[]

[ "<s>", "BitVector", "HexagonRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "R29", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "R30", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "R31", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "SA0", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "LC0", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "SA1", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "LC1", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "P3_0", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "USR", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "PC", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "UGP", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "GP", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "CS0", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "CS1", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "UPCYCLELO", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "UPCYCLEHI", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "FRAMELIMIT", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "FRAMEKEY", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "PKTCOUNTLO", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "PKTCOUNTHI", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "UTIMERLO", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "UTIMERHI", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "C8", ")", ";", "Reserved", ".", "set", "(", "Hexagon", "::", "USR_OVF", ")", ";", "for", "(", "int", "x", "=", "Reserved", ".", "find_first", "(", ")", ";", "x", ">=", "0", ";", "x", "=", "Reserved", ".", "find_next", "(", "x", ")", ")", "markSuperRegs", "(", "Reserved", ",", "x", ")", ";", "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", "." ]

[ "Hexagon", "Hexagon", "Hexagon::R29", "Hexagon::R30", "Hexagon::R31", "Hexagon::SA0", "Hexagon::LC0", "Hexagon::SA1", "Hexagon::LC1", "Hexagon::P3_0", "Hexagon::USR", "Hexagon::PC", "Hexagon::UGP", "Hexagon::GP", "Hexagon::CS0", "Hexagon::CS1", "Hexagon::UPCYCLELO", "Hexagon::UPCYCLEHI", "Hexagon::FRAMELIMIT", "Hexagon::FRAMEKEY", "Hexagon::PKTCOUNTLO", "Hexagon::PKTCOUNTHI", "Hexagon::UTIMERLO", "Hexagon::UTIMERHI", "Hexagon::C8", "Hexagon::USR_OVF", "0" ]

[]

[ "<s>", "bool", "supportSplitCSR", "(", "MachineFunction", "*", "MF", ")", "const", "override", "{", "return", "MF", "->", "getFunction", "(", ")", ".", "getCallingConv", "(", ")", "==", "CallingConv", "::", "CXX_FAST_TLS", "&&", "MF", "->", "getFunction", "(", ")", ".", "hasFnAttribute", "(", "Attribute", "::", "NoUnwind", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "that", "a", "subset", "of", "CSRs", "for", "the", "given", "machine", "function", "is", "handled", "explicitly", "via", "copies", "." ]

[ "X86" ]

[]

[ "<s>", "void", "P2FrameLowering", "::", "emitEpilogue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "LLVM_DEBUG", "(", "dbgs", "(", ")", "<<", "\"Emit Epilogue: \"", "<<", "MF", ".", "getName", "(", ")", "<<", "\"\\n\"", ")", ";", "MachineBasicBlock", "::", "iterator", "MBBI", "=", "MBB", ".", "getLastNonDebugInstr", "(", ")", ";", "const", "MachineFrameInfo", "&", "MFI", "=", "MF", ".", "getFrameInfo", "(", ")", ";", "P2FunctionInfo", "*", "P2FI", "=", "MF", ".", "getInfo", "<", "P2FunctionInfo", ">", "(", ")", ";", "const", "P2InstrInfo", "*", "TII", "=", "MF", ".", "getSubtarget", "<", "P2Subtarget", ">", "(", ")", ".", "getInstrInfo", "(", ")", ";", "uint64_t", "StackSize", "=", "MFI", ".", "getStackSize", "(", ")", "-", "4", "-", "P2FI", "->", "getIncomingArgSize", "(", ")", ";", "if", "(", "StackSize", "==", "0", ")", "{", "LLVM_DEBUG", "(", "errs", "(", ")", "<<", "\"No need to de-allocate stack space\\n\"", ")", ";", "return", ";", "}", "TII", "->", "adjustStackPtr", "(", "P2", "::", "PTRA", ",", "-", "StackSize", ",", "MBB", ",", "MBBI", ")", ";", "}", "</s>" ]

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

[ "P2", "P2", "\"Emit Epilogue: \"", "\"\\n\"", "P2", "P2", "P2", "P2", "P2", "4", "P2", "0", "\"No need to de-allocate stack space\\n\"", "P2::PTRA" ]

[]

[ "<s>", "EVT", "X86TargetLowering", "::", "getSetCCResultType", "(", "LLVMContext", "&", ",", "EVT", "VT", ")", "const", "{", "if", "(", "!", "VT", ".", "isVector", "(", ")", ")", "return", "MVT", "::", "i8", ";", "return", "VT", ".", "changeVectorElementTypeToInteger", "(", ")", ";", "}", "</s>" ]

[ "Return", "the", "value", "type", "to", "use", "for", "ISD", ":", ":SETCC", "." ]

[ "X86", "X86", "MVT::i8" ]

[]

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

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

[ "riscv" ]

[]

[ "<s>", "static", "void", "mn10300_insert_setlb_lcc", "(", "rtx", "label", ",", "rtx", "branch", ")", "{", "rtx", "lcc", ",", "comparison", ",", "cmp_reg", ";", "if", "(", "LABEL_NUSES", "(", "label", ")", ">", "1", ")", "{", "rtx_insn", "*", "insn", ";", "DUMP", "(", "\"Inserting SETLB insn after:\"", ",", "label", ")", ";", "insn", "=", "emit_insn_after", "(", "gen_setlb", "(", ")", ",", "label", ")", ";", "label", "=", "gen_label_rtx", "(", ")", ";", "emit_label_after", "(", "label", ",", "insn", ")", ";", "DUMP", "(", "\"Created new loop-back label:\"", ",", "label", ")", ";", "}", "else", "{", "DUMP", "(", "\"Inserting SETLB insn before:\"", ",", "label", ")", ";", "emit_insn_before", "(", "gen_setlb", "(", ")", ",", "label", ")", ";", "}", "comparison", "=", "XEXP", "(", "SET_SRC", "(", "PATTERN", "(", "branch", ")", ")", ",", "0", ")", ";", "cmp_reg", "=", "XEXP", "(", "comparison", ",", "0", ")", ";", "gcc_assert", "(", "REG_P", "(", "cmp_reg", ")", ")", ";", "gcc_assert", "(", "REGNO", "(", "cmp_reg", ")", "==", "CC_REG", ")", ";", "if", "(", "GET_MODE", "(", "cmp_reg", ")", "==", "CC_FLOATmode", ")", "lcc", "=", "gen_FLcc", "(", "comparison", ",", "label", ")", ";", "else", "lcc", "=", "gen_Lcc", "(", "comparison", ",", "label", ")", ";", "rtx_insn", "*", "jump", "=", "emit_jump_insn_before", "(", "lcc", ",", "branch", ")", ";", "mark_jump_label", "(", "XVECEXP", "(", "lcc", ",", "0", ",", "0", ")", ",", "jump", ",", "0", ")", ";", "JUMP_LABEL", "(", "jump", ")", "=", "label", ";", "DUMP", "(", "\"Replacing branch insn...\"", ",", "branch", ")", ";", "DUMP", "(", "\"... with Lcc insn:\"", ",", "jump", ")", ";", "delete_insn", "(", "branch", ")", ";", "}", "</s>" ]

[ "Replace", "the", "BRANCH", "insn", "with", "a", "Lcc", "insn", "that", "goes", "to", "LABEL", ".", "Insert", "a", "SETLB", "insn", "just", "before", "LABEL", "." ]

[ "mn10300", "1", "\"Inserting SETLB insn after:\"", "\"Created new loop-back label:\"", "\"Inserting SETLB insn before:\"", "0", "0", "0", "0", "0", "\"Replacing branch insn...\"", "\"... with Lcc insn:\"" ]

[]

[ "<s>", "bool", "GCNTTIImpl", "::", "isSourceOfDivergence", "(", "const", "Value", "*", "V", ")", "const", "{", "if", "(", "const", "Argument", "*", "A", "=", "dyn_cast", "<", "Argument", ">", "(", "V", ")", ")", "return", "!", "AMDGPU", "::", "isArgPassedInSGPR", "(", "A", ")", ";", "if", "(", "const", "LoadInst", "*", "Load", "=", "dyn_cast", "<", "LoadInst", ">", "(", "V", ")", ")", "return", "Load", "->", "getPointerAddressSpace", "(", ")", "==", "AMDGPUAS", "::", "PRIVATE_ADDRESS", "||", "Load", "->", "getPointerAddressSpace", "(", ")", "==", "AMDGPUAS", "::", "FLAT_ADDRESS", ";", "if", "(", "isa", "<", "AtomicRMWInst", ">", "(", "V", ")", "||", "isa", "<", "AtomicCmpXchgInst", ">", "(", "V", ")", ")", "return", "true", ";", "if", "(", "const", "IntrinsicInst", "*", "Intrinsic", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "V", ")", ")", "return", "AMDGPU", "::", "isIntrinsicSourceOfDivergence", "(", "Intrinsic", "->", "getIntrinsicID", "(", ")", ")", ";", "if", "(", "const", "CallInst", "*", "CI", "=", "dyn_cast", "<", "CallInst", ">", "(", "V", ")", ")", "{", "if", "(", "CI", "->", "isInlineAsm", "(", ")", ")", "return", "isInlineAsmSourceOfDivergence", "(", "CI", ")", ";", "return", "true", ";", "}", "if", "(", "isa", "<", "InvokeInst", ">", "(", "V", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Returns", "whether", "V", "is", "a", "source", "of", "divergence", "." ]

[ "AMDGPU", "AMDGPU::isArgPassedInSGPR", "AMDGPU", "AMDGPU", "AMDGPU::isIntrinsicSourceOfDivergence" ]

[]

[ "<s>", "bool", "MVEGatherScatterLowering", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "!", "EnableMaskedGatherScatters", ")", "return", "false", ";", "auto", "&", "TPC", "=", "getAnalysis", "<", "TargetPassConfig", ">", "(", ")", ";", "auto", "&", "TM", "=", "TPC", ".", "getTM", "<", "TargetMachine", ">", "(", ")", ";", "auto", "*", "ST", "=", "&", "TM", ".", "getSubtarget", "<", "ARMSubtarget", ">", "(", "F", ")", ";", "if", "(", "!", "ST", "->", "hasMVEIntegerOps", "(", ")", ")", "return", "false", ";", "LI", "=", "&", "getAnalysis", "<", "LoopInfoWrapperPass", ">", "(", ")", ".", "getLoopInfo", "(", ")", ";", "SmallVector", "<", "IntrinsicInst", "*", ",", "4", ">", "Gathers", ";", "SmallVector", "<", "IntrinsicInst", "*", ",", "4", ">", "Scatters", ";", "bool", "Changed", "=", "false", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "Changed", "|=", "SimplifyInstructionsInBlock", "(", "&", "BB", ")", ";", "for", "(", "Instruction", "&", "I", ":", "BB", ")", "{", "IntrinsicInst", "*", "II", "=", "dyn_cast", "<", "IntrinsicInst", ">", "(", "&", "I", ")", ";", "if", "(", "II", "&&", "II", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "masked_gather", "&&", "isa", "<", "FixedVectorType", ">", "(", "II", "->", "getType", "(", ")", ")", ")", "{", "Gathers", ".", "push_back", "(", "II", ")", ";", "Changed", "|=", "optimiseAddress", "(", "II", "->", "getArgOperand", "(", "0", ")", ",", "II", "->", "getParent", "(", ")", ",", "LI", ")", ";", "}", "else", "if", "(", "II", "&&", "II", "->", "getIntrinsicID", "(", ")", "==", "Intrinsic", "::", "masked_scatter", "&&", "isa", "<", "FixedVectorType", ">", "(", "II", "->", "getArgOperand", "(", "0", ")", "->", "getType", "(", ")", ")", ")", "{", "Scatters", ".", "push_back", "(", "II", ")", ";", "Changed", "|=", "optimiseAddress", "(", "II", "->", "getArgOperand", "(", "1", ")", ",", "II", "->", "getParent", "(", ")", ",", "LI", ")", ";", "}", "}", "}", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Gathers", ".", "size", "(", ")", ";", "i", "++", ")", "{", "IntrinsicInst", "*", "I", "=", "Gathers", "[", "i", "]", ";", "Instruction", "*", "L", "=", "lowerGather", "(", "I", ")", ";", "if", "(", "L", "==", "nullptr", ")", "continue", ";", "SimplifyInstructionsInBlock", "(", "L", "->", "getParent", "(", ")", ")", ";", "Changed", "=", "true", ";", "}", "for", "(", "unsigned", "i", "=", "0", ";", "i", "<", "Scatters", ".", "size", "(", ")", ";", "i", "++", ")", "{", "IntrinsicInst", "*", "I", "=", "Scatters", "[", "i", "]", ";", "Instruction", "*", "S", "=", "lowerScatter", "(", "I", ")", ";", "if", "(", "S", "==", "nullptr", ")", "continue", ";", "SimplifyInstructionsInBlock", "(", "S", "->", "getParent", "(", ")", ")", ";", "Changed", "=", "true", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "ARM", "ARM", "4", "4", "Intrinsic::masked_gather", "0", "Intrinsic::masked_scatter", "0", "1", "0", "0" ]

[]

[ "<s>", "SparcTargetMachine", "::", "SparcTargetMachine", "(", "const", "Target", "&", "T", ",", "const", "Triple", "&", "TT", ",", "StringRef", "CPU", ",", "StringRef", "FS", ",", "const", "TargetOptions", "&", "Options", ",", "Optional", "<", "Reloc", "::", "Model", ">", "RM", ",", "Optional", "<", "CodeModel", "::", "Model", ">", "CM", ",", "CodeGenOpt", "::", "Level", "OL", ",", "bool", "JIT", ",", "bool", "is64bit", ")", ":", "LLVMTargetMachine", "(", "T", ",", "computeDataLayout", "(", "TT", ",", "is64bit", ")", ",", "TT", ",", "CPU", ",", "FS", ",", "Options", ",", "getEffectiveRelocModel", "(", "RM", ")", ",", "getEffectiveSparcCodeModel", "(", "CM", ",", "getEffectiveRelocModel", "(", "RM", ")", ",", "is64bit", ",", "JIT", ")", ",", "OL", ")", ",", "TLOF", "(", "std", "::", "make_unique", "<", "SparcELFTargetObjectFile", ">", "(", ")", ")", ",", "Subtarget", "(", "TT", ",", "CPU", ",", "FS", ",", "*", "this", ",", "is64bit", ")", ",", "is64Bit", "(", "is64bit", ")", "{", "initAsmInfo", "(", ")", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "static", "void", "arc_init_reg_tables", "(", ")", "{", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "NUM_MACHINE_MODES", ";", "i", "++", ")", "{", "switch", "(", "GET_MODE_CLASS", "(", "i", ")", ")", "{", "case", "MODE_INT", ":", "case", "MODE_PARTIAL_INT", ":", "case", "MODE_COMPLEX_INT", ":", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "<=", "4", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "S_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "D_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "==", "16", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "T_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "==", "32", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "O_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "case", "MODE_FLOAT", ":", "case", "MODE_COMPLEX_FLOAT", ":", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "<=", "4", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "SF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "==", "8", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "DF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "==", "16", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "TF_MODE", ";", "else", "if", "(", "GET_MODE_SIZE", "(", "i", ")", "==", "32", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "OF_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "case", "MODE_CC", ":", "default", ":", "if", "(", "i", "==", "(", "int", ")", "CCmode", "||", "i", "==", "(", "int", ")", "CCZNmode", "||", "i", "==", "(", "int", ")", "CCZNCmode", ")", "arc_mode_class", "[", "i", "]", "=", "1", "<<", "(", "int", ")", "C_MODE", ";", "else", "arc_mode_class", "[", "i", "]", "=", "0", ";", "break", ";", "}", "}", "for", "(", "i", "=", "0", ";", "i", "<", "FIRST_PSEUDO_REGISTER", ";", "i", "++", ")", "{", "if", "(", "i", "<", "60", ")", "arc_regno_reg_class", "[", "i", "]", "=", "GENERAL_REGS", ";", "else", "if", "(", "i", "==", "60", ")", "arc_regno_reg_class", "[", "i", "]", "=", "LPCOUNT_REG", ";", "else", "if", "(", "i", "==", "61", ")", "arc_regno_reg_class", "[", "i", "]", "=", "NO_REGS", ";", "else", "arc_regno_reg_class", "[", "i", "]", "=", "NO_REGS", ";", "}", "}", "</s>" ]

[ "Initialize", "the", "arc_mode_class", "array", "." ]

[ "arc", "0", "4", "1", "8", "1", "16", "1", "32", "1", "0", "4", "1", "8", "1", "16", "1", "32", "1", "0", "1", "0", "0", "60", "60", "61" ]

[]

[ "<s>", "bool", "ARMPassConfig", "::", "addInstSelector", "(", ")", "{", "addPass", "(", "createARMISelDag", "(", "getARMTargetMachine", "(", ")", ",", "getOptLevel", "(", ")", ")", ")", ";", "if", "(", "Triple", "(", "TM", "->", "getTargetTriple", "(", ")", ")", ".", "isOSBinFormatELF", "(", ")", "&&", "TM", "->", "Options", ".", "EnableFastISel", ")", "addPass", "(", "createARMGlobalBaseRegPass", "(", ")", ")", ";", "return", "false", ";", "}", "</s>" ]

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

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

[]

[ "<s>", "bool", "MMIXAsmBackend", "::", "writeNopData", "(", "raw_ostream", "&", "OS", ",", "uint64_t", "Count", ")", "const", "{", "if", "(", "(", "Count", "%", "4", ")", "!=", "0", ")", "return", "false", ";", "for", "(", "uint64_t", "i", "=", "0", ";", "i", "<", "Count", ";", "i", "+=", "4", ")", "OS", ".", "write", "(", "\"\\xfd\\0\\0\\0\"", ",", "4", ")", ";", "return", "true", ";", "}", "</s>" ]

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

[ "MMIX", "MMIX", "4", "0", "0", "4", "\"\\xfd\\0\\0\\0\"", "4" ]

[]

[ "<s>", "enum", "reg_class", "mt_secondary_reload_class", "(", "enum", "reg_class", "class", "ATTRIBUTE_UNUSED", ",", "enum", "machine_mode", "mode", ",", "rtx", "x", ")", "{", "if", "(", "(", "mode", "==", "QImode", "&&", "(", "!", "TARGET_BYTE_ACCESS", ")", ")", "||", "mode", "==", "HImode", ")", "{", "if", "(", "GET_CODE", "(", "x", ")", "==", "MEM", "||", "(", "GET_CODE", "(", "x", ")", "==", "REG", "&&", "true_regnum", "(", "x", ")", "==", "-", "1", ")", "||", "(", "GET_CODE", "(", "x", ")", "==", "SUBREG", "&&", "(", "GET_CODE", "(", "SUBREG_REG", "(", "x", ")", ")", "==", "MEM", "||", "(", "GET_CODE", "(", "SUBREG_REG", "(", "x", ")", ")", "==", "REG", "&&", "true_regnum", "(", "SUBREG_REG", "(", "x", ")", ")", "==", "-", "1", ")", ")", ")", ")", "return", "GENERAL_REGS", ";", "}", "return", "NO_REGS", ";", "}", "</s>" ]

[ "Implement", "SECONDARY_RELOAD_CLASS", "." ]

[ "mt", "1", "1" ]

[]

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

[ "Returns", "true", "if", "the", "target", "wants", "the", "LocalStackAllocation", "pass", "to", "be", "run", "and", "virtual", "base", "registers", "used", "for", "more", "efficient", "stack", "access", "." ]

[ "AMDGPU", "SI" ]

[]

[ "<s>", "bool", "SIInstrInfo", "::", "usesConstantBus", "(", "const", "MachineRegisterInfo", "&", "MRI", ",", "const", "MachineOperand", "&", "MO", ",", "const", "MCOperandInfo", "&", "OpInfo", ")", "const", "{", "if", "(", "MO", ".", "isImm", "(", ")", ")", "return", "!", "isInlineConstant", "(", "MO", ",", "OpInfo", ")", ";", "if", "(", "!", "MO", ".", "isReg", "(", ")", ")", "return", "true", ";", "if", "(", "!", "MO", ".", "isUse", "(", ")", ")", "return", "false", ";", "if", "(", "Register", "::", "isVirtualRegister", "(", "MO", ".", "getReg", "(", ")", ")", ")", "return", "RI", ".", "isSGPRClass", "(", "MRI", ".", "getRegClass", "(", "MO", ".", "getReg", "(", ")", ")", ")", ";", "if", "(", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "SGPR_NULL", ")", "return", "false", ";", "if", "(", "MO", ".", "isImplicit", "(", ")", ")", "{", "return", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "M0", "||", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "VCC", "||", "MO", ".", "getReg", "(", ")", "==", "AMDGPU", "::", "VCC_LO", ";", "}", "else", "{", "return", "AMDGPU", "::", "SReg_32RegClass", ".", "contains", "(", "MO", ".", "getReg", "(", ")", ")", "||", "AMDGPU", "::", "SReg_64RegClass", ".", "contains", "(", "MO", ".", "getReg", "(", ")", ")", ";", "}", "}", "</s>" ]

[ "Returns", "true", "if", "this", "operand", "uses", "the", "constant", "bus", "." ]

[ "AMDGPU", "SI", "AMDGPU::SGPR_NULL", "AMDGPU::M0", "AMDGPU::VCC", "AMDGPU::VCC_LO", "AMDGPU::SReg_32RegClass", "AMDGPU::SReg_64RegClass" ]

[]

[ "<s>", "bool", "runOnMachineFunction", "(", "MachineFunction", "&", "F", ")", "{", "bool", "Changed", "=", "false", ";", "if", "(", "EnableDelJmp", ")", "{", "MachineFunction", "::", "iterator", "FJ", "=", "F", ".", "begin", "(", ")", ";", "if", "(", "FJ", "!=", "F", ".", "end", "(", ")", ")", "FJ", "++", ";", "if", "(", "FJ", "==", "F", ".", "end", "(", ")", ")", "return", "Changed", ";", "for", "(", "MachineFunction", "::", "iterator", "FI", "=", "F", ".", "begin", "(", ")", ",", "FE", "=", "F", ".", "end", "(", ")", ";", "FJ", "!=", "FE", ";", "++", "FI", ",", "++", "FJ", ")", "Changed", "|=", "runOnMachineBasicBlock", "(", "*", "FI", ",", "*", "FJ", ")", ";", "}", "return", "Changed", ";", "}", "</s>" ]

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

[ "P2" ]

[]

[ "<s>", "ArrayRef", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">>", "ARMBaseInstrInfo", "::", "getSerializableBitmaskMachineOperandTargetFlags", "(", ")", "const", "{", "using", "namespace", "ARMII", ";", "static", "const", "std", "::", "pair", "<", "unsigned", ",", "const", "char", "*", ">", "TargetFlags", "[", "]", "=", "{", "{", "MO_COFFSTUB", ",", "\"arm-coffstub\"", "}", ",", "{", "MO_GOT", ",", "\"arm-got\"", "}", ",", "{", "MO_SBREL", ",", "\"arm-sbrel\"", "}", ",", "{", "MO_DLLIMPORT", ",", "\"arm-dllimport\"", "}", ",", "{", "MO_SECREL", ",", "\"arm-secrel\"", "}", ",", "{", "MO_NONLAZY", ",", "\"arm-nonlazy\"", "}", "}", ";", "return", "makeArrayRef", "(", "TargetFlags", ")", ";", "}", "</s>" ]

[ "Return", "an", "array", "that", "contains", "the", "bitmask", "target", "flag", "values", "and", "their", "names", "." ]

[ "ARM", "ARM", "ARM", "\"arm-coffstub\"", "\"arm-got\"", "\"arm-sbrel\"", "\"arm-dllimport\"", "\"arm-secrel\"", "\"arm-nonlazy\"" ]

[]

[ "<s>", "static", "bool", "ia64_function_ok_for_sibcall", "(", "tree", "decl", ",", "tree", "exp", "ATTRIBUTE_UNUSED", ")", "{", "if", "(", "lookup_attribute", "(", "\"syscall_linkage\"", ",", "TYPE_ATTRIBUTES", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", ")", "return", "false", ";", "return", "decl", "&&", "(", "*", "targetm", ".", "binds_local_p", ")", "(", "decl", ")", ";", "}", "</s>" ]

[ "True", "if", "it", "is", "OK", "to", "do", "sibling", "call", "optimization", "for", "the", "specified", "call", "expression", "EXP", ".", "DECL", "will", "be", "the", "called", "function", ",", "or", "NULL", "if", "this", "is", "an", "indirect", "call", "." ]

[ "ia64", "\"syscall_linkage\"" ]

[]

[ "<s>", "ArrayRef", "<", "MachineBasicBlock", "*", ">", "getBlocks", "(", ")", "const", "{", "return", "Blocks", ";", "}", "</s>" ]

[ "Get", "a", "list", "of", "the", "basic", "blocks", "which", "make", "up", "this", "loop", "." ]

[ "WebAssembly" ]

[]

[ "<s>", "static", "void", "s390_encode_section_info", "(", "tree", "decl", ",", "rtx", "rtl", ",", "int", "first", ")", "{", "default_encode_section_info", "(", "decl", ",", "rtl", ",", "first", ")", ";", "if", "(", "TREE_CODE", "(", "decl", ")", "==", "VAR_DECL", ")", "{", "if", "(", "DECL_ALIGN", "(", "decl", ")", "==", "0", "||", "DECL_ALIGN", "(", "decl", ")", "%", "16", ")", "SYMBOL_FLAG_SET_NOTALIGN2", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", ";", "else", "if", "(", "DECL_ALIGN", "(", "decl", ")", "%", "32", ")", "SYMBOL_FLAG_SET_NOTALIGN4", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", ";", "else", "if", "(", "DECL_ALIGN", "(", "decl", ")", "%", "64", ")", "SYMBOL_FLAG_SET_NOTALIGN8", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", ";", "}", "if", "(", "MEM_P", "(", "rtl", ")", "&&", "GET_CODE", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", "==", "SYMBOL_REF", "&&", "TREE_CONSTANT_POOL_ADDRESS_P", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", ")", "{", "if", "(", "MEM_ALIGN", "(", "rtl", ")", "==", "0", "||", "MEM_ALIGN", "(", "rtl", ")", "%", "16", ")", "SYMBOL_FLAG_SET_NOTALIGN2", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", ";", "else", "if", "(", "MEM_ALIGN", "(", "rtl", ")", "%", "32", ")", "SYMBOL_FLAG_SET_NOTALIGN4", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", ";", "else", "if", "(", "MEM_ALIGN", "(", "rtl", ")", "%", "64", ")", "SYMBOL_FLAG_SET_NOTALIGN8", "(", "XEXP", "(", "rtl", ",", "0", ")", ")", ";", "}", "}", "</s>" ]

[ "Encode", "symbol", "attributes", "(", "local", "vs.", "global", ",", "tls", "model", ")", "of", "a", "SYMBOL_REF", "into", "its", "SYMBOL_REF_FLAGS", "." ]

[ "s390", "0", "16", "0", "32", "0", "64", "0", "0", "0", "0", "16", "0", "32", "0", "64", "0" ]

[]

[ "<s>", "bool", "ARMIndirectThunks", "::", "doInitialization", "(", "Module", "&", "M", ")", "{", "initTIs", "(", "M", ",", "TIs", ")", ";", "return", "false", ";", "}", "</s>" ]

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

[ "ARM", "ARM" ]

[]

[ "<s>", "MCSymbol", "*", "WebAssemblyMCInstLower", "::", "GetExternalSymbolSymbol", "(", "const", "MachineOperand", "&", "MO", ")", "const", "{", "const", "char", "*", "Name", "=", "MO", ".", "getSymbolName", "(", ")", ";", "MCSymbolWasm", "*", "WasmSym", "=", "cast", "<", "MCSymbolWasm", ">", "(", "Printer", ".", "GetExternalSymbolSymbol", "(", "Name", ")", ")", ";", "const", "WebAssemblySubtarget", "&", "Subtarget", "=", "Printer", ".", "getSubtarget", "(", ")", ";", "if", "(", "strcmp", "(", "Name", ",", "\"__stack_pointer\"", ")", "==", "0", ")", "{", "WasmSym", "->", "setType", "(", "wasm", "::", "WASM_SYMBOL_TYPE_GLOBAL", ")", ";", "WasmSym", "->", "setGlobalType", "(", "wasm", "::", "WasmGlobalType", "{", "uint8_t", "(", "Subtarget", ".", "hasAddr64", "(", ")", "?", "wasm", "::", "WASM_TYPE_I64", ":", "wasm", "::", "WASM_TYPE_I32", ")", ",", "true", "}", ")", ";", "return", "WasmSym", ";", "}", "SmallVector", "<", "wasm", "::", "ValType", ",", "4", ">", "Returns", ";", "SmallVector", "<", "wasm", "::", "ValType", ",", "4", ">", "Params", ";", "GetLibcallSignature", "(", "Subtarget", ",", "Name", ",", "Returns", ",", "Params", ")", ";", "auto", "Signature", "=", "make_unique", "<", "wasm", "::", "WasmSignature", ">", "(", "std", "::", "move", "(", "Returns", ")", ",", "std", "::", "move", "(", "Params", ")", ")", ";", "WasmSym", "->", "setSignature", "(", "Signature", ".", "get", "(", ")", ")", ";", "Printer", ".", "addSignature", "(", "std", "::", "move", "(", "Signature", ")", ")", ";", "WasmSym", "->", "setType", "(", "wasm", "::", "WASM_SYMBOL_TYPE_FUNCTION", ")", ";", "return", "WasmSym", ";", "}", "</s>" ]

[ "Return", "the", "MCSymbol", "for", "the", "specified", "ExternalSymbol", "." ]

[ "WebAssembly", "WebAssembly", "WebAssembly", "\"__stack_pointer\"", "0", "wasm::WASM_SYMBOL_TYPE_GLOBAL", "wasm::WasmGlobalType", "wasm::WASM_TYPE_I64", "wasm::WASM_TYPE_I32", "wasm::ValType", "4", "wasm::ValType", "4", "wasm::WasmSignature", "wasm::WASM_SYMBOL_TYPE_FUNCTION" ]

[]

[ "<s>", "bool", "isLegalMaskedGather", "(", "Type", "*", "DataType", ")", "{", "return", "ST", "->", "hasSVE", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "supports", "masked", "gather", "." ]

[ "AArch64" ]

[]

[ "<s>", "static", "bool", "rs6000_function_parms_need_stack", "(", "tree", "fun", ",", "bool", "incoming", ")", "{", "tree", "fntype", ",", "result", ";", "CUMULATIVE_ARGS", "args_so_far_v", ";", "cumulative_args_t", "args_so_far", ";", "if", "(", "!", "fun", ")", "return", "false", ";", "fntype", "=", "fun", ";", "if", "(", "!", "TYPE_P", "(", "fun", ")", ")", "fntype", "=", "TREE_TYPE", "(", "fun", ")", ";", "if", "(", "(", "!", "incoming", "&&", "!", "prototype_p", "(", "fntype", ")", ")", "||", "stdarg_p", "(", "fntype", ")", ")", "return", "true", ";", "INIT_CUMULATIVE_INCOMING_ARGS", "(", "args_so_far_v", ",", "fntype", ",", "NULL_RTX", ")", ";", "args_so_far", "=", "pack_cumulative_args", "(", "&", "args_so_far_v", ")", ";", "if", "(", "incoming", ")", "{", "gcc_assert", "(", "DECL_P", "(", "fun", ")", ")", ";", "result", "=", "DECL_RESULT", "(", "fun", ")", ";", "}", "else", "result", "=", "TREE_TYPE", "(", "fntype", ")", ";", "if", "(", "result", "&&", "aggregate_value_p", "(", "result", ",", "fntype", ")", ")", "{", "if", "(", "!", "TYPE_P", "(", "result", ")", ")", "result", "=", "TREE_TYPE", "(", "result", ")", ";", "result", "=", "build_pointer_type", "(", "result", ")", ";", "rs6000_parm_needs_stack", "(", "args_so_far", ",", "result", ")", ";", "}", "if", "(", "incoming", ")", "{", "tree", "parm", ";", "for", "(", "parm", "=", "DECL_ARGUMENTS", "(", "fun", ")", ";", "parm", "&&", "parm", "!=", "void_list_node", ";", "parm", "=", "TREE_CHAIN", "(", "parm", ")", ")", "if", "(", "rs6000_parm_needs_stack", "(", "args_so_far", ",", "TREE_TYPE", "(", "parm", ")", ")", ")", "return", "true", ";", "}", "else", "{", "function_args_iterator", "args_iter", ";", "tree", "arg_type", ";", "FOREACH_FUNCTION_ARGS", "(", "fntype", ",", "arg_type", ",", "args_iter", ")", "if", "(", "rs6000_parm_needs_stack", "(", "args_so_far", ",", "arg_type", ")", ")", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "FUN", "has", "no", "prototype", ",", "has", "a", "variable", "argument", "list", ",", "or", "passes", "any", "parameter", "in", "memory", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "void", "mips_init_builtins", "(", "void", ")", "{", "const", "struct", "mips_builtin_description", "*", "d", ";", "unsigned", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "ARRAY_SIZE", "(", "mips_builtins", ")", ";", "i", "++", ")", "{", "d", "=", "&", "mips_builtins", "[", "i", "]", ";", "if", "(", "d", "->", "avail", "(", ")", ")", "{", "mips_builtin_decls", "[", "i", "]", "=", "add_builtin_function", "(", "d", "->", "name", ",", "mips_build_function_type", "(", "d", "->", "function_type", ")", ",", "i", ",", "BUILT_IN_MD", ",", "NULL", ",", "NULL", ")", ";", "if", "(", "mips_builtin_decls", "[", "i", "]", "&&", "d", "->", "is_pure", ")", "DECL_PURE_P", "(", "mips_builtin_decls", "[", "i", "]", ")", "=", "1", ";", "mips_get_builtin_decl_index", "[", "d", "->", "icode", "]", "=", "i", ";", "}", "}", "}", "</s>" ]

[ "Init", "builtin", "functions", ".", "This", "is", "called", "from", "TARGET_INIT_BUILTIN", "." ]

[ "mips", "0", "1" ]

[]

[ "<s>", "const", "char", "*", "getPassName", "(", ")", "const", "override", "{", "return", "\"SystemZ Local Dynamic TLS Access Clean-up\"", ";", "}", "</s>" ]

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

[ "SystemZ", "\"SystemZ Local Dynamic TLS Access Clean-up\"" ]

[]

[ "<s>", "bool", "RISCVAsmBackend", "::", "shouldInsertFixupForCodeAlign", "(", "MCAssembler", "&", "Asm", ",", "const", "MCAsmLayout", "&", "Layout", ",", "MCAlignFragment", "&", "AF", ")", "{", "if", "(", "!", "STI", ".", "getFeatureBits", "(", ")", "[", "RISCV", "::", "FeatureRelax", "]", ")", "return", "false", ";", "unsigned", "Count", ";", "if", "(", "!", "shouldInsertExtraNopBytesForCodeAlign", "(", "AF", ",", "Count", ")", "||", "(", "Count", "==", "0", ")", ")", "return", "false", ";", "MCContext", "&", "Ctx", "=", "Asm", ".", "getContext", "(", ")", ";", "const", "MCExpr", "*", "Dummy", "=", "MCConstantExpr", "::", "create", "(", "0", ",", "Ctx", ")", ";", "MCFixup", "Fixup", "=", "MCFixup", "::", "create", "(", "0", ",", "Dummy", ",", "MCFixupKind", "(", "RISCV", "::", "fixup_riscv_align", ")", ",", "SMLoc", "(", ")", ")", ";", "uint64_t", "FixedValue", "=", "0", ";", "MCValue", "NopBytes", "=", "MCValue", "::", "get", "(", "Count", ")", ";", "Asm", ".", "getWriter", "(", ")", ".", "recordRelocation", "(", "Asm", ",", "Layout", ",", "&", "AF", ",", "Fixup", ",", "NopBytes", ",", "FixedValue", ")", ";", "return", "true", ";", "}", "</s>" ]

[ "Hook", "which", "indicates", "if", "the", "target", "requires", "a", "fixup", "to", "be", "generated", "when", "handling", "an", "align", "directive", "in", "an", "executable", "section", "." ]

[ "RISCV", "RISCV", "RISCV::FeatureRelax", "0", "0", "0", "RISCV::fixup_riscv_align", "0" ]

[]

[ "<s>", "static", "rtx", "move_to_hl", "(", "int", "opno", ",", "rtx_insn", "*", "before", ")", "{", "rtx", "src", "=", "OP", "(", "opno", ")", ";", "machine_mode", "mode", "=", "GET_MODE", "(", "src", ")", ";", "rtx", "reg", ";", "if", "(", "mode", "==", "VOIDmode", ")", "mode", "=", "recog_data", ".", "operand_mode", "[", "opno", "]", ";", "reg", "=", "(", "mode", "==", "QImode", ")", "?", "L", ":", "HL", ";", "if", "(", "mode", "==", "QImode", "||", "!", "is_virtual_register", "(", "OP", "(", "opno", ")", ")", ")", "{", "OP", "(", "opno", ")", "=", "move_to_acc", "(", "opno", ",", "before", ")", ";", "OP", "(", "opno", ")", "=", "move_acc_to_reg", "(", "OP", "(", "opno", ")", ",", "L_REG", ",", "before", ")", ";", "return", "reg", ";", "}", "return", "gen_and_emit_move", "(", "reg", ",", "src", ",", "before", ",", "true", ")", ";", "}", "</s>" ]

[ "Copy", "OP", "(", "opno", ")", "to", "H", "or", "HL", ",", "placing", "any", "generated", "insns", "before", "BEFORE", ".", "Returns", "H/HL", "RTX", "." ]

[ "rl78" ]

[]

[ "<s>", "bool", "PPCRegisterInfo", "::", "hasReservedSpillSlot", "(", "const", "MachineFunction", "&", "MF", ",", "unsigned", "Reg", ",", "int", "&", "FrameIdx", ")", "const", "{", "if", "(", "Subtarget", ".", "isSVR4ABI", "(", ")", "&&", "PPC", "::", "CR2", "<=", "Reg", "&&", "Reg", "<=", "PPC", "::", "CR4", ")", "{", "if", "(", "Subtarget", ".", "isPPC64", "(", ")", ")", "FrameIdx", "=", "0", ";", "else", "{", "const", "PPCFunctionInfo", "*", "FI", "=", "MF", ".", "getInfo", "<", "PPCFunctionInfo", ">", "(", ")", ";", "FrameIdx", "=", "FI", "->", "getCRSpillFrameIndex", "(", ")", ";", "}", "return", "true", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "target", "has", "reserved", "a", "spill", "slot", "in", "the", "stack", "frame", "of", "the", "given", "function", "for", "the", "specified", "register", "." ]

[ "PowerPC", "PPC", "PPC::CR2", "PPC::CR4", "PPC", "0", "PPC", "PPC" ]

[]

[ "<s>", "bool", "WinEHStatePass", "::", "runOnFunction", "(", "Function", "&", "F", ")", "{", "if", "(", "F", ".", "hasAvailableExternallyLinkage", "(", ")", ")", "return", "false", ";", "if", "(", "!", "F", ".", "hasPersonalityFn", "(", ")", ")", "return", "false", ";", "PersonalityFn", "=", "dyn_cast", "<", "Function", ">", "(", "F", ".", "getPersonalityFn", "(", ")", "->", "stripPointerCastsSafe", "(", ")", ")", ";", "if", "(", "!", "PersonalityFn", ")", "return", "false", ";", "Personality", "=", "classifyEHPersonality", "(", "PersonalityFn", ")", ";", "if", "(", "!", "isFuncletEHPersonality", "(", "Personality", ")", ")", "return", "false", ";", "bool", "HasPads", "=", "false", ";", "for", "(", "BasicBlock", "&", "BB", ":", "F", ")", "{", "if", "(", "BB", ".", "isEHPad", "(", ")", ")", "{", "HasPads", "=", "true", ";", "break", ";", "}", "}", "if", "(", "!", "HasPads", ")", "return", "false", ";", "Type", "*", "Int8PtrType", "=", "Type", "::", "getInt8PtrTy", "(", "TheModule", "->", "getContext", "(", ")", ")", ";", "SetJmp3", "=", "TheModule", "->", "getOrInsertFunction", "(", "\"_setjmp3\"", ",", "FunctionType", "::", "get", "(", "Type", "::", "getInt32Ty", "(", "TheModule", "->", "getContext", "(", ")", ")", ",", "{", "Int8PtrType", ",", "Type", "::", "getInt32Ty", "(", "TheModule", "->", "getContext", "(", ")", ")", "}", ",", "true", ")", ")", ";", "F", ".", "addFnAttr", "(", "\"no-frame-pointer-elim\"", ",", "\"true\"", ")", ";", "emitExceptionRegistrationRecord", "(", "&", "F", ")", ";", "WinEHFuncInfo", "FuncInfo", ";", "addStateStores", "(", "F", ",", "FuncInfo", ")", ";", "PersonalityFn", "=", "nullptr", ";", "Personality", "=", "EHPersonality", "::", "Unknown", ";", "UseStackGuard", "=", "false", ";", "RegNode", "=", "nullptr", ";", "EHGuardNode", "=", "nullptr", ";", "return", "true", ";", "}", "</s>" ]

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

[ "X86", "\"_setjmp3\"", "\"no-frame-pointer-elim\"", "\"true\"" ]

[]

[ "<s>", "bool", "restoreCalleeSavedRegisters", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "MI", ",", "std", "::", "vector", "<", "CalleeSavedInfo", ">", "&", "CSI", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "override", "{", "return", "true", ";", "}", "</s>" ]

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

[ "Hexagon" ]

[]

[ "<s>", "void", "LanaiInstrInfo", "::", "copyPhysReg", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "Position", ",", "DebugLoc", "DL", ",", "unsigned", "DestinationRegister", ",", "unsigned", "SourceRegister", ",", "bool", "KillSource", ")", "const", "{", "if", "(", "!", "Lanai", "::", "GPRRegClass", ".", "contains", "(", "DestinationRegister", ",", "SourceRegister", ")", ")", "{", "llvm_unreachable", "(", "\"Impossible reg-to-reg copy\"", ")", ";", "}", "BuildMI", "(", "MBB", ",", "Position", ",", "DL", ",", "get", "(", "Lanai", "::", "OR_I_LO", ")", ",", "DestinationRegister", ")", ".", "addReg", "(", "SourceRegister", ",", "getKillRegState", "(", "KillSource", ")", ")", ".", "addImm", "(", "0", ")", ";", "}", "</s>" ]

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

[ "Lanai", "Lanai", "Lanai::GPRRegClass", "\"Impossible reg-to-reg copy\"", "Lanai::OR_I_LO", "0" ]

[]

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

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

[ "ARM", "ARM", "ARM::LDRrs", "ARM::t2LDRs", "1", "2", "3", "2", "0", "3", "0", "1", "0", "ARM::LDRi12", "ARM::t2LDRi12", "ARM::tRestore", "ARM::VLDRD", "ARM::VLDRS", "1", "2", "2", "0", "1", "0", "ARM::VLD1q64Pseudo", "1", "0", "0", "1", "0", "ARM::VLDMQIA", "1", "0", "0", "1", "0", "0" ]

[]

[ "<s>", "static", "bool", "mips_interrupt_extra_call_saved_reg_p", "(", "unsigned", "int", "regno", ")", "{", "if", "(", "(", "ISA_HAS_HILO", "||", "TARGET_DSP", ")", "&&", "MD_REG_P", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "TARGET_DSP", "&&", "DSP_ACC_REG_P", "(", "regno", ")", ")", "return", "true", ";", "if", "(", "GP_REG_P", "(", "regno", ")", "&&", "!", "cfun", "->", "machine", "->", "use_shadow_register_set_p", ")", "{", "if", "(", "regno", "==", "GP_REG_FIRST", ")", "return", "false", ";", "if", "(", "KERNEL_REG_P", "(", "regno", ")", ")", "return", "false", ";", "if", "(", "regno", "==", "STACK_POINTER_REGNUM", ")", "return", "false", ";", "return", "call_really_used_regs", "[", "regno", "]", ";", "}", "return", "false", ";", "}", "</s>" ]

[ "Return", "true", "if", "REGNO", "is", "a", "register", "that", "is", "ordinarily", "call-clobbered", "but", "must", "nevertheless", "be", "preserved", "by", "an", "interrupt", "handler", "." ]

[ "mips" ]

[]

[ "<s>", "int", "arm_return_in_memory", "(", "tree", "type", ")", "{", "HOST_WIDE_INT", "size", ";", "if", "(", "!", "AGGREGATE_TYPE_P", "(", "type", ")", "&&", "(", "TREE_CODE", "(", "type", ")", "!=", "VECTOR_TYPE", ")", "&&", "!", "(", "TARGET_AAPCS_BASED", "&&", "TREE_CODE", "(", "type", ")", "==", "COMPLEX_TYPE", ")", ")", "return", "0", ";", "size", "=", "int_size_in_bytes", "(", "type", ")", ";", "if", "(", "arm_abi", "!=", "ARM_ABI_APCS", ")", "{", "return", "(", "size", "<", "0", "||", "size", ">", "UNITS_PER_WORD", ")", ";", "}", "if", "(", "TREE_CODE", "(", "type", ")", "==", "VECTOR_TYPE", ")", "return", "(", "size", "<", "0", "||", "size", ">", "(", "4", "*", "UNITS_PER_WORD", ")", ")", ";", "if", "(", "size", "<", "0", "||", "size", ">", "UNITS_PER_WORD", ")", "return", "1", ";", "if", "(", "TREE_CODE", "(", "type", ")", "==", "RECORD_TYPE", ")", "{", "tree", "field", ";", "for", "(", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "field", "&&", "TREE_CODE", "(", "field", ")", "!=", "FIELD_DECL", ";", "field", "=", "TREE_CHAIN", "(", "field", ")", ")", "continue", ";", "if", "(", "field", "==", "NULL", ")", "return", "0", ";", "if", "(", "FLOAT_TYPE_P", "(", "TREE_TYPE", "(", "field", ")", ")", ")", "return", "1", ";", "if", "(", "RETURN_IN_MEMORY", "(", "TREE_TYPE", "(", "field", ")", ")", ")", "return", "1", ";", "for", "(", "field", "=", "TREE_CHAIN", "(", "field", ")", ";", "field", ";", "field", "=", "TREE_CHAIN", "(", "field", ")", ")", "{", "if", "(", "TREE_CODE", "(", "field", ")", "!=", "FIELD_DECL", ")", "continue", ";", "if", "(", "!", "DECL_BIT_FIELD_TYPE", "(", "field", ")", ")", "return", "1", ";", "}", "return", "0", ";", "}", "if", "(", "TREE_CODE", "(", "type", ")", "==", "UNION_TYPE", ")", "{", "tree", "field", ";", "for", "(", "field", "=", "TYPE_FIELDS", "(", "type", ")", ";", "field", ";", "field", "=", "TREE_CHAIN", "(", "field", ")", ")", "{", "if", "(", "TREE_CODE", "(", "field", ")", "!=", "FIELD_DECL", ")", "continue", ";", "if", "(", "FLOAT_TYPE_P", "(", "TREE_TYPE", "(", "field", ")", ")", ")", "return", "1", ";", "if", "(", "RETURN_IN_MEMORY", "(", "TREE_TYPE", "(", "field", ")", ")", ")", "return", "1", ";", "}", "return", "0", ";", "}", "return", "1", ";", "}", "</s>" ]

[ "Decide", "whether", "a", "type", "should", "be", "returned", "in", "memory", "(", "true", ")", "or", "in", "a", "register", "(", "false", ")", ".", "This", "is", "called", "by", "the", "macro", "RETURN_IN_MEMORY", "." ]

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

[]

[ "<s>", "static", "void", "thumb1_reorg", "(", "void", ")", "{", "basic_block", "bb", ";", "FOR_EACH_BB_FN", "(", "bb", ",", "cfun", ")", "{", "rtx", "dest", ",", "src", ";", "rtx", "pat", ",", "op0", ",", "set", "=", "NULL", ";", "rtx_insn", "*", "prev", ",", "*", "insn", "=", "BB_END", "(", "bb", ")", ";", "bool", "insn_clobbered", "=", "false", ";", "while", "(", "insn", "!=", "BB_HEAD", "(", "bb", ")", "&&", "!", "NONDEBUG_INSN_P", "(", "insn", ")", ")", "insn", "=", "PREV_INSN", "(", "insn", ")", ";", "if", "(", "insn", "==", "BB_HEAD", "(", "bb", ")", "||", "INSN_CODE", "(", "insn", ")", "!=", "CODE_FOR_cbranchsi4_insn", ")", "continue", ";", "pat", "=", "PATTERN", "(", "insn", ")", ";", "op0", "=", "XEXP", "(", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "0", ")", ",", "0", ")", ";", "gcc_assert", "(", "insn", "!=", "BB_HEAD", "(", "bb", ")", ")", ";", "for", "(", "prev", "=", "PREV_INSN", "(", "insn", ")", ";", "(", "!", "insn_clobbered", "&&", "prev", "!=", "BB_HEAD", "(", "bb", ")", "&&", "(", "NOTE_P", "(", "prev", ")", "||", "DEBUG_INSN_P", "(", "prev", ")", "||", "(", "(", "set", "=", "single_set", "(", "prev", ")", ")", "!=", "NULL", "&&", "get_attr_conds", "(", "prev", ")", "==", "CONDS_NOCOND", ")", ")", ")", ";", "prev", "=", "PREV_INSN", "(", "prev", ")", ")", "{", "if", "(", "reg_set_p", "(", "op0", ",", "prev", ")", ")", "insn_clobbered", "=", "true", ";", "}", "if", "(", "insn_clobbered", ")", "continue", ";", "if", "(", "!", "set", ")", "continue", ";", "dest", "=", "SET_DEST", "(", "set", ")", ";", "src", "=", "SET_SRC", "(", "set", ")", ";", "if", "(", "!", "low_register_operand", "(", "dest", ",", "SImode", ")", "||", "!", "low_register_operand", "(", "src", ",", "SImode", ")", ")", "continue", ";", "if", "(", "REGNO", "(", "op0", ")", "==", "REGNO", "(", "src", ")", "||", "REGNO", "(", "op0", ")", "==", "REGNO", "(", "dest", ")", ")", "{", "dest", "=", "copy_rtx", "(", "dest", ")", ";", "src", "=", "copy_rtx", "(", "src", ")", ";", "src", "=", "gen_rtx_MINUS", "(", "SImode", ",", "src", ",", "const0_rtx", ")", ";", "PATTERN", "(", "prev", ")", "=", "gen_rtx_SET", "(", "VOIDmode", ",", "dest", ",", "src", ")", ";", "INSN_CODE", "(", "prev", ")", "=", "-", "1", ";", "XEXP", "(", "XEXP", "(", "SET_SRC", "(", "pat", ")", ",", "0", ")", ",", "0", ")", "=", "copy_rtx", "(", "dest", ")", ";", "INSN_CODE", "(", "insn", ")", "=", "-", "1", ";", "}", "}", "}", "</s>" ]

[ "Rewrite", "move", "insn", "into", "subtract", "of", "0", "if", "the", "condition", "codes", "will", "be", "useful", "in", "next", "conditional", "jump", "insn", "." ]

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

[]

[ "<s>", "static", "void", "riscv_setup_incoming_varargs", "(", "cumulative_args_t", "cum", ",", "const", "function_arg_info", "&", "arg", ",", "int", "*", "pretend_size", "ATTRIBUTE_UNUSED", ",", "int", "no_rtl", ")", "{", "CUMULATIVE_ARGS", "local_cum", ";", "int", "gp_saved", ";", "local_cum", "=", "*", "get_cumulative_args", "(", "cum", ")", ";", "if", "(", "!", "TYPE_NO_NAMED_ARGS_STDARG_P", "(", "TREE_TYPE", "(", "current_function_decl", ")", ")", ")", "riscv_function_arg_advance", "(", "pack_cumulative_args", "(", "&", "local_cum", ")", ",", "arg", ")", ";", "gp_saved", "=", "MAX_ARGS_IN_REGISTERS", "-", "local_cum", ".", "num_gprs", ";", "if", "(", "!", "no_rtl", "&&", "gp_saved", ">", "0", ")", "{", "rtx", "ptr", "=", "plus_constant", "(", "Pmode", ",", "virtual_incoming_args_rtx", ",", "REG_PARM_STACK_SPACE", "(", "cfun", "->", "decl", ")", "-", "gp_saved", "*", "UNITS_PER_WORD", ")", ";", "rtx", "mem", "=", "gen_frame_mem", "(", "BLKmode", ",", "ptr", ")", ";", "set_mem_alias_set", "(", "mem", ",", "get_varargs_alias_set", "(", ")", ")", ";", "move_block_from_reg", "(", "local_cum", ".", "num_gprs", "+", "GP_ARG_FIRST", ",", "mem", ",", "gp_saved", ")", ";", "}", "if", "(", "REG_PARM_STACK_SPACE", "(", "cfun", "->", "decl", ")", "==", "0", ")", "cfun", "->", "machine", "->", "varargs_size", "=", "gp_saved", "*", "UNITS_PER_WORD", ";", "}", "</s>" ]

[ "Implement", "TARGET_SETUP_INCOMING_VARARGS", "." ]

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

[]

[ "<s>", "void", "SPUHazardRecognizer", "::", "AdvanceCycle", "(", ")", "{", "DOUT", "(", "llvm", "::", "dbgs", "(", ")", "<<", "\"SPUHazardRecognizer::AdvanceCycle\\n\"", ";", "}", "</s>" ]

[ "AdvanceCycle", "-", "This", "callback", "is", "invoked", "whenever", "the", "next", "top-down", "instruction", "to", "be", "scheduled", "can", "not", "issue", "in", "the", "current", "cycle", ",", "either", "because", "of", "latency", "or", "resource", "conflicts", "." ]

[ "CellSPU", "SPU", "\"SPUHazardRecognizer::AdvanceCycle\\n\"" ]

[]

[ "<s>", "unsigned", "long", "arm_current_func_type", "(", ")", "{", "if", "(", "ARM_FUNC_TYPE", "(", "cfun", "->", "machine", "->", "func_type", ")", "==", "ARM_FT_UNKNOWN", ")", "cfun", "->", "machine", "->", "func_type", "=", "arm_compute_func_type", "(", ")", ";", "return", "cfun", "->", "machine", "->", "func_type", ";", "}", "</s>" ]

[ "Returns", "the", "type", "of", "the", "current", "function", "." ]

[ "arm" ]

[]

[ "<s>", "BitVector", "RISCVRegisterInfo", "::", "getReservedRegs", "(", "const", "MachineFunction", "&", "MF", ")", "const", "{", "const", "TargetFrameLowering", "*", "TFI", "=", "getFrameLowering", "(", "MF", ")", ";", "BitVector", "Reserved", "(", "getNumRegs", "(", ")", ")", ";", "for", "(", "size_t", "Reg", "=", "0", ";", "Reg", "<", "getNumRegs", "(", ")", ";", "Reg", "++", ")", "{", "if", "(", "MF", ".", "getSubtarget", "<", "RISCVSubtarget", ">", "(", ")", ".", "isRegisterReservedByUser", "(", "Reg", ")", ")", "markSuperRegs", "(", "Reserved", ",", "Reg", ")", ";", "}", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X0", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X2", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X3", ")", ";", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X4", ")", ";", "if", "(", "TFI", "->", "hasFP", "(", "MF", ")", ")", "markSuperRegs", "(", "Reserved", ",", "RISCV", "::", "X8", ")", ";", "assert", "(", "checkAllSuperRegsMarked", "(", "Reserved", ")", ")", ";", "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", "." ]

[ "RISCV", "RISCV", "0", "RISCV", "RISCV::X0", "RISCV::X2", "RISCV::X3", "RISCV::X4", "RISCV::X8" ]

[]

[ "<s>", "bool", "AArch64FrameLowering", "::", "canUseAsPrologue", "(", "const", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "const", "MachineFunction", "*", "MF", "=", "MBB", ".", "getParent", "(", ")", ";", "MachineBasicBlock", "*", "TmpMBB", "=", "const_cast", "<", "MachineBasicBlock", "*", ">", "(", "&", "MBB", ")", ";", "const", "AArch64Subtarget", "&", "Subtarget", "=", "MF", "->", "getSubtarget", "<", "AArch64Subtarget", ">", "(", ")", ";", "const", "AArch64RegisterInfo", "*", "RegInfo", "=", "Subtarget", ".", "getRegisterInfo", "(", ")", ";", "if", "(", "!", "RegInfo", "->", "needsStackRealignment", "(", "*", "MF", ")", ")", "return", "true", ";", "return", "findScratchNonCalleeSaveRegister", "(", "TmpMBB", ")", "!=", "AArch64", "::", "NoRegister", ";", "}", "</s>" ]

[ "Check", "whether", "or", "not", "the", "given", "MBB", "can", "be", "used", "as", "a", "prologue", "for", "the", "target", "." ]

[ "AArch64", "AArch64", "AArch64", "AArch64", "AArch64", "AArch64::NoRegister" ]

[]

[ "<s>", "bool", "nds32_expand_movmemsi", "(", "rtx", "dstmem", ",", "rtx", "srcmem", ",", "rtx", "total_bytes", ",", "rtx", "alignment", ")", "{", "if", "(", "nds32_expand_movmemsi_unroll", "(", "dstmem", ",", "srcmem", ",", "total_bytes", ",", "alignment", ")", ")", "return", "true", ";", "if", "(", "!", "optimize_size", "&&", "optimize", ">", "2", ")", "return", "nds32_expand_movmemsi_loop", "(", "dstmem", ",", "srcmem", ",", "total_bytes", ",", "alignment", ")", ";", "return", "false", ";", "}", "</s>" ]

[ "Function", "to", "move", "block", "memory", "content", "by", "using", "load_multiple", "and", "store_multiple", ".", "This", "is", "auxiliary", "extern", "function", "to", "help", "create", "rtx", "template", ".", "Check", "nds32-multiple.md", "file", "for", "the", "patterns", "." ]

[ "nds32", "2" ]

[]

[ "<s>", "SDValue", "AMDGPUTargetLowering", "::", "LowerOperation", "(", "SDValue", "Op", ",", "SelectionDAG", "&", "DAG", ")", "const", "{", "switch", "(", "Op", ".", "getOpcode", "(", ")", ")", "{", "default", ":", "Op", "->", "print", "(", "errs", "(", ")", ",", "&", "DAG", ")", ";", "llvm_unreachable", "(", "\"Custom lowering code for this \"", "\"instruction is not implemented yet!\"", ")", ";", "break", ";", "case", "ISD", "::", "SIGN_EXTEND_INREG", ":", "return", "LowerSIGN_EXTEND_INREG", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CONCAT_VECTORS", ":", "return", "LowerCONCAT_VECTORS", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "EXTRACT_SUBVECTOR", ":", "return", "LowerEXTRACT_SUBVECTOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UDIVREM", ":", "return", "LowerUDIVREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SDIVREM", ":", "return", "LowerSDIVREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FREM", ":", "return", "LowerFREM", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FCEIL", ":", "return", "LowerFCEIL", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FTRUNC", ":", "return", "LowerFTRUNC", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FRINT", ":", "return", "LowerFRINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FNEARBYINT", ":", "return", "LowerFNEARBYINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FROUND", ":", "return", "LowerFROUND", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FFLOOR", ":", "return", "LowerFFLOOR", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FLOG", ":", "return", "LowerFLOG", "(", "Op", ",", "DAG", ",", "numbers", "::", "ln2f", ")", ";", "case", "ISD", "::", "FLOG10", ":", "return", "LowerFLOG", "(", "Op", ",", "DAG", ",", "numbers", "::", "ln2f", "/", "numbers", "::", "ln10f", ")", ";", "case", "ISD", "::", "FEXP", ":", "return", "lowerFEXP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "SINT_TO_FP", ":", "return", "LowerSINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "UINT_TO_FP", ":", "return", "LowerUINT_TO_FP", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_FP16", ":", "return", "LowerFP_TO_FP16", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_SINT", ":", "return", "LowerFP_TO_SINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "FP_TO_UINT", ":", "return", "LowerFP_TO_UINT", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "CTTZ", ":", "case", "ISD", "::", "CTTZ_ZERO_UNDEF", ":", "case", "ISD", "::", "CTLZ", ":", "case", "ISD", "::", "CTLZ_ZERO_UNDEF", ":", "return", "LowerCTLZ_CTTZ", "(", "Op", ",", "DAG", ")", ";", "case", "ISD", "::", "DYNAMIC_STACKALLOC", ":", "return", "LowerDYNAMIC_STACKALLOC", "(", "Op", ",", "DAG", ")", ";", "}", "return", "Op", ";", "}", "</s>" ]

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

[ "AMDGPU", "AMDGPU", "\"Custom lowering code for this \"", "\"instruction is not implemented yet!\"", "ISD::SIGN_EXTEND_INREG", "SI", "ISD::CONCAT_VECTORS", "ISD::EXTRACT_SUBVECTOR", "ISD::UDIVREM", "ISD::SDIVREM", "ISD::FREM", "ISD::FCEIL", "ISD::FTRUNC", "ISD::FRINT", "ISD::FNEARBYINT", "ISD::FROUND", "ISD::FFLOOR", "ISD::FLOG", "ISD::FLOG10", "ISD::FEXP", "ISD::SINT_TO_FP", "SI", "ISD::UINT_TO_FP", "ISD::FP_TO_FP16", "ISD::FP_TO_SINT", "SI", "ISD::FP_TO_UINT", "ISD::CTTZ", "ISD::CTTZ_ZERO_UNDEF", "ISD::CTLZ", "ISD::CTLZ_ZERO_UNDEF", "ISD::DYNAMIC_STACKALLOC" ]

[]

[ "<s>", "void", "X86InstrInfo", "::", "replaceBranchWithTailCall", "(", "MachineBasicBlock", "&", "MBB", ",", "SmallVectorImpl", "<", "MachineOperand", ">", "&", "BranchCond", ",", "const", "MachineInstr", "&", "TailCall", ")", "const", "{", "assert", "(", "canMakeTailCallConditional", "(", "BranchCond", ",", "TailCall", ")", ")", ";", "MachineBasicBlock", "::", "iterator", "I", "=", "MBB", ".", "end", "(", ")", ";", "while", "(", "I", "!=", "MBB", ".", "begin", "(", ")", ")", "{", "--", "I", ";", "if", "(", "I", "->", "isDebugInstr", "(", ")", ")", "continue", ";", "if", "(", "!", "I", "->", "isBranch", "(", ")", ")", "assert", "(", "0", "&&", "\"Can't find the branch to replace!\"", ")", ";", "X86", "::", "CondCode", "CC", "=", "X86", "::", "getCondFromBranchOpc", "(", "I", "->", "getOpcode", "(", ")", ")", ";", "assert", "(", "BranchCond", ".", "size", "(", ")", "==", "1", ")", ";", "if", "(", "CC", "!=", "BranchCond", "[", "0", "]", ".", "getImm", "(", ")", ")", "continue", ";", "break", ";", "}", "unsigned", "Opc", "=", "TailCall", ".", "getOpcode", "(", ")", "==", "X86", "::", "TCRETURNdi", "?", "X86", "::", "TCRETURNdicc", ":", "X86", "::", "TCRETURNdi64cc", ";", "auto", "MIB", "=", "BuildMI", "(", "MBB", ",", "I", ",", "MBB", ".", "findDebugLoc", "(", "I", ")", ",", "get", "(", "Opc", ")", ")", ";", "MIB", "->", "addOperand", "(", "TailCall", ".", "getOperand", "(", "0", ")", ")", ";", "MIB", ".", "addImm", "(", "0", ")", ";", "MIB", "->", "addOperand", "(", "BranchCond", "[", "0", "]", ")", ";", "MIB", ".", "copyImplicitOps", "(", "TailCall", ")", ";", "LivePhysRegs", "LiveRegs", "(", "getRegisterInfo", "(", ")", ")", ";", "LiveRegs", ".", "addLiveOuts", "(", "MBB", ")", ";", "SmallVector", "<", "std", "::", "pair", "<", "unsigned", ",", "const", "MachineOperand", "*", ">", ",", "8", ">", "Clobbers", ";", "LiveRegs", ".", "stepForward", "(", "*", "MIB", ",", "Clobbers", ")", ";", "for", "(", "const", "auto", "&", "C", ":", "Clobbers", ")", "{", "MIB", ".", "addReg", "(", "C", ".", "first", ",", "RegState", "::", "Implicit", ")", ";", "MIB", ".", "addReg", "(", "C", ".", "first", ",", "RegState", "::", "Implicit", "|", "RegState", "::", "Define", ")", ";", "}", "I", "->", "eraseFromParent", "(", ")", ";", "}", "</s>" ]

[ "Replace", "the", "conditional", "branch", "in", "MBB", "with", "a", "conditional", "tail", "call", "." ]

[ "X86", "X86", "0", "\"Can't find the branch to replace!\"", "X86::CondCode", "X86::getCondFromBranchOpc", "1", "0", "X86::TCRETURNdi", "X86::TCRETURNdicc", "X86::TCRETURNdi64cc", "0", "0", "0", "8" ]

[]

[ "<s>", "static", "bool", "rs6000_cannot_change_mode_class", "(", "machine_mode", "from", ",", "machine_mode", "to", ",", "enum", "reg_class", "rclass", ")", "{", "unsigned", "from_size", "=", "GET_MODE_SIZE", "(", "from", ")", ";", "unsigned", "to_size", "=", "GET_MODE_SIZE", "(", "to", ")", ";", "if", "(", "from_size", "!=", "to_size", ")", "{", "enum", "reg_class", "xclass", "=", "(", "TARGET_VSX", ")", "?", "VSX_REGS", ":", "FLOAT_REGS", ";", "if", "(", "reg_classes_intersect_p", "(", "xclass", ",", "rclass", ")", ")", "{", "unsigned", "to_nregs", "=", "hard_regno_nregs", "[", "FIRST_FPR_REGNO", "]", "[", "to", "]", ";", "unsigned", "from_nregs", "=", "hard_regno_nregs", "[", "FIRST_FPR_REGNO", "]", "[", "from", "]", ";", "if", "(", "TARGET_IEEEQUAD", "&&", "(", "to", "==", "TFmode", "||", "from", "==", "TFmode", ")", ")", "return", "true", ";", "if", "(", "!", "BYTES_BIG_ENDIAN", "&&", "(", "to", "==", "TDmode", "||", "from", "==", "TDmode", ")", ")", "return", "true", ";", "if", "(", "from_size", "<", "8", "||", "to_size", "<", "8", ")", "return", "true", ";", "if", "(", "from_size", "==", "8", "&&", "(", "8", "*", "to_nregs", ")", "!=", "to_size", ")", "return", "true", ";", "if", "(", "to_size", "==", "8", "&&", "(", "8", "*", "from_nregs", ")", "!=", "from_size", ")", "return", "true", ";", "return", "false", ";", "}", "else", "return", "false", ";", "}", "if", "(", "TARGET_E500_DOUBLE", "&&", "(", "(", "(", "(", "to", ")", "==", "DFmode", ")", "+", "(", "(", "from", ")", "==", "DFmode", ")", ")", "==", "1", "||", "(", "(", "(", "to", ")", "==", "TFmode", ")", "+", "(", "(", "from", ")", "==", "TFmode", ")", ")", "==", "1", "||", "(", "(", "(", "to", ")", "==", "DDmode", ")", "+", "(", "(", "from", ")", "==", "DDmode", ")", ")", "==", "1", "||", "(", "(", "(", "to", ")", "==", "TDmode", ")", "+", "(", "(", "from", ")", "==", "TDmode", ")", ")", "==", "1", "||", "(", "(", "(", "to", ")", "==", "DImode", ")", "+", "(", "(", "from", ")", "==", "DImode", ")", ")", "==", "1", ")", ")", "return", "true", ";", "if", "(", "TARGET_VSX", "&&", "VSX_REG_CLASS_P", "(", "rclass", ")", ")", "{", "unsigned", "num_regs", "=", "(", "from_size", "+", "15", ")", "/", "16", ";", "if", "(", "hard_regno_nregs", "[", "FIRST_FPR_REGNO", "]", "[", "to", "]", ">", "num_regs", "||", "hard_regno_nregs", "[", "FIRST_FPR_REGNO", "]", "[", "from", "]", ">", "num_regs", ")", "return", "true", ";", "return", "(", "from_size", "!=", "8", "&&", "from_size", "!=", "16", ")", ";", "}", "if", "(", "TARGET_ALTIVEC", "&&", "rclass", "==", "ALTIVEC_REGS", "&&", "(", "ALTIVEC_VECTOR_MODE", "(", "from", ")", "+", "ALTIVEC_VECTOR_MODE", "(", "to", ")", ")", "==", "1", ")", "return", "true", ";", "if", "(", "TARGET_SPE", "&&", "(", "SPE_VECTOR_MODE", "(", "from", ")", "+", "SPE_VECTOR_MODE", "(", "to", ")", ")", "==", "1", "&&", "reg_classes_intersect_p", "(", "GENERAL_REGS", ",", "rclass", ")", ")", "return", "true", ";", "return", "false", ";", "}", "</s>" ]

[ "Return", "nonzero", "if", "for", "CLASS", "a", "mode", "change", "from", "FROM", "to", "TO", "is", "invalid", "." ]

[ "rs6000", "8", "8", "8", "8", "8", "8", "1", "1", "1", "1", "1", "15", "16", "8", "16", "1", "1" ]

[]

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

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

[ "R600" ]

[]

[ "<s>", "void", "MINA32FrameLowering", "::", "emitPrologue", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ")", "const", "{", "}", "</s>" ]

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

[ "MINA32", "MINA32" ]

[]

[ "<s>", "static", "int", "ix86_function_sseregparm", "(", "const_tree", "type", ",", "const_tree", "decl", ",", "bool", "warn", ")", "{", "gcc_assert", "(", "!", "TARGET_64BIT", ")", ";", "if", "(", "TARGET_SSEREGPARM", "||", "(", "type", "&&", "lookup_attribute", "(", "\"sseregparm\"", ",", "TYPE_ATTRIBUTES", "(", "type", ")", ")", ")", ")", "{", "if", "(", "!", "TARGET_SSE", ")", "{", "if", "(", "warn", ")", "{", "if", "(", "decl", ")", "error", "(", "\"calling %qD with attribute sseregparm without \"", "\"SSE/SSE2 enabled\"", ",", "decl", ")", ";", "else", "error", "(", "\"calling %qT with attribute sseregparm without \"", "\"SSE/SSE2 enabled\"", ",", "type", ")", ";", "}", "return", "0", ";", "}", "return", "2", ";", "}", "if", "(", "!", "decl", ")", "return", "0", ";", "cgraph_node", "*", "target", "=", "cgraph_node", "::", "get", "(", "decl", ")", ";", "if", "(", "target", ")", "target", "=", "target", "->", "function_symbol", "(", ")", ";", "if", "(", "target", "&&", "(", "target_opts_for_fn", "(", "target", "->", "decl", ")", "->", "x_ix86_fpmath", "&", "FPMATH_SSE", ")", "&&", "opt_for_fn", "(", "target", "->", "decl", ",", "optimize", ")", "&&", "!", "(", "profile_flag", "&&", "!", "flag_fentry", ")", ")", "{", "if", "(", "target", "->", "local", "&&", "target", "->", "can_change_signature", ")", "{", "if", "(", "!", "TARGET_SSE", "&&", "warn", ")", "return", "-", "1", ";", "return", "TARGET_SSE2_P", "(", "target_opts_for_fn", "(", "target", "->", "decl", ")", "->", "x_ix86_isa_flags", ")", "?", "2", ":", "1", ";", "}", "}", "return", "0", ";", "}", "</s>" ]

[ "Return", "1", "or", "2", ",", "if", "we", "can", "pass", "up", "to", "SSE_REGPARM_MAX", "SFmode", "(", "1", ")", "and", "DFmode", "(", "2", ")", "arguments", "in", "SSE", "registers", "for", "a", "function", "with", "the", "indicated", "TYPE", "and", "DECL", ".", "DECL", "may", "be", "NULL", "when", "calling", "function", "indirectly", "or", "considering", "a", "libcall", ".", "Otherwise", "return", "0", "." ]

[ "i386", "\"sseregparm\"", "\"calling %qD with attribute sseregparm without \"", "\"SSE/SSE2 enabled\"", "\"calling %qT with attribute sseregparm without \"", "\"SSE/SSE2 enabled\"", "0", "2", "0", "1", "2", "1", "0" ]

[]

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

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

[ "Comet2", "Comet2" ]

[]

[ "<s>", "bool", "RISCVTargetLowering", "::", "mayBeEmittedAsTailCall", "(", "const", "CallInst", "*", "CI", ")", "const", "{", "return", "CI", "->", "isTailCall", "(", ")", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "target", "may", "be", "able", "emit", "the", "call", "instruction", "as", "a", "tail", "call", "." ]

[ "RI5CY", "RISCV" ]

[]

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

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

[ "AVR" ]

[]

[ "<s>", "char", "*", "csky_output_call", "(", "rtx", "*", "operands", ",", "int", "index", ")", "{", "static", "char", "buffer", "[", "20", "]", ";", "rtx", "addr", "=", "operands", "[", "index", "]", ";", "if", "(", "REG_P", "(", "addr", ")", ")", "sprintf", "(", "buffer", ",", "\"jsr\\t%%%d\"", ",", "index", ")", ";", "else", "if", "(", "flag_pic", "&&", "(", "GET_CODE", "(", "addr", ")", "==", "UNSPEC", ")", ")", "sprintf", "(", "buffer", ",", "\"bsr\\t%%%d\"", ",", "index", ")", ";", "else", "sprintf", "(", "buffer", ",", "\"jbsr\\t%%%d\"", ",", "index", ")", ";", "return", "buffer", ";", "}", "</s>" ]

[ "Functions", "to", "output", "assembly", "code", "for", "a", "function", "call", "." ]

[ "csky", "20", "\"jsr\\t%%%d\"", "\"bsr\\t%%%d\"", "\"jbsr\\t%%%d\"" ]

[]

[ "<s>", "void", "BlackfinDAGToDAGISel", "::", "PostprocessISelDAG", "(", ")", "{", "FixRegisterClasses", "(", "*", "CurDAG", ")", ";", "}", "</s>" ]

[ "PostprocessISelDAG", "(", ")", "-", "This", "hook", "allows", "the", "target", "to", "hack", "on", "the", "graph", "right", "after", "selection", "." ]

[ "Blackfin" ]

[]

[ "<s>", "bool", "ARMBaseInstrInfo", "::", "isPredicable", "(", "MachineInstr", "*", "MI", ")", "const", "{", "if", "(", "!", "MI", "->", "isPredicable", "(", ")", ")", "return", "false", ";", "ARMFunctionInfo", "*", "AFI", "=", "MI", "->", "getParent", "(", ")", "->", "getParent", "(", ")", "->", "getInfo", "<", "ARMFunctionInfo", ">", "(", ")", ";", "if", "(", "AFI", "->", "isThumb2Function", "(", ")", ")", "{", "if", "(", "getSubtarget", "(", ")", ".", "hasV8Ops", "(", ")", ")", "return", "isV8EligibleForIT", "(", "MI", ")", ";", "}", "else", "{", "if", "(", "(", "MI", "->", "getDesc", "(", ")", ".", "TSFlags", "&", "ARMII", "::", "DomainMask", ")", "==", "ARMII", "::", "DomainNEON", ")", "return", "false", ";", "}", "return", "true", ";", "}", "</s>" ]

[ "Return", "true", "if", "the", "specified", "instruction", "can", "be", "predicated", "." ]

[ "ARM", "ARM", "ARM", "ARM", "ARMII::DomainMask", "ARMII::DomainNEON" ]

[]

[ "<s>", "static", "inline", "enum", "insn_code", "rs6000_htm_spr_icode", "(", "bool", "nonvoid", ")", "{", "if", "(", "nonvoid", ")", "return", "(", "TARGET_64BIT", ")", "?", "CODE_FOR_htm_mfspr_di", ":", "CODE_FOR_htm_mfspr_si", ";", "else", "return", "(", "TARGET_64BIT", ")", "?", "CODE_FOR_htm_mtspr_di", ":", "CODE_FOR_htm_mtspr_si", ";", "}", "</s>" ]

[ "Return", "the", "correct", "ICODE", "value", "depending", "on", "whether", "we", "are", "setting", "or", "reading", "the", "HTM", "SPRs", "." ]

[ "rs6000" ]

[]

[ "<s>", "static", "rtx", "nvptx_gen_pack", "(", "rtx", "dst", ",", "rtx", "src0", ",", "rtx", "src1", ")", "{", "rtx", "res", ";", "switch", "(", "GET_MODE", "(", "dst", ")", ")", "{", "case", "DImode", ":", "res", "=", "gen_packsidi2", "(", "dst", ",", "src0", ",", "src1", ")", ";", "break", ";", "case", "DFmode", ":", "res", "=", "gen_packsidf2", "(", "dst", ",", "src0", ",", "src1", ")", ";", "break", ";", "default", ":", "gcc_unreachable", "(", ")", ";", "}", "return", "res", ";", "}", "</s>" ]

[ "Generate", "instruction", "(", "s", ")", "to", "pack", "2", "32", "bit", "objects", "into", "a", "64", "bit", "object", "." ]

[ "nvptx" ]

[]

[ "<s>", "void", "HexagonInstrInfo", "::", "loadRegFromStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "DestReg", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ",", "const", "TargetRegisterInfo", "*", "TRI", ")", "const", "{", "DebugLoc", "DL", "=", "MBB", ".", "findDebugLoc", "(", "I", ")", ";", "MachineFunction", "&", "MF", "=", "*", "MBB", ".", "getParent", "(", ")", ";", "MachineFrameInfo", "&", "MFI", "=", "*", "MF", ".", "getFrameInfo", "(", ")", ";", "unsigned", "Align", "=", "MFI", ".", "getObjectAlignment", "(", "FI", ")", ";", "MachineMemOperand", "*", "MMO", "=", "MF", ".", "getMachineMemOperand", "(", "MachinePointerInfo", "::", "getFixedStack", "(", "MF", ",", "FI", ")", ",", "MachineMemOperand", "::", "MOLoad", ",", "MFI", ".", "getObjectSize", "(", "FI", ")", ",", "Align", ")", ";", "if", "(", "Hexagon", "::", "IntRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "L2_loadri_io", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "DoubleRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "L2_loadrd_io", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "PredRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "LDriw_pred", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "if", "(", "Hexagon", "::", "ModRegsRegClass", ".", "hasSubClassEq", "(", "RC", ")", ")", "{", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "Hexagon", "::", "LDriw_mod", ")", ",", "DestReg", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addMemOperand", "(", "MMO", ")", ";", "}", "else", "{", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "}", "}", "</s>" ]

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

[ "Hexagon", "Hexagon", "Hexagon::IntRegsRegClass", "Hexagon::L2_loadri_io", "0", "Hexagon::DoubleRegsRegClass", "Hexagon::L2_loadrd_io", "0", "Hexagon::PredRegsRegClass", "Hexagon::LDriw_pred", "0", "Hexagon::ModRegsRegClass", "Hexagon::LDriw_mod", "0", "\"Can't store this register to stack slot\"" ]

[]

[ "<s>", "static", "rtx", "get_mask_policy_for_pred", "(", "enum", "predication_type_index", "pred", ")", "{", "if", "(", "pred", "==", "PRED_TYPE_tumu", "||", "pred", "==", "PRED_TYPE_mu", ")", "return", "gen_int_mode", "(", "MASK_UNDISTURBED", ",", "Pmode", ")", ";", "return", "gen_int_mode", "(", "get_prefer_mask_policy", "(", ")", ",", "Pmode", ")", ";", "}", "</s>" ]

[ "Get", "MASK", "policy", "for", "predication", ".", "If", "predication", "indicates", "MU", ",", "return", "the", "MU", ".", "Otherwise", ",", "return", "the", "prefer", "default", "configuration", "." ]

[ "riscv" ]

[]

[ "<s>", "unsigned", "GCNHazardRecognizer", "::", "PreEmitNoops", "(", "MachineInstr", "*", "MI", ")", "{", "if", "(", "SIInstrInfo", "::", "isSMRD", "(", "*", "MI", ")", ")", "return", "std", "::", "max", "(", "0", ",", "checkSMRDHazards", "(", "MI", ")", ")", ";", "if", "(", "SIInstrInfo", "::", "isVMEM", "(", "*", "MI", ")", ")", "return", "std", "::", "max", "(", "0", ",", "checkVMEMHazards", "(", "MI", ")", ")", ";", "if", "(", "SIInstrInfo", "::", "isDPP", "(", "*", "MI", ")", ")", "return", "std", "::", "max", "(", "0", ",", "checkDPPHazards", "(", "MI", ")", ")", ";", "return", "0", ";", "}", "</s>" ]

[ "PreEmitNoops", "-", "This", "callback", "is", "invoked", "prior", "to", "emitting", "an", "instruction", "." ]

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

[]

[ "<s>", "void", "VideoCore4FrameLowering", "::", "eliminateCallFramePseudoInstr", "(", "MachineFunction", "&", "MF", ",", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ")", "const", "{", "MachineInstr", "&", "MI", "=", "*", "I", ";", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "VideoCore4", "::", "ADJCALLSTACKDOWN", ")", "{", "}", "else", "if", "(", "MI", ".", "getOpcode", "(", ")", "==", "VideoCore4", "::", "ADJCALLSTACKUP", ")", "{", "}", "else", "{", "llvm_unreachable", "(", "\"Cannot handle this call frame pseudo instruction\"", ")", ";", "}", "MBB", ".", "erase", "(", "I", ")", ";", "}", "</s>" ]

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

[ "VideoCore4", "VideoCore4", "VideoCore4::ADJCALLSTACKDOWN", "VideoCore4::ADJCALLSTACKUP", "\"Cannot handle this call frame pseudo instruction\"" ]

[]

[ "<s>", "void", "SparcInstrInfo", "::", "storeRegToStackSlot", "(", "MachineBasicBlock", "&", "MBB", ",", "MachineBasicBlock", "::", "iterator", "I", ",", "unsigned", "SrcReg", ",", "bool", "isKill", ",", "int", "FI", ",", "const", "TargetRegisterClass", "*", "RC", ")", "const", "{", "DebugLoc", "DL", "=", "DebugLoc", "::", "getUnknownLoc", "(", ")", ";", "if", "(", "I", "!=", "MBB", ".", "end", "(", ")", ")", "DL", "=", "I", "->", "getDebugLoc", "(", ")", ";", "if", "(", "RC", "==", "SP", "::", "IntRegsRegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "STri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "else", "if", "(", "RC", "==", "SP", "::", "FPRegsRegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "STFri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "else", "if", "(", "RC", "==", "SP", "::", "DFPRegsRegisterClass", ")", "BuildMI", "(", "MBB", ",", "I", ",", "DL", ",", "get", "(", "SP", "::", "STDFri", ")", ")", ".", "addFrameIndex", "(", "FI", ")", ".", "addImm", "(", "0", ")", ".", "addReg", "(", "SrcReg", ",", "getKillRegState", "(", "isKill", ")", ")", ";", "else", "llvm_unreachable", "(", "\"Can't store this register to stack slot\"", ")", ";", "}", "</s>" ]

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

[ "Sparc", "Sparc", "SP::IntRegsRegisterClass", "SP::STri", "0", "SP::FPRegsRegisterClass", "SP::STFri", "0", "SP::DFPRegsRegisterClass", "SP::STDFri", "0", "\"Can't store this register to stack slot\"" ]

[]

[ "<s>", "rtx", "gen_easy_altivec_constant", "(", "rtx", "op", ")", "{", "enum", "machine_mode", "mode", "=", "GET_MODE", "(", "op", ")", ";", "int", "nunits", "=", "GET_MODE_NUNITS", "(", "mode", ")", ";", "rtx", "last", "=", "CONST_VECTOR_ELT", "(", "op", ",", "nunits", "-", "1", ")", ";", "unsigned", "step", "=", "nunits", "/", "4", ";", "unsigned", "copies", "=", "1", ";", "if", "(", "vspltis_constant", "(", "op", ",", "step", ",", "copies", ")", ")", "return", "gen_rtx_VEC_DUPLICATE", "(", "V4SImode", ",", "gen_lowpart", "(", "SImode", ",", "last", ")", ")", ";", "if", "(", "step", "==", "1", ")", "copies", "<<=", "1", ";", "else", "step", ">>=", "1", ";", "if", "(", "vspltis_constant", "(", "op", ",", "step", ",", "copies", ")", ")", "return", "gen_rtx_VEC_DUPLICATE", "(", "V8HImode", ",", "gen_lowpart", "(", "HImode", ",", "last", ")", ")", ";", "if", "(", "step", "==", "1", ")", "copies", "<<=", "1", ";", "else", "step", ">>=", "1", ";", "if", "(", "vspltis_constant", "(", "op", ",", "step", ",", "copies", ")", ")", "return", "gen_rtx_VEC_DUPLICATE", "(", "V16QImode", ",", "gen_lowpart", "(", "QImode", ",", "last", ")", ")", ";", "gcc_unreachable", "(", ")", ";", "}", "</s>" ]

[ "Generate", "a", "VEC_DUPLICATE", "representing", "a", "vspltis", "[", "bhw", "]", "instruction", "whose", "result", "is", "OP", ".", "Abort", "if", "it", "is", "not", "possible", "." ]

[ "rs6000", "1", "4", "1", "1", "1", "1", "1", "1", "1" ]

[]

[ "<s>", "int64_t", "ARMBaseRegisterInfo", "::", "getFrameIndexInstrOffset", "(", "const", "MachineInstr", "*", "MI", ",", "int", "Idx", ")", "const", "{", "const", "MCInstrDesc", "&", "Desc", "=", "MI", "->", "getDesc", "(", ")", ";", "unsigned", "AddrMode", "=", "(", "Desc", ".", "TSFlags", "&", "ARMII", "::", "AddrModeMask", ")", ";", "int64_t", "InstrOffs", "=", "0", ";", "int", "Scale", "=", "1", ";", "unsigned", "ImmIdx", "=", "0", ";", "switch", "(", "AddrMode", ")", "{", "case", "ARMII", "::", "AddrModeT2_i8", ":", "case", "ARMII", "::", "AddrModeT2_i8neg", ":", "case", "ARMII", "::", "AddrModeT2_i8pos", ":", "case", "ARMII", "::", "AddrModeT2_i12", ":", "case", "ARMII", "::", "AddrMode_i12", ":", "InstrOffs", "=", "MI", "->", "getOperand", "(", "Idx", "+", "1", ")", ".", "getImm", "(", ")", ";", "Scale", "=", "1", ";", "break", ";", "case", "ARMII", "::", "AddrMode5", ":", "{", "const", "MachineOperand", "&", "OffOp", "=", "MI", "->", "getOperand", "(", "Idx", "+", "1", ")", ";", "InstrOffs", "=", "ARM_AM", "::", "getAM5Offset", "(", "OffOp", ".", "getImm", "(", ")", ")", ";", "if", "(", "ARM_AM", "::", "getAM5Op", "(", "OffOp", ".", "getImm", "(", ")", ")", "==", "ARM_AM", "::", "sub", ")", "InstrOffs", "=", "-", "InstrOffs", ";", "Scale", "=", "4", ";", "break", ";", "}", "case", "ARMII", "::", "AddrMode2", ":", "ImmIdx", "=", "Idx", "+", "2", ";", "InstrOffs", "=", "ARM_AM", "::", "getAM2Offset", "(", "MI", "->", "getOperand", "(", "ImmIdx", ")", ".", "getImm", "(", ")", ")", ";", "if", "(", "ARM_AM", "::", "getAM2Op", "(", "MI", "->", "getOperand", "(", "ImmIdx", ")", ".", "getImm", "(", ")", ")", "==", "ARM_AM", "::", "sub", ")", "InstrOffs", "=", "-", "InstrOffs", ";", "break", ";", "case", "ARMII", "::", "AddrMode3", ":", "ImmIdx", "=", "Idx", "+", "2", ";", "InstrOffs", "=", "ARM_AM", "::", "getAM3Offset", "(", "MI", "->", "getOperand", "(", "ImmIdx", ")", ".", "getImm", "(", ")", ")", ";", "if", "(", "ARM_AM", "::", "getAM3Op", "(", "MI", "->", "getOperand", "(", "ImmIdx", ")", ".", "getImm", "(", ")", ")", "==", "ARM_AM", "::", "sub", ")", "InstrOffs", "=", "-", "InstrOffs", ";", "break", ";", "case", "ARMII", "::", "AddrModeT1_s", ":", "ImmIdx", "=", "Idx", "+", "1", ";", "InstrOffs", "=", "MI", "->", "getOperand", "(", "ImmIdx", ")", ".", "getImm", "(", ")", ";", "Scale", "=", "4", ";", "break", ";", "default", ":", "llvm_unreachable", "(", "\"Unsupported addressing mode!\"", ")", ";", "}", "return", "InstrOffs", "*", "Scale", ";", "}", "</s>" ]

[ "Get", "the", "offset", "from", "the", "referenced", "frame", "index", "in", "the", "instruction", ",", "if", "there", "is", "one", "." ]

[ "ARM", "ARM", "ARMII::AddrModeMask", "0", "1", "0", "ARMII::AddrModeT2_i8", "ARMII::AddrModeT2_i8neg", "ARMII::AddrModeT2_i8pos", "ARMII::AddrModeT2_i12", "ARMII::AddrMode_i12", "1", "1", "ARMII::AddrMode5", "1", "ARM_AM::getAM5Offset", "ARM_AM::getAM5Op", "ARM_AM::sub", "4", "ARMII::AddrMode2", "2", "ARM_AM::getAM2Offset", "ARM_AM::getAM2Op", "ARM_AM::sub", "ARMII::AddrMode3", "2", "ARM_AM::getAM3Offset", "ARM_AM::getAM3Op", "ARM_AM::sub", "ARMII::AddrModeT1_s", "1", "4", "\"Unsupported addressing mode!\"" ]

[]

[ "<s>", "static", "void", "process_args", "(", "int", "*", "p_argc", ",", "char", "*", "*", "argv", ")", "{", "int", "i", ";", "for", "(", "i", "=", "1", ";", "i", "<", "*", "p_argc", ";", "i", "++", ")", "{", "if", "(", "strlen", "(", "argv", "[", "i", "]", ")", "<", "2", ")", "continue", ";", "if", "(", "strncmp", "(", "argv", "[", "i", "]", ",", "\"-L\"", ",", "2", ")", "==", "0", ")", "{", "char", "*", "nbuff", ",", "*", "ptr", ";", "int", "new_len", ",", "search_dirs_len", ";", "ptr", "=", "&", "argv", "[", "i", "]", "[", "2", "]", ";", "new_len", "=", "strlen", "(", "ptr", ")", ";", "search_dirs_len", "=", "strlen", "(", "search_dirs", ")", ";", "nbuff", "=", "xmalloc", "(", "new_len", "+", "1", ")", ";", "strcpy", "(", "nbuff", ",", "ptr", ")", ";", "while", "(", "new_len", ">", "1", "&&", "nbuff", "[", "new_len", "-", "1", "]", "==", "'/'", ")", "{", "nbuff", "[", "new_len", "-", "1", "]", "=", "0", ";", "new_len", "--", ";", "}", "search_dirs", "=", "xrealloc", "(", "search_dirs", ",", "search_dirs_len", "+", "new_len", "+", "2", ")", ";", "if", "(", "search_dirs_len", ">", "0", ")", "strcat", "(", "search_dirs", ",", "PATH_SEPARATOR_STR", ")", ";", "strcat", "(", "search_dirs", ",", "nbuff", ")", ";", "free", "(", "nbuff", ")", ";", "}", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-v\"", ")", "==", "0", ")", "verbose", "=", "1", ";", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-g0\"", ")", "==", "0", ")", "addarg", "(", "\"/notraceback\"", ")", ";", "else", "if", "(", "strncmp", "(", "argv", "[", "i", "]", ",", "\"-g\"", ",", "2", ")", "==", "0", ")", "{", "addarg", "(", "\"/debug\"", ")", ";", "debug", "=", "1", ";", "}", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-static\"", ")", "==", "0", ")", "staticp", "=", "1", ";", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-map\"", ")", "==", "0", ")", "{", "char", "*", "buff", ",", "*", "ptr", ";", "buff", "=", "xmalloc", "(", "strlen", "(", "exefilename", ")", "+", "5", ")", ";", "strcpy", "(", "buff", ",", "exefilename", ")", ";", "ptr", "=", "strchr", "(", "buff", ",", "'.'", ")", ";", "if", "(", "ptr", ")", "*", "ptr", "=", "0", ";", "strcat", "(", "buff", ",", "\".map\"", ")", ";", "addarg", "(", "\"/map=\"", ")", ";", "addarg", "(", "buff", ")", ";", "addarg", "(", "\"/full\"", ")", ";", "}", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"-save-temps\"", ")", "==", "0", ")", "save_temps", "=", "1", ";", "else", "if", "(", "strcmp", "(", "argv", "[", "i", "]", ",", "\"--noinhibit-exec\"", ")", "==", "0", ")", "inhibit_exec", "=", "0", ";", "}", "}", "</s>" ]

[ "Preprocess", "the", "number", "of", "args", "ARGC", "in", "ARGV", ".", "Look", "for", "special", "flags", ",", "etc", ".", "that", "must", "be", "handled", "for", "the", "VMS", "linker", "." ]

[ "alpha", "1", "2", "\"-L\"", "2", "0", "2", "1", "1", "1", "1", "0", "2", "0", "\"-v\"", "0", "1", "\"-g0\"", "0", "\"/notraceback\"", "\"-g\"", "2", "0", "\"/debug\"", "1", "\"-static\"", "0", "1", "\"-map\"", "0", "5", "0", "\".map\"", "\"/map=\"", "\"/full\"", "\"-save-temps\"", "0", "1", "\"--noinhibit-exec\"", "0", "0" ]

[]

[ "<s>", "void", "AArch64Subtarget", "::", "overrideSchedPolicy", "(", "MachineSchedPolicy", "&", "Policy", ",", "MachineInstr", "*", "begin", ",", "MachineInstr", "*", "end", ",", "unsigned", "NumRegionInstrs", ")", "const", "{", "Policy", ".", "OnlyTopDown", "=", "false", ";", "Policy", ".", "OnlyBottomUp", "=", "false", ";", "}", "</s>" ]

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

[ "AArch64", "AArch64" ]

[]