← Back to branch summary

~ubuntu-branches/ubuntu/feisty/clamav/feisty

« back to all changes in this revision

Viewing changes to libclamav/c++/llvm/lib/CodeGen/CallingConvLower.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Kees Cook
  • Date: 2007-02-20 10:33:44 UTC
  • mto: This revision was merged to the branch mainline in revision 16.
  • Revision ID: james.westby@ubuntu.com-20070220103344-zgcu2psnx9d98fpa
Tags: upstream-0.90
Import upstream version 0.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
libclamav/c++/llvm/lib/CodeGen/CallingConvLower.cpp
1
 
//===-- CallingConvLower.cpp - Calling Conventions ------------------------===//
2
 
//
3
 
//                     The LLVM Compiler Infrastructure
4
 
//
5
 
// This file is distributed under the University of Illinois Open Source
6
 
// License. See LICENSE.TXT for details.
7
 
//
8
 
//===----------------------------------------------------------------------===//
9
 
//
10
 
// This file implements the CCState class, used for lowering and implementing
11
 
// calling conventions.
12
 
//
13
 
//===----------------------------------------------------------------------===//
14
 
 
15
 
#include "llvm/CodeGen/CallingConvLower.h"
16
 
#include "llvm/Support/Debug.h"
17
 
#include "llvm/Support/ErrorHandling.h"
18
 
#include "llvm/Support/raw_ostream.h"
19
 
#include "llvm/Target/TargetRegisterInfo.h"
20
 
#include "llvm/Target/TargetData.h"
21
 
#include "llvm/Target/TargetMachine.h"
22
 
using namespace llvm;
23
 
 
24
 
CCState::CCState(CallingConv::ID CC, bool isVarArg, const TargetMachine &tm,
25
 
                 SmallVector<CCValAssign, 16> &locs, LLVMContext &C)
26
 
  : CallingConv(CC), IsVarArg(isVarArg), TM(tm),
27
 
    TRI(*TM.getRegisterInfo()), Locs(locs), Context(C) {
28
 
  // No stack is used.
29
 
  StackOffset = 0;
30
 
  
31
 
  UsedRegs.resize((TRI.getNumRegs()+31)/32);
32
 
}
33
 
 
34
 
// HandleByVal - Allocate a stack slot large enough to pass an argument by
35
 
// value. The size and alignment information of the argument is encoded in its
36
 
// parameter attribute.
37
 
void CCState::HandleByVal(unsigned ValNo, EVT ValVT,
38
 
                          EVT LocVT, CCValAssign::LocInfo LocInfo,
39
 
                          int MinSize, int MinAlign,
40
 
                          ISD::ArgFlagsTy ArgFlags) {
41
 
  unsigned Align = ArgFlags.getByValAlign();
42
 
  unsigned Size  = ArgFlags.getByValSize();
43
 
  if (MinSize > (int)Size)
44
 
    Size = MinSize;
45
 
  if (MinAlign > (int)Align)
46
 
    Align = MinAlign;
47
 
  unsigned Offset = AllocateStack(Size, Align);
48
 
 
49
 
  addLoc(CCValAssign::getMem(ValNo, ValVT, Offset, LocVT, LocInfo));
50
 
}
51
 
 
52
 
/// MarkAllocated - Mark a register and all of its aliases as allocated.
53
 
void CCState::MarkAllocated(unsigned Reg) {
54
 
  UsedRegs[Reg/32] |= 1 << (Reg&31);
55
 
  
56
 
  if (const unsigned *RegAliases = TRI.getAliasSet(Reg))
57
 
    for (; (Reg = *RegAliases); ++RegAliases)
58
 
      UsedRegs[Reg/32] |= 1 << (Reg&31);
59
 
}
60
 
 
61
 
/// AnalyzeFormalArguments - Analyze an array of argument values,
62
 
/// incorporating info about the formals into this state.
63
 
void
64
 
CCState::AnalyzeFormalArguments(const SmallVectorImpl<ISD::InputArg> &Ins,
65
 
                                CCAssignFn Fn) {
66
 
  unsigned NumArgs = Ins.size();
67
 
 
68
 
  for (unsigned i = 0; i != NumArgs; ++i) {
69
 
    EVT ArgVT = Ins[i].VT;
70
 
    ISD::ArgFlagsTy ArgFlags = Ins[i].Flags;
71
 
    if (Fn(i, ArgVT, ArgVT, CCValAssign::Full, ArgFlags, *this)) {
72
 
#ifndef NDEBUG
73
 
      dbgs() << "Formal argument #" << i << " has unhandled type "
74
 
             << ArgVT.getEVTString();
75
 
#endif
76
 
      llvm_unreachable(0);
77
 
    }
78
 
  }
79
 
}
80
 
 
81
 
/// CheckReturn - Analyze the return values of a function, returning true if
82
 
/// the return can be performed without sret-demotion, and false otherwise.
83
 
bool CCState::CheckReturn(const SmallVectorImpl<ISD::OutputArg> &Outs,
84
 
                          CCAssignFn Fn) {
85
 
  // Determine which register each value should be copied into.
86
 
  for (unsigned i = 0, e = Outs.size(); i != e; ++i) {
87
 
    EVT VT = Outs[i].VT;
88
 
    ISD::ArgFlagsTy ArgFlags = Outs[i].Flags;
89
 
    if (Fn(i, VT, VT, CCValAssign::Full, ArgFlags, *this))
90
 
      return false;
91
 
  }
92
 
  return true;
93
 
}
94
 
 
95
 
/// AnalyzeReturn - Analyze the returned values of a return,
96
 
/// incorporating info about the result values into this state.
97
 
void CCState::AnalyzeReturn(const SmallVectorImpl<ISD::OutputArg> &Outs,
98
 
                            CCAssignFn Fn) {
99
 
  // Determine which register each value should be copied into.
100
 
  for (unsigned i = 0, e = Outs.size(); i != e; ++i) {
101
 
    EVT VT = Outs[i].VT;
102
 
    ISD::ArgFlagsTy ArgFlags = Outs[i].Flags;
103
 
    if (Fn(i, VT, VT, CCValAssign::Full, ArgFlags, *this)) {
104
 
#ifndef NDEBUG
105
 
      dbgs() << "Return operand #" << i << " has unhandled type "
106
 
             << VT.getEVTString();
107
 
#endif
108
 
      llvm_unreachable(0);
109
 
    }
110
 
  }
111
 
}
112
 
 
113
 
/// AnalyzeCallOperands - Analyze the outgoing arguments to a call,
114
 
/// incorporating info about the passed values into this state.
115
 
void CCState::AnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> &Outs,
116
 
                                  CCAssignFn Fn) {
117
 
  unsigned NumOps = Outs.size();
118
 
  for (unsigned i = 0; i != NumOps; ++i) {
119
 
    EVT ArgVT = Outs[i].VT;
120
 
    ISD::ArgFlagsTy ArgFlags = Outs[i].Flags;
121
 
    if (Fn(i, ArgVT, ArgVT, CCValAssign::Full, ArgFlags, *this)) {
122
 
#ifndef NDEBUG
123
 
      dbgs() << "Call operand #" << i << " has unhandled type "
124
 
             << ArgVT.getEVTString();
125
 
#endif
126
 
      llvm_unreachable(0);
127
 
    }
128
 
  }
129
 
}
130
 
 
131
 
/// AnalyzeCallOperands - Same as above except it takes vectors of types
132
 
/// and argument flags.
133
 
void CCState::AnalyzeCallOperands(SmallVectorImpl<EVT> &ArgVTs,
134
 
                                  SmallVectorImpl<ISD::ArgFlagsTy> &Flags,
135
 
                                  CCAssignFn Fn) {
136
 
  unsigned NumOps = ArgVTs.size();
137
 
  for (unsigned i = 0; i != NumOps; ++i) {
138
 
    EVT ArgVT = ArgVTs[i];
139
 
    ISD::ArgFlagsTy ArgFlags = Flags[i];
140
 
    if (Fn(i, ArgVT, ArgVT, CCValAssign::Full, ArgFlags, *this)) {
141
 
#ifndef NDEBUG
142
 
      dbgs() << "Call operand #" << i << " has unhandled type "
143
 
             << ArgVT.getEVTString();
144
 
#endif
145
 
      llvm_unreachable(0);
146
 
    }
147
 
  }
148
 
}
149
 
 
150
 
/// AnalyzeCallResult - Analyze the return values of a call,
151
 
/// incorporating info about the passed values into this state.
152
 
void CCState::AnalyzeCallResult(const SmallVectorImpl<ISD::InputArg> &Ins,
153
 
                                CCAssignFn Fn) {
154
 
  for (unsigned i = 0, e = Ins.size(); i != e; ++i) {
155
 
    EVT VT = Ins[i].VT;
156
 
    ISD::ArgFlagsTy Flags = Ins[i].Flags;
157
 
    if (Fn(i, VT, VT, CCValAssign::Full, Flags, *this)) {
158
 
#ifndef NDEBUG
159
 
      dbgs() << "Call result #" << i << " has unhandled type "
160
 
             << VT.getEVTString();
161
 
#endif
162
 
      llvm_unreachable(0);
163
 
    }
164
 
  }
165
 
}
166
 
 
167
 
/// AnalyzeCallResult - Same as above except it's specialized for calls which
168
 
/// produce a single value.
169
 
void CCState::AnalyzeCallResult(EVT VT, CCAssignFn Fn) {
170
 
  if (Fn(0, VT, VT, CCValAssign::Full, ISD::ArgFlagsTy(), *this)) {
171
 
#ifndef NDEBUG
172
 
    dbgs() << "Call result has unhandled type "
173
 
           << VT.getEVTString();
174
 
#endif
175
 
    llvm_unreachable(0);
176
 
  }
177
 
}