llvm-svn: 20245

llvm-svn: 20244

llvm-svn: 20243

llvm-svn: 20242

spaces in path names and not confuse the shell.

llvm-svn: 20241

variable so that spaces don't screw it up.

llvm-svn: 20240

llvm-svn: 20239

* --config-file is really --config-dir, according to `llvmc --help'

llvm-svn: 20238

llvm-svn: 20237

llvm-svn: 20233

llvm-svn: 20232

llvm-svn: 20231

for 0.0 and -0.0.

llvm-svn: 20230

llvm-svn: 20229

Don't sink argument loads into loops or other bad places.  This disables folding of argument loads with instructions that are not in the entry block.

llvm-svn: 20228

and handle incomplete control dependences correctly.  This fixes:

Regression/Transforms/ADCE/dead-phi-edge.ll
  -> a missed optimization

Regression/Transforms/ADCE/dead-phi-edge.ll
  -> a compiler crash distilled from QT4

llvm-svn: 20227

llvm-svn: 20226

and PR515.

llvm-svn: 20224

llvm-svn: 20223

The install target in Makefile.rules no longer uses pax but just uses find
and "install" instead.

llvm-svn: 20216

llvm-svn: 20215

* Make it possible to have the Install program run in verbose mode when
  the TOOL_VERBOSE=1 option is set
* Ensure non-executable installed files do not install with execute perms.

llvm-svn: 20214

llvm-svn: 20213

llvm-svn: 20212

llvm-svn: 20211

llvm-svn: 20208

llvm-svn: 20207

for the suggestion! :)

llvm-svn: 20203

llvm-svn: 20202

llvm-svn: 20201

handling zero length files a little more intelligently. If both files are
zero length then we return 0 (true) indicating a match. If only one of the
files is zero length then we return 1 (false) indicating that the files
differ. If the files don't agree in length then they can't match so we
skip the first loop that looks for a quick match.

llvm-svn: 20200

llvm-svn: 20198

to save and restore the LR register on entry and exit of a leaf function
that needed to access globals or the constant pool.  This should hopefully
fix oscar from sending the PPC tester spinning out of control.

llvm-svn: 20197

llvm-svn: 20195

llvm-svn: 20194

llvm-svn: 20193

void %test(int** %P) {
  %A = volatile load int** %P
  ret void
}

void %test2(int*** %Q) {
  %P = load int*** %Q
  volatile store int** %P, int*** %Q
  ret void
}

instead of emitting:

void test(int **l1_P) {
  int *l2_A;

  l2_A = (int **((volatile int **)l1_P));
  return;
}
void test2(int ***l2_Q) {
  int **l1_P;

  l1_P = *l2_Q;
  *((volatile int ***)l2_Q) = l1_P;
  return;
}

... which is loading/storing volatile pointers, not through volatile pointers,
emit this (which is right):

void test(int **l1_P) {
  int *l3_A;

  l3_A = *((int * volatile*)l1_P);
  return;
}
void test2(int ***l2_Q) {
  int **l1_P;

  l1_P = *l2_Q;
  *((int ** volatile*)l2_Q) = l1_P;
  return;
}

llvm-svn: 20191

llvm-svn: 20190

llvm-svn: 20189

llvm-svn: 20187