|
| 1 | +//====- LoweringPrepareArm64CXXABI.cpp - Arm64 ABI specific code -----====// |
| 2 | +// |
| 3 | +// Part of the LLVM Project, |
| 4 | +// under the Apache License v2.0 with LLVM Exceptions. |
| 5 | +// See https://llvm.org/LICENSE.txt for license information. |
| 6 | +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| 7 | +// |
| 8 | +//===------------------------------------------------------------------===// |
| 9 | +// |
| 10 | +// This file provides ARM64 C++ ABI specific code that is used during LLVMIR |
| 11 | +// lowering prepare. |
| 12 | +// |
| 13 | +//===------------------------------------------------------------------===// |
| 14 | + |
| 15 | +#include "../IR/MissingFeatures.h" |
| 16 | +#include "LoweringPrepareItaniumCXXABI.h" |
| 17 | + |
| 18 | +#include <assert.h> |
| 19 | + |
| 20 | +using cir::LoweringPrepareCXXABI; |
| 21 | +using cir::MissingFeatures; |
| 22 | + |
| 23 | +using namespace mlir; |
| 24 | +using namespace mlir::cir; |
| 25 | + |
| 26 | +namespace { |
| 27 | +class LoweringPrepareAArch64CXXABI : public LoweringPrepareItaniumCXXABI { |
| 28 | +public: |
| 29 | + LoweringPrepareAArch64CXXABI(clang::TargetCXXABI::Kind k) : Kind(k) {} |
| 30 | + mlir::Value lowerVAArg(CIRBaseBuilderTy &builder, |
| 31 | + mlir::cir::VAArgOp op) override; |
| 32 | + |
| 33 | +private: |
| 34 | + clang::TargetCXXABI::Kind Kind; |
| 35 | + mlir::Value lowerAAPCSVAArg(CIRBaseBuilderTy &builder, mlir::cir::VAArgOp op); |
| 36 | +}; |
| 37 | +} // namespace |
| 38 | + |
| 39 | +LoweringPrepareCXXABI * |
| 40 | +LoweringPrepareCXXABI::createAArch64ABI(clang::TargetCXXABI::Kind k) { |
| 41 | + return new LoweringPrepareAArch64CXXABI(k); |
| 42 | +} |
| 43 | + |
| 44 | +mlir::Value |
| 45 | +LoweringPrepareAArch64CXXABI::lowerAAPCSVAArg(CIRBaseBuilderTy &builder, |
| 46 | + mlir::cir::VAArgOp op) { |
| 47 | + auto loc = op->getLoc(); |
| 48 | + auto valist = op->getOperand(0); |
| 49 | + auto opResTy = op.getType(); |
| 50 | + // front end should not produce non-scalar type of VAArgOp |
| 51 | + bool isSupportedType = |
| 52 | + opResTy.isa<mlir::cir::IntType, mlir::cir::SingleType, |
| 53 | + mlir::cir::PointerType, mlir::cir::BoolType, |
| 54 | + mlir::cir::DoubleType>(); |
| 55 | + |
| 56 | + // Homogenous Aggregate type not supported and indirect arg |
| 57 | + // passing not supported yet. And for these supported types, |
| 58 | + // we should not have alignment greater than 8 problem. |
| 59 | + assert(isSupportedType); |
| 60 | + assert(!MissingFeatures::handleAArch64Indirect()); |
| 61 | + |
| 62 | + bool isFloatingType = |
| 63 | + opResTy.isa<mlir::cir::SingleType, mlir::cir::DoubleType>(); |
| 64 | + |
| 65 | + // The AArch64 va_list type and handling is specified in the Procedure Call |
| 66 | + // Standard, section B.4: |
| 67 | + // |
| 68 | + // struct { |
| 69 | + // void *__stack; |
| 70 | + // void *__gr_top; |
| 71 | + // void *__vr_top; |
| 72 | + // int __gr_offs; |
| 73 | + // int __vr_offs; |
| 74 | + // }; |
| 75 | + auto curInsertionP = builder.saveInsertionPoint(); |
| 76 | + auto currentBlock = builder.getInsertionBlock(); |
| 77 | + auto boolTy = builder.getBoolTy(); |
| 78 | + |
| 79 | + auto maybeRegBlock = builder.createBlock(builder.getBlock()->getParent()); |
| 80 | + auto inRegBlock = builder.createBlock(builder.getBlock()->getParent()); |
| 81 | + auto onStackBlock = builder.createBlock(builder.getBlock()->getParent()); |
| 82 | + |
| 83 | + //======================================= |
| 84 | + // Find out where argument was passed |
| 85 | + //======================================= |
| 86 | + |
| 87 | + // If v/gr_offs >= 0 we're already using the stack for this type of |
| 88 | + // argument. We don't want to keep updating reg_offs (in case it overflows, |
| 89 | + // though anyone passing 2GB of arguments, each at most 16 bytes, deserves |
| 90 | + // whatever they get). |
| 91 | + builder.restoreInsertionPoint(curInsertionP); |
| 92 | + // 3 is the field number of __gr_offs, 4 is the field number of __vr_offs |
| 93 | + auto offsP = builder.createGetMemberOp(loc, valist, |
| 94 | + isFloatingType ? "vr_offs" : "gr_offs", |
| 95 | + isFloatingType ? 4 : 3); |
| 96 | + auto offs = builder.create<mlir::cir::LoadOp>(loc, offsP); |
| 97 | + auto zeroValue = builder.create<mlir::cir::ConstantOp>( |
| 98 | + loc, offs.getType(), mlir::cir::IntAttr::get(offs.getType(), 0)); |
| 99 | + auto cmpRes = builder.create<mlir::cir::CmpOp>(loc, boolTy, CmpOpKind::ge, |
| 100 | + offs, zeroValue); |
| 101 | + builder.create<mlir::cir::BrCondOp>(loc, cmpRes, onStackBlock, maybeRegBlock); |
| 102 | + auto newEndBlock = currentBlock->splitBlock(op); |
| 103 | + |
| 104 | + // maybeRegBlock updates the gr_offs/vr_offs pointer for next call to va_arg |
| 105 | + // on this va_list. The fact that this is done unconditionally reflects the |
| 106 | + // fact that allocating an argument to the stack also uses up all the |
| 107 | + // remaining registers of the appropriate kind. |
| 108 | + builder.setInsertionPointToEnd(maybeRegBlock); |
| 109 | + auto boundaryValue = builder.create<mlir::cir::ConstantOp>( |
| 110 | + loc, offs.getType(), |
| 111 | + mlir::cir::IntAttr::get(offs.getType(), isFloatingType ? 16 : 8)); |
| 112 | + auto newRegsOffs = builder.create<mlir::cir::BinOp>( |
| 113 | + loc, offs.getType(), mlir::cir::BinOpKind::Add, offs, boundaryValue); |
| 114 | + builder.createStore(loc, newRegsOffs, offsP); |
| 115 | + // Now we're in a position to decide whether this argument really was in |
| 116 | + // registers or not. |
| 117 | + auto maybeRegCmpRes = builder.create<mlir::cir::CmpOp>( |
| 118 | + loc, boolTy, CmpOpKind::le, newRegsOffs, zeroValue); |
| 119 | + builder.create<mlir::cir::BrCondOp>(loc, maybeRegCmpRes, inRegBlock, |
| 120 | + onStackBlock); |
| 121 | + |
| 122 | + //======================================= |
| 123 | + // Argument was on the stack |
| 124 | + //======================================= |
| 125 | + builder.setInsertionPointToEnd(onStackBlock); |
| 126 | + auto stackP = builder.createGetMemberOp(loc, valist, "stack", 0); |
| 127 | + // On big-endian platforms, the value will be right-aligned in its stack slot. |
| 128 | + assert(!MissingFeatures::handleBigEndian()); |
| 129 | + auto stack = builder.create<mlir::cir::LoadOp>(loc, stackP); |
| 130 | + auto ptrDiffTy = |
| 131 | + mlir::cir::IntType::get(builder.getContext(), 64, /*signed=*/false); |
| 132 | + auto eight = builder.create<mlir::cir::ConstantOp>( |
| 133 | + loc, ptrDiffTy, mlir::cir::IntAttr::get(ptrDiffTy, 8)); |
| 134 | + auto i8Ty = IntegerType::get(builder.getContext(), 8); |
| 135 | + auto i8PtrTy = PointerType::get(builder.getContext(), i8Ty); |
| 136 | + auto castStack = builder.createBitcast(stack, i8PtrTy); |
| 137 | + // Write the new value of __stack for the next call to va_arg |
| 138 | + auto newStackAsi8Ptr = builder.create<mlir::cir::PtrStrideOp>( |
| 139 | + loc, castStack.getType(), castStack, eight); |
| 140 | + auto newStack = builder.createBitcast(newStackAsi8Ptr, stack.getType()); |
| 141 | + builder.createStore(loc, newStack, stackP); |
| 142 | + builder.create<mlir::cir::BrOp>(loc, mlir::ValueRange{stack}, newEndBlock); |
| 143 | + |
| 144 | + //======================================= |
| 145 | + // Argument was in registers |
| 146 | + //======================================= |
| 147 | + // Now we emit the code for if the argument was originally passed in |
| 148 | + // registers. First start the appropriate block: |
| 149 | + builder.setInsertionPointToEnd(inRegBlock); |
| 150 | + auto regTopP = builder.createGetMemberOp(loc, valist, |
| 151 | + isFloatingType ? "vr_top" : "gr_top", |
| 152 | + isFloatingType ? 2 : 1); |
| 153 | + auto regTop = builder.create<mlir::cir::LoadOp>(loc, regTopP); |
| 154 | + auto castRegTop = builder.createBitcast(regTop, i8PtrTy); |
| 155 | + // On big-endian platforms, the value will be right-aligned in its stack slot. |
| 156 | + assert(!MissingFeatures::handleBigEndian()); |
| 157 | + auto resAsInt8P = builder.create<mlir::cir::PtrStrideOp>( |
| 158 | + loc, castRegTop.getType(), castRegTop, offs); |
| 159 | + auto resAsVoidP = builder.createBitcast(resAsInt8P, regTop.getType()); |
| 160 | + builder.create<mlir::cir::BrOp>(loc, mlir::ValueRange{resAsVoidP}, |
| 161 | + newEndBlock); |
| 162 | + |
| 163 | + // generate additional instructions for end block |
| 164 | + builder.setInsertionPoint(op); |
| 165 | + newEndBlock->addArgument(stack.getType(), loc); |
| 166 | + auto resP = newEndBlock->getArgument(0); |
| 167 | + assert(resP.getType().isa<mlir::cir::PointerType>()); |
| 168 | + auto opResPTy = PointerType::get(builder.getContext(), opResTy); |
| 169 | + auto castResP = builder.createBitcast(resP, opResPTy); |
| 170 | + auto res = builder.create<mlir::cir::LoadOp>(loc, castResP); |
| 171 | + return res.getResult(); |
| 172 | +} |
| 173 | + |
| 174 | +mlir::Value LoweringPrepareAArch64CXXABI::lowerVAArg(CIRBaseBuilderTy &builder, |
| 175 | + mlir::cir::VAArgOp op) { |
| 176 | + |
| 177 | + if (Kind == clang::TargetCXXABI::GenericAArch64) { |
| 178 | + return lowerAAPCSVAArg(builder, op); |
| 179 | + } |
| 180 | + assert(0 && "unsupported AArch64 CXX ABI"); |
| 181 | +} |
0 commit comments