XALAN_CPP_NAMESPACE_BEGIN
ElemComment::ElemComment(
StylesheetConstructionContext& constructionContext,
Stylesheet& stylesheetTree,
const AttributeListType& atts,
int lineNumber,
int columnNumber) :
ElemTemplateElement(constructionContext,
stylesheetTree,
lineNumber,
columnNumber,
StylesheetConstructionContext::ELEMNAME_COMMENT)
{
const unsigned int nAttrs = atts.getLength();
for(unsigned int i = 0; i < nAttrs; i++)
{
const XalanDOMChar* const aname = atts.getName(i);
if(isAttrOK(aname, atts, i, constructionContext) == false ||
processSpaceAttr(aname, atts, i, constructionContext))
{
constructionContext.error(
XalanMessageLoader::getMessage(
XalanMessages::TemplateHasIllegalAttribute_2Param,
Constants::ELEMNAME_COMMENT_WITH_PREFIX_STRING.c_str(),
aname),
0,
this);
}
}
}
void
ElemVariable::init(
StylesheetConstructionContext& constructionContext,
Stylesheet& stylesheetTree,
const AttributeListType& atts)
{
const unsigned int nAttrs = atts.getLength();
for(unsigned int i = 0; i < nAttrs; i++)
{
const XalanDOMChar* const aname = atts.getName(i);
if (equals(aname, Constants::ATTRNAME_SELECT))
{
m_selectPattern = constructionContext.createXPath(getLocator(), atts.getValue(i), *this);
}
else if (equals(aname, Constants::ATTRNAME_NAME))
{
m_qname = constructionContext.createXalanQName(
atts.getValue(i),
stylesheetTree.getNamespaces(),
getLocator());
if (m_qname->isValid() == false)
{
constructionContext.error(
XalanMessageLoader::getMessage(
XalanMessages::AttributeValueNotValidQName_2Param,
Constants::ATTRNAME_NAME.c_str(),
atts.getValue(i)),
0,
this);
}
}
else if(!(isAttrOK(aname, atts, i, constructionContext) ||
processSpaceAttr(aname, atts, i, constructionContext)))
{
constructionContext.error(
XalanMessageLoader::getMessage(
XalanMessages::TemplateHasIllegalAttribute_2Param,
Constants::ELEMNAME_VARIABLE_WITH_PREFIX_STRING.c_str(),
aname),
0,
this);
}
}
if(m_qname == 0)
{
constructionContext.error(
XalanMessageLoader::getMessage(
XalanMessages::TemplateMustHaveAttribute_2Param,
Constants::ELEMNAME_VARIABLE_WITH_PREFIX_STRING,
Constants::ATTRNAME_NAME),
0,
this);
}
}
XALAN_CPP_NAMESPACE_BEGIN
ElemPI::ElemPI(
StylesheetConstructionContext& constructionContext,
Stylesheet& stylesheetTree,
const AttributeListType& atts,
XalanFileLoc lineNumber,
XalanFileLoc columnNumber) :
ElemTemplateElement(
constructionContext,
stylesheetTree,
lineNumber,
columnNumber,
StylesheetConstructionContext::ELEMNAME_PI),
m_nameAVT(0)
{
const XalanSize_t nAttrs = atts.getLength();
for(XalanSize_t i = 0; i < nAttrs; i++)
{
const XalanDOMChar* const aname = atts.getName(i);
if (equals(aname, Constants::ATTRNAME_NAME))
{
m_nameAVT =
constructionContext.createAVT(getLocator(), aname, atts.getValue(i), *this);
}
else if (isAttrOK(
aname,
atts,
i,
constructionContext) == false &&
processSpaceAttr(
Constants::ELEMNAME_PI_WITH_PREFIX_STRING.c_str(),
aname,
atts,
i,
constructionContext) == false)
{
error(
constructionContext,
XalanMessages::ElementHasIllegalAttribute_2Param,
Constants::ELEMNAME_PI_WITH_PREFIX_STRING.c_str(),
aname);
}
}
if (0 == m_nameAVT)
{
error(
constructionContext,
XalanMessages::ElementMustHaveAttribute_2Param,
Constants::ELEMNAME_PI_WITH_PREFIX_STRING,
Constants::ATTRNAME_NAME);
}
}
XALAN_CPP_NAMESPACE_BEGIN
ElemForEach::ElemForEach(
StylesheetConstructionContext& constructionContext,
Stylesheet& stylesheetTree,
const AttributeListType& atts,
int lineNumber,
int columnNumber) :
ElemTemplateElement(constructionContext,
stylesheetTree,
lineNumber,
columnNumber,
StylesheetConstructionContext::ELEMNAME_FOR_EACH),
m_selectPattern(0),
m_sortElems(),
m_sortElemsCount(0)
{
const unsigned int nAttrs = atts.getLength();
for(unsigned int i = 0; i < nAttrs; i++)
{
const XalanDOMChar* const aname = atts.getName(i);
if(equals(aname, Constants::ATTRNAME_SELECT))
{
m_selectPattern = constructionContext.createXPath(getLocator(), atts.getValue(i), *this);
}
else if(!(isAttrOK(aname, atts, i, constructionContext) ||
processSpaceAttr(aname, atts, i, constructionContext)))
{
constructionContext.error(
XalanMessageLoader::getMessage(
XalanMessages::TemplateHasIllegalAttribute_2Param,
Constants::ELEMNAME_FOREACH_WITH_PREFIX_STRING.c_str(),
aname),
0,
this);
}
}
if(0 == m_selectPattern)
{
constructionContext.error(
XalanMessageLoader::getMessage(
XalanMessages::TemplateMustHaveAttribute_2Param,
Constants::ELEMNAME_FOREACH_WITH_PREFIX_STRING,
Constants::ATTRNAME_SELECT),
0,
this);
}
}
XALAN_CPP_NAMESPACE_BEGIN
ElemMessage::ElemMessage(
StylesheetConstructionContext& constructionContext,
Stylesheet& stylesheetTree,
const AttributeListType& atts,
int lineNumber,
int columnNumber) :
ElemTemplateElement(constructionContext,
stylesheetTree,
lineNumber,
columnNumber,
StylesheetConstructionContext::ELEMNAME_MESSAGE),
m_terminate(false)
{
const unsigned int nAttrs = atts.getLength();
for(unsigned int i = 0; i < nAttrs; i++)
{
const XalanDOMChar* const aname = atts.getName(i);
if (equals(aname, Constants::ATTRNAME_TERMINATE) == true)
{
const XalanDOMChar* const avalue = atts.getValue(i);
if (equals(avalue, Constants::ATTRVAL_YES) == true)
{
m_terminate = true;
}
else if (equals(avalue, Constants::ATTRVAL_NO) == false)
{
constructionContext.error(
XalanMessageLoader::getMessage(XalanMessages::AttributeHasIllegalValue_1Param,Constants::ATTRNAME_TERMINATE),
0,
this);
}
}
else if(isAttrOK(aname, atts, i, constructionContext) == false ||
processSpaceAttr(aname, atts, i, constructionContext))
{
constructionContext.error(
XalanMessageLoader::getMessage(
XalanMessages::TemplateHasIllegalAttribute_2Param,
Constants::ELEMNAME_MESSAGE_WITH_PREFIX_STRING.c_str(),
aname),
0,
this);
}
}
}
bool
ElemUse::processUseAttributeSets(
StylesheetConstructionContext& constructionContext,
const XalanDOMChar* attrName,
const AttributeListType& atts,
int which)
{
bool isUAS = false;
if(StylesheetConstructionContext::ELEMNAME_LITERAL_RESULT == getXSLToken())
{
isUAS = constructionContext.isXSLUseAttributeSetsAttribute(
attrName,
getStylesheet(),
getLocator());
}
else
{
isUAS = equals(attrName, Constants::ATTRNAME_USEATTRIBUTESETS);
}
if(isUAS == true)
{
m_attributeSetsNames =
constructionContext.tokenizeQNames(
m_attributeSetsNamesCount,
atts.getValue(which),
getStylesheet().getNamespaces(),
getLocator());
assert(m_attributeSetsNamesCount == 0 || m_attributeSetsNames != 0);
}
return isUAS;
}
XALAN_CPP_NAMESPACE_BEGIN
ElemOtherwise::ElemOtherwise(
StylesheetConstructionContext& constructionContext,
Stylesheet& stylesheetTree,
const AttributeListType& atts,
XalanFileLoc lineNumber,
XalanFileLoc columnNumber) :
ElemTemplateElement(
constructionContext,
stylesheetTree,
lineNumber,
columnNumber,
StylesheetConstructionContext::ELEMNAME_OTHERWISE)
{
const XalanSize_t nAttrs = atts.getLength();
for (XalanSize_t i = 0; i < nAttrs; i++)
{
const XalanDOMChar* const aname = atts.getName(i);
if (isAttrOK(
aname,
atts,
i,
constructionContext) == false &&
processSpaceAttr(
Constants::ELEMNAME_OTHERWISE_WITH_PREFIX_STRING.c_str(),
aname,
atts,
i,
constructionContext) == false)
{
error(
constructionContext,
XalanMessages::ElementHasIllegalAttribute_2Param,
Constants::ELEMNAME_OTHERWISE_WITH_PREFIX_STRING.c_str(),
aname);
}
}
}
XALAN_CPP_NAMESPACE_BEGIN
ElemFallback::ElemFallback(
StylesheetConstructionContext& constructionContext,
Stylesheet& stylesheetTree,
const AttributeListType& atts,
int lineNumber,
int columnNumber) :
ElemTemplateElement(constructionContext,
stylesheetTree,
lineNumber,
columnNumber,
StylesheetConstructionContext::ELEMNAME_FALLBACK)
{
const unsigned int nAttrs = atts.getLength();
for(unsigned int i = 0; i < nAttrs; i++)
{
const XalanDOMChar* const aname = atts.getName(i);
if (isAttrOK(
aname,
atts,
i,
constructionContext) == false &&
processSpaceAttr(
Constants::ELEMNAME_FALLBACK_WITH_PREFIX_STRING.c_str(),
aname,
atts,
i,
constructionContext) == false)
{
error(
constructionContext,
XalanMessages::ElementHasIllegalAttribute_2Param,
Constants::ELEMNAME_FALLBACK_WITH_PREFIX_STRING.c_str(),
aname);
}
}
}
void
FormatterToXercesDOM::addAttributes(
DOMElementType* theElement,
AttributeListType& attrs)
{
const unsigned int nAtts = attrs.getLength();
if (m_prefixResolver == 0)
{
for(unsigned int i = 0; i < nAtts; i++)
{
theElement->setAttribute(attrs.getName(i), attrs.getValue(i));
}
}
else
{
for(unsigned int i = 0; i < nAtts; i++)
{
const XalanDOMChar* const theName = attrs.getName(i);
assert(theName != 0);
// Check for the namespace...
const XalanDOMString* const theNamespace =
DOMServices::getNamespaceForPrefix(theName, *m_prefixResolver, true, m_buffer);
if (theNamespace == 0 || length(*theNamespace) == 0)
{
theElement->setAttribute(theName, attrs.getValue(i));
}
else
{
theElement->setAttributeNS(theNamespace->c_str(), theName, attrs.getValue(i));
}
}
}
}
XALAN_CPP_NAMESPACE_BEGIN
ElemAttributeSet::ElemAttributeSet(
StylesheetConstructionContext& constructionContext,
Stylesheet& stylesheetTree,
const AttributeListType& atts,
XalanFileLoc lineNumber,
XalanFileLoc columnNumber) :
ElemUse(constructionContext,
stylesheetTree,
lineNumber,
columnNumber,
StylesheetConstructionContext::ELEMNAME_ATTRIBUTE_SET),
m_qname(0)
{
const XalanSize_t nAttrs = atts.getLength();
for (XalanSize_t i = 0; i < nAttrs; i++)
{
const XalanDOMChar* const aname = atts.getName(i);
if (equals(aname, Constants::ATTRNAME_NAME))
{
m_qname = constructionContext.createXalanQName(
atts.getValue(i),
stylesheetTree.getNamespaces(),
getLocator());
if (m_qname->isValid() == false)
{
error(
constructionContext,
XalanMessages::AttributeValueNotValidQName_2Param,
aname,
atts.getValue(i));
}
}
else if (processUseAttributeSets(
constructionContext,
aname,
atts,
i) == false &&
isAttrOK(
aname,
atts,
i,
constructionContext) == false)
{
error(
constructionContext,
XalanMessages::ElementHasIllegalAttribute_2Param,
Constants::ELEMNAME_ATTRIBUTESET_WITH_PREFIX_STRING.c_str(),
aname);
}
}
if (m_qname == 0)
{
error(
constructionContext,
XalanMessages::ElementMustHaveAttribute_2Param,
Constants::ELEMNAME_ATTRIBUTESET_WITH_PREFIX_STRING,
Constants::ATTRNAME_NAME);
}
assert(m_qname->isValid() == true);
}
ElemTemplate::ElemTemplate(
StylesheetConstructionContext& constructionContext,
Stylesheet& stylesheetTree,
const AttributeListType& atts,
int lineNumber,
int columnNumber) :
ElemTemplateElement(constructionContext,
stylesheetTree,
lineNumber,
columnNumber,
StylesheetConstructionContext::ELEMNAME_TEMPLATE),
m_matchPattern(0),
m_name(&s_empty),
m_mode(&s_empty),
m_priority(XPath::getMatchScoreValue(XPath::eMatchScoreNone))
{
const unsigned int nAttrs = atts.getLength();
for(unsigned int i = 0; i < nAttrs; i++)
{
const XalanDOMChar* const aname = atts.getName(i);
if (equals(aname, Constants::ATTRNAME_MATCH))
{
m_matchPattern = constructionContext.createMatchPattern(getLocator(), atts.getValue(i), *this);
}
else if (equals(aname, Constants::ATTRNAME_NAME))
{
m_name = constructionContext.createXalanQName(
atts.getValue(i),
getStylesheet().getNamespaces(),
getLocator());
if (m_name->isValid() == false)
{
error(
constructionContext,
XalanMessages::AttributeValueNotValidQName_2Param,
aname,
atts.getValue(i));
}
}
else if (equals(aname, Constants::ATTRNAME_PRIORITY))
{
assert(atts.getValue(i) != 0);
m_priority = DoubleSupport::toDouble(atts.getValue(i), constructionContext.getMemoryManager());
}
else if (equals(aname, Constants::ATTRNAME_MODE))
{
m_mode = constructionContext.createXalanQName(
atts.getValue(i),
getStylesheet().getNamespaces(),
getLocator());
if (m_mode->isValid() == false)
{
error(
constructionContext,
XalanMessages::AttributeValueNotValidQName_2Param,
aname,
atts.getValue(i));
}
}
else if(isAttrOK(
aname,
atts,
i,
constructionContext) == false &&
processSpaceAttr(
Constants::ELEMNAME_TEMPLATE_WITH_PREFIX_STRING.c_str(),
aname,
atts,
i,
constructionContext) == false)
{
error(
constructionContext,
XalanMessages::ElementHasIllegalAttribute_2Param,
Constants::ELEMNAME_TEMPLATE_WITH_PREFIX_STRING.c_str(),
aname);
}
}
if(0 == m_matchPattern && m_name->isEmpty() == true)
{
error(
constructionContext,
XalanMessages::ElementRequiresEitherNameOrMatchAttribute_1Param,
Constants::ELEMNAME_TEMPLATE_WITH_PREFIX_STRING);
}
assert(m_name->isEmpty() == true || m_name->isValid() == true);
assert(m_mode->isEmpty() == true || m_mode->isValid() == true);
}
void
ElemLiteralResult::init(
StylesheetConstructionContext& constructionContext,
Stylesheet& stylesheetTree,
const XalanDOMChar* name,
const AttributeListType& atts)
{
assert(name != 0);
hasPrefix(indexOf(name, XalanUnicode::charColon) < length(name) ? true : false);
const unsigned int nAttrs = atts.getLength();
// This over-allocates, but we probably won't waste that much space.
m_avts = constructionContext.allocateAVTPointerVector(nAttrs);
assert(m_avts != 0);
const StylesheetConstructionContext::GetAndReleaseCachedString theGuard(constructionContext);
XalanDOMString& theBuffer = theGuard.get();
for(unsigned int i = 0; i < nAttrs; i++)
{
const XalanDOMChar* const aname = atts.getName(i);
bool needToProcess = true;
const XalanDOMString::size_type indexOfNSSep = indexOf(aname, XalanUnicode::charColon);
const XalanDOMString::size_type len = length(aname);
if(indexOfNSSep < len)
{
substring(aname, theBuffer, 0, indexOfNSSep);
if(!equals(theBuffer, DOMServices::s_XMLNamespace))
{
const XalanDOMString* const ns =
getNamespaceForPrefixInternal(theBuffer);
if(ns == 0)
{
constructionContext.error(
XalanMessageLoader::getMessage(XalanMessages::UndeclaredNamespacePrefix_1Param, theBuffer),
0,
this);
}
else if(equals(*ns, stylesheetTree.getXSLTNamespaceURI()))
{
theBuffer.assign(aname + indexOfNSSep + 1, len - (indexOfNSSep + 1));
if(processPrefixControl(constructionContext, stylesheetTree, theBuffer, atts.getValue(i)) == true)
{
needToProcess = false;
}
else if (equals(theBuffer, Constants::ATTRNAME_VERSION) == true)
{
const XalanDOMChar* const value = atts.getValue(i);
stylesheetTree.setXSLTVerDeclared(DoubleSupport::toDouble(value));
}
}
}
else
{
// don't process namespace decls
needToProcess = false;
}
}
if(needToProcess == true)
{
processSpaceAttr(aname, atts, i, constructionContext);
// Add xmlns attribute(except xmlns:xsl), xml:space, etc...
// Ignore anything with xsl:xxx
if(! processUseAttributeSets(constructionContext, aname, atts, i) &&
isAttrOK(aname, atts, i, constructionContext))
{
m_avts[m_avtsCount++] =
constructionContext.createAVT(getLocator(), aname, atts.getValue(i), *this);
}
}
}
}
XALAN_CPP_NAMESPACE_BEGIN
ElemElement::ElemElement(
StylesheetConstructionContext& constructionContext,
Stylesheet& stylesheetTree,
const AttributeListType& atts,
int lineNumber,
int columnNumber) :
ElemUse(constructionContext,
stylesheetTree,
lineNumber,
columnNumber,
StylesheetConstructionContext::ELEMNAME_ELEMENT),
m_nameAVT(0),
m_namespaceAVT(0)
{
// Namespace aliases are not used for xsl:element, so
// turn them off...
// m_namespacesHandler.setProcessNamespaceAliaises(false);
const unsigned int nAttrs = atts.getLength();
for(unsigned int i = 0; i < nAttrs; i++)
{
const XalanDOMChar* const aname = atts.getName(i);
if(equals(aname, Constants::ATTRNAME_NAME))
{
m_nameAVT =
constructionContext.createAVT(getLocator(), aname, atts.getValue(i), *this);
}
else if(equals(aname, Constants::ATTRNAME_NAMESPACE))
{
m_namespaceAVT =
constructionContext.createAVT(getLocator(), aname, atts.getValue(i), *this);
}
else if(!(processUseAttributeSets(constructionContext, aname, atts, i) ||
processSpaceAttr(aname, atts, i, constructionContext) ||
isAttrOK(aname, atts, i, constructionContext)))
{
constructionContext.error(
XalanMessageLoader::getMessage(
XalanMessages::TemplateHasIllegalAttribute_2Param,
Constants::ELEMNAME_ELEMENT_WITH_PREFIX_STRING.c_str(),
aname),
0,
this);
}
}
if(0 == m_nameAVT)
{
constructionContext.error(
XalanMessageLoader::getMessage(XalanMessages::TemplateMustHaveAttribute_2Param
,Constants::ELEMNAME_ELEMENT_WITH_PREFIX_STRING
,Constants::ATTRNAME_NAME),
0,
this);
}
}
XALAN_CPP_NAMESPACE_BEGIN
ElemWithParam::ElemWithParam(
StylesheetConstructionContext& constructionContext,
Stylesheet& stylesheetTree,
const AttributeListType& atts,
int lineNumber,
int columnNumber) :
ElemTemplateElement(constructionContext,
stylesheetTree,
lineNumber,
columnNumber,
StylesheetConstructionContext::ELEMNAME_WITH_PARAM),
m_selectPattern(0),
m_qname(0)
{
const unsigned int nAttrs = atts.getLength();
for(unsigned int i = 0; i < nAttrs; i++)
{
const XalanDOMChar* const aname = atts.getName(i);
if(equals(aname, Constants::ATTRNAME_SELECT))
{
m_selectPattern = constructionContext.createXPath(getLocator(), atts.getValue(i), *this);
}
else if(equals(aname, Constants::ATTRNAME_NAME))
{
m_qname = constructionContext.createXalanQName(
atts.getValue(i),
stylesheetTree.getNamespaces(),
getLocator());
if (m_qname->isValid() == false)
{
constructionContext.error(
XalanMessageLoader::getMessage(
XalanMessages::AttributeValueNotValidQName_2Param,
Constants::ATTRNAME_NAME.c_str(),
atts.getValue(i)),
0,
this);
}
}
else if(!isAttrOK(aname, atts, i, constructionContext))
{
constructionContext.error(
XalanMessageLoader::getMessage(
XalanMessages::TemplateHasIllegalAttribute_2Param,
Constants::ELEMNAME_WITHPARAM_WITH_PREFIX_STRING.c_str(),
aname),
0,
this);
}
}
if(m_qname == 0)
{
constructionContext.error(
XalanMessageLoader::getMessage(
XalanMessages::TemplateMustHaveAttribute_2Param,
Constants::ELEMNAME_WITHPARAM_WITH_PREFIX_STRING,
Constants::ATTRNAME_NAME),
0,
this);
}
}
void CodeGenModule::ConstructAttributeList(const CGFunctionInfo &FI,
const Decl *TargetDecl,
AttributeListType &PAL,
unsigned &CallingConv) {
unsigned FuncAttrs = 0;
unsigned RetAttrs = 0;
CallingConv = FI.getEffectiveCallingConvention();
// FIXME: handle sseregparm someday...
if (TargetDecl) {
if (TargetDecl->hasAttr<NoThrowAttr>())
FuncAttrs |= llvm::Attribute::NoUnwind;
if (TargetDecl->hasAttr<NoReturnAttr>())
FuncAttrs |= llvm::Attribute::NoReturn;
if (TargetDecl->hasAttr<ConstAttr>())
FuncAttrs |= llvm::Attribute::ReadNone;
else if (TargetDecl->hasAttr<PureAttr>())
FuncAttrs |= llvm::Attribute::ReadOnly;
if (TargetDecl->hasAttr<MallocAttr>())
RetAttrs |= llvm::Attribute::NoAlias;
}
if (CodeGenOpts.OptimizeSize)
FuncAttrs |= llvm::Attribute::OptimizeForSize;
if (CodeGenOpts.DisableRedZone)
FuncAttrs |= llvm::Attribute::NoRedZone;
if (CodeGenOpts.NoImplicitFloat)
FuncAttrs |= llvm::Attribute::NoImplicitFloat;
QualType RetTy = FI.getReturnType();
unsigned Index = 1;
const ABIArgInfo &RetAI = FI.getReturnInfo();
switch (RetAI.getKind()) {
case ABIArgInfo::Extend:
if (RetTy->isSignedIntegerType()) {
RetAttrs |= llvm::Attribute::SExt;
} else if (RetTy->isUnsignedIntegerType()) {
RetAttrs |= llvm::Attribute::ZExt;
}
// FALLTHROUGH
case ABIArgInfo::Direct:
break;
case ABIArgInfo::Indirect:
PAL.push_back(llvm::AttributeWithIndex::get(Index,
llvm::Attribute::StructRet |
llvm::Attribute::NoAlias));
++Index;
// sret disables readnone and readonly
FuncAttrs &= ~(llvm::Attribute::ReadOnly |
llvm::Attribute::ReadNone);
break;
case ABIArgInfo::Ignore:
case ABIArgInfo::Coerce:
break;
case ABIArgInfo::Expand:
assert(0 && "Invalid ABI kind for return argument");
}
if (RetAttrs)
PAL.push_back(llvm::AttributeWithIndex::get(0, RetAttrs));
// FIXME: we need to honour command line settings also...
// FIXME: RegParm should be reduced in case of nested functions and/or global
// register variable.
signed RegParm = 0;
if (TargetDecl)
if (const RegparmAttr *RegParmAttr
= TargetDecl->getAttr<RegparmAttr>())
RegParm = RegParmAttr->getNumParams();
unsigned PointerWidth = getContext().Target.getPointerWidth(0);
for (CGFunctionInfo::const_arg_iterator it = FI.arg_begin(),
ie = FI.arg_end(); it != ie; ++it) {
QualType ParamType = it->type;
const ABIArgInfo &AI = it->info;
unsigned Attributes = 0;
switch (AI.getKind()) {
case ABIArgInfo::Coerce:
break;
case ABIArgInfo::Indirect:
if (AI.getIndirectByVal())
Attributes |= llvm::Attribute::ByVal;
Attributes |=
llvm::Attribute::constructAlignmentFromInt(AI.getIndirectAlign());
// byval disables readnone and readonly.
FuncAttrs &= ~(llvm::Attribute::ReadOnly |
llvm::Attribute::ReadNone);
break;
case ABIArgInfo::Extend:
if (ParamType->isSignedIntegerType()) {
Attributes |= llvm::Attribute::SExt;
} else if (ParamType->isUnsignedIntegerType()) {
Attributes |= llvm::Attribute::ZExt;
}
// FALLS THROUGH
case ABIArgInfo::Direct:
if (RegParm > 0 &&
(ParamType->isIntegerType() || ParamType->isPointerType())) {
RegParm -=
(Context.getTypeSize(ParamType) + PointerWidth - 1) / PointerWidth;
if (RegParm >= 0)
Attributes |= llvm::Attribute::InReg;
}
// FIXME: handle sseregparm someday...
break;
case ABIArgInfo::Ignore:
// Skip increment, no matching LLVM parameter.
continue;
case ABIArgInfo::Expand: {
std::vector<const llvm::Type*> Tys;
// FIXME: This is rather inefficient. Do we ever actually need to do
// anything here? The result should be just reconstructed on the other
// side, so extension should be a non-issue.
getTypes().GetExpandedTypes(ParamType, Tys);
Index += Tys.size();
continue;
}
}
if (Attributes)
PAL.push_back(llvm::AttributeWithIndex::get(Index, Attributes));
++Index;
}
if (FuncAttrs)
PAL.push_back(llvm::AttributeWithIndex::get(~0, FuncAttrs));
}
